File - Code Metrics - kakserpom/phpdaemon - Measure and Improve Code Quality continuously with Scrutinizer

File F
last analyzed 2021-06-02 17:17 UTC

↳ Parent: Project

Complexity

Total Complexity

120

Size/Duplication

Total Lines	781
Duplicated Lines	18.05 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

Metric	Value
dl	141
loc	781
rs	1.819
c	0
b	0
f	0
wmc	120
lcom	1
cbo	6

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getFd()	0	4	1
B	convertFlags()	0	21	8
B	truncate()	19	19	7
B	stat()	4	23	6
A	statRefresh()	4	19	5
B	statvfs()	0	24	6
A	sync()	14	15	4
A	datasync()	14	15	4
B	write()	10	48	10
B	chown()	21	21	7
A	touch()	0	18	5
A	clearStatCache()	0	5	1
B	read()	8	28	7
D	sendfile()	0	82	16
B	readahead()	0	25	6
A	readAllGenHandler()	14	15	3
A	readAll()	12	36	5
A	readAllChunkedGenHandler()	12	22	2
A	readAllChunked()	9	31	4
A	__toString()	0	4	1
A	setChunkSize()	0	4	1
A	seek()	0	9	2
A	tell()	0	7	2
A	close()	0	21	5
A	__destruct()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like File often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use File, and based on these observations, apply Extract Interface, too.

<?php
namespace PHPDaemon\FS;

use PHPDaemon\Core\CallbackWrapper;
use PHPDaemon\Network\IOStream;
use PHPDaemon\Structures\StackCallbacks;

/**
 * File
 * @package PHPDaemon\FS
 * @author  Vasily Zorin <[email protected]>
 */
class File
{
    use \PHPDaemon\Traits\ClassWatchdog;
    use \PHPDaemon\Traits\StaticObjectWatchdog;

    /**
     * @var integer Priority
     */
    public $priority = 10;

    /**
     * @var integer Chunk size
     */
    public $chunkSize = 4096;

    /**
     * @var string $stat hash Stat
     */
    protected $stat;

    /**
     * @var array Cache of statvfs()
     */
    protected $statvfs;

    /**
     * @var integer Current offset
     */
    public $offset = 0;

    /**
     * @var string Cache key
     */
    public $fdCacheKey;

    /**
     * @var boolean Append?
     */
    public $append;

    /**
     * @var string Path
     */
    public $path;

    /**
     * @var boolean Writing?
     */
    public $writing = false;

    /**
     * @var boolean Closed?
     */
    public $closed = false;

    /**
     * @var object File descriptor
     */
    protected $fd;

    /**
     * @var PHPDaemon\Structures\StackCallbacks Stack of callbacks called when writing is done
     */
    protected $onWriteOnce;

    /**
     * File constructor
     * @param resource $fd Descriptor
     * @param string $path Path
     */
    public function __construct($fd, $path)
    {
        $this->fd = $fd;

        $this->path = $path;
        $this->onWriteOnce = new StackCallbacks;

    }

    /**
     * Get file descriptor
     * @return resource File descriptor

     */
    public function getFd()
    {
        return $this->fd;
    }

    /**
     * Converts string of flags to integer or standard text representation
     * @param  string $mode Mode
     * @param  boolean $text Text?
     * @return mixed
     */
    public static function convertFlags($mode, $text = false)
    {
        $plus = mb_orig_strpos($mode, '+') !== false;
        $sync = mb_orig_strpos($mode, 's') !== false;
        $type = strtr($mode, ['b' => '', '+' => '', 's' => '', '!' => '']);
        if ($text) {
            return $type;
        }
        $types = [
            'r' => $plus ? EIO_O_RDWR : EIO_O_RDONLY,
            'w' => ($plus ? EIO_O_RDWR : EIO_O_WRONLY) | EIO_O_CREAT | EIO_O_TRUNC,
            'a' => ($plus ? EIO_O_RDWR : EIO_O_WRONLY) | EIO_O_CREAT | EIO_O_APPEND,
            'x' => ($plus ? EIO_O_RDWR : EIO_O_WRONLY) | EIO_O_EXCL | EIO_O_CREAT,
            'c' => ($plus ? EIO_O_RDWR : EIO_O_WRONLY) | EIO_O_CREAT,
        ];
        $m = $types[$type];
        if ($sync) {
            $m |= EIO_O_FSYNC;
        }
        return $m;
    }

    /**
     * Truncates this file
     * @param  integer $offset Offset. Default is 0
     * @param  callable $cb Callback

     * @param  integer $pri Priority
     * @return resource|boolean
     */
    public function truncate($offset = 0, $cb = null, $pri = EIO_PRI_DEFAULT)

    {
        $cb = CallbackWrapper::forceWrap($cb);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if (!$this->fd || $this->fd === -1) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {
            $fp = fopen($this->path, 'r+');
            $r = $fp && ftruncate($fp, $offset);
            if ($cb) {
                $cb($this, $r);
            }
            return $r;
        }
        return eio_ftruncate($this->fd, $offset, $pri, $cb, $this);
    }

    /**
     * Stat()
     * @param  callable $cb Callback
     * @param  integer $pri Priority
     * @return resource|boolean
     */
    public function stat($cb, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
        if (!$this->fd || $this->fd === -1) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {

            $cb($this, FileSystem::statPrepare(fstat($this->fd)));
            return false;
        }
        if ($this->stat) {
            $cb($this, $this->stat);
            return true;
        }
        return eio_fstat($this->fd, $pri, function ($file, $stat) use ($cb) {
            $stat = FileSystem::statPrepare($stat);
            $file->stat = $stat;
            $cb($file, $stat);
        }, $this);
    }

    /**
     * Stat() non-cached
     * @param  callable $cb Callback
     * @param  integer $pri Priority
     * @return resource|boolean
     */
    public function statRefresh($cb, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
        if (!$this->fd || $this->fd === -1) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {

            $cb($this, FileSystem::statPrepare(fstat($this->fd)));
            return true;
        }
        return eio_fstat($this->fd, $pri, function ($file, $stat) use ($cb) {
            $stat = FileSystem::statPrepare($stat);
            $file->stat = $stat;
            $cb($file, $stat);
        }, $this);
    }

    /**
     * Statvfs()
     * @param  callable $cb Callback
     * @param  integer $pri Priority
     * @return resource|boolean
     */
    public function statvfs($cb, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if ($this->statvfs) {

            $cb($this, $this->statvfs);
            return true;
        }
        return eio_fstatvfs($this->fd, $pri, function ($file, $stat) use ($cb) {
            $file->statvfs = $stat;
            $cb($file, $stat);
        }, $this);
    }

    /**
     * Sync()
     * @param  callable $cb Callback
     * @param  integer $pri Priority
     * @return resource|false
     */
    public function sync($cb, $pri = EIO_PRI_DEFAULT)

    {
        $cb = CallbackWrapper::forceWrap($cb);
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {
            $cb($this, true);
            return false;
        }
        return eio_fsync($this->fd, $pri, $cb, $this);
    }

    /**
     * Datasync()
     * @param  callable $cb Callback
     * @param  integer $pri Priority
     * @return resource|false
     */
    public function datasync($cb, $pri = EIO_PRI_DEFAULT)

    {
        $cb = CallbackWrapper::forceWrap($cb);
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {
            $cb($this, true);
            return false;
        }
        return eio_fdatasync($this->fd, $pri, $cb, $this);
    }

    /**
     * Writes data to file
     * @param  string $data Data
     * @param  callable $cb Callback

     * @param  integer $offset Offset

     * @param  integer $pri Priority
     * @return resource|false
     */
    public function write($data, $cb = null, $offset = null, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if ($data === '') {
            if ($cb) {
                $cb($this, 0);
            }
            return false;
        }
        if (!FileSystem::$supported) {

            if ($offset !== null) {
                fseek($data, $offset);
            }
            $r = fwrite($this->fd, $data);
            if ($cb) {
                $cb($this, $r);
            }
            return false;
        }
        if ($cb !== null) {
            $this->onWriteOnce->push($cb);
        }
        $l = mb_orig_strlen($data);
        if ($offset === null) {
            $offset = $this->offset;
            $this->offset += $l;
        }
        $this->writing = true;
        $res = eio_write(
            $this->fd,
            $data,
            $l,
            $offset,
            $pri,
            function ($file, $result) {
                $this->writing = false;
                $this->onWriteOnce->executeAll($file, $result);
            },
            $this
        );
        return $res;
    }

    /**
     * Changes ownership of this file
     * @param  integer $uid User ID
     * @param  integer $gid Group ID
     * @param  callable $cb = null Callback

     * @param  integer $pri = EIO_PRI_DEFAULT Priority
     * @return resource|false
     */
    public function chown($uid, $gid = -1, $cb = null, $pri = EIO_PRI_DEFAULT)

    {
        $cb = CallbackWrapper::forceWrap($cb);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {
            $r = chown($this->path, $uid);
            if ($gid !== -1) {
                $r = $r && chgrp($this->path, $gid);
            }
            if ($cb) {
                $cb($this, $r);
            }
            return false;
        }
        return eio_fchown($this->fd, $uid, $gid, $pri, $cb, $this);
    }

    /**
     * touch()
     * @param  integer $mtime Last modification time
     * @param  integer $atime Last access time

     * @param  callable $cb Callback

     * @param  integer $pri Priority
     * @return resource|false
     */
    public function touch($mtime, $atime = null, $cb = null, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {
            $r = touch($this->path, $mtime, $atime);
            if ($cb) {
                $cb($this, $r);
            }
            return false;
        }
        return eio_futime($this->fd, $atime, $mtime, $pri, $cb, $this);
    }

    /**
     * Clears cache of stat() and statvfs()
     * @return void
     */
    public function clearStatCache()
    {
        $this->stat = null;
        $this->statvfs = null;

    }

    /**
     * Reads data from file
     * @param  integer $length Length
     * @param  integer $offset Offset

     * @param  callable $cb Callback

     * @param  integer $pri Priority
     * @return boolean

     */
    public function read($length, $offset = null, $cb = null, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {

            if ($offset !== null) {
                fseek($this->fd, $length);
            }
            $data = fread($this->fd, $length);
            $cb === null || $cb($this, $data);
            return $data;
        }
        $this->offset += $length;
        eio_read(
            $this->fd,
            $length,
            $offset !== null ? $offset : $this->offset,
            $pri,
            $cb,
            $this
        );
        return true;
    }

    /**
     * sendfile()
     * @param  mixed $outfd File descriptor
     * @param  callable $cb Callback
     * @param  callable $startCb Start callback

     * @param  integer $offset Offset
     * @param  integer $length Length

     * @param  integer $pri Priority
     * @return boolean           Success
     */
    public function sendfile($outfd, $cb, $startCb = null, $offset = 0, $length = null, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        static $chunkSize = 1024;
        $ret = true;

        $handler = function (
            $file,
            $sent = -1
        ) use (
            &$ret,
            $outfd,
            $cb,
            &$handler,
            &$offset,
            &$length,
            $pri,
            $chunkSize
        ) {
            if ($outfd instanceof IOStream) {
                if ($outfd->isFreed()) {
                    $cb($file, false);
                    return;
                }
                $ofd = $outfd->getFd();
            } else {
                $ofd = $outfd;
            }
            if (!$ret) {
                $cb($file, false);
                return;
            }
            if ($sent === -1) {
                $sent = 0;
            }
            $offset += $sent;
            $length -= $sent;
            if ($length <= 0) {
                $cb($file, true);
                return;
            }
            if (!$ofd) {
                $cb($file, false);
                return;
            }
            $c = min($chunkSize, $length);
            $ret = eio_sendfile($ofd, $file->fd, $offset, $c, $pri, $handler, $file);
        };
        if ($length !== null) {
            if ($startCb !== null) {
                if (!$startCb($this, $length, $handler)) {
                    $handler($this);
                }
            } else {
                $handler($this);
            }
            return true;
        }
        $this->statRefresh(function ($file, $stat) use ($startCb, $handler, &$length) {
            $length = $stat['size'];
            if ($startCb !== null) {
                if (!$startCb($file, $length, $handler)) {
                    $handler($file);
                }
            } else {
                $handler($file);
            }
        }, $pri);
        return true;
    }

    /**
     * readahead()
     * @param  integer $length Length
     * @param  integer $offset Offset

     * @param  callable $cb Callback

     * @param  integer $pri Priority
     * @return resource|false
     */
    public function readahead($length, $offset = null, $cb = null, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        if (!FileSystem::$supported) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        $this->offset += $length;
        return eio_readahead(
            $this->fd,
            $length,
            $offset !== null ? $offset : $this->offset,
            $pri,
            $cb,
            $this
        );
    }

    /**
     * Generates closure-callback for readAll
     * @param  callable $cb
     * @param  integer $size
     * @param  integer &$offset
     * @param  integer &$pri
     * @param  string &$buf
     * @return callable
     */
    protected function readAllGenHandler($cb, $size, &$offset, &$pri, &$buf)

    {
        return function ($file, $data) use ($cb, $size, &$offset, &$pri, &$buf) {
            $buf .= $data;
            $offset += mb_orig_strlen($data);
            $len = min($file->chunkSize, $size - $offset);
            if ($offset >= $size) {
                if ($cb) {
                    $cb($file, $buf);
                }
                return;
            }
            eio_read($file->fd, $len, $offset, $pri, $this->readAllGenHandler($cb, $size, $offset, $pri, $buf), $this);
        };
    }

    /**
     * Reads whole file
     * @param  callable $cb Callback
     * @param  integer $pri Priority
     * @return boolean       Success
     */
    public function readAll($cb, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        $this->statRefresh(
            function ($file, $stat) use ($cb, $pri) {

                if (!$stat) {
                    if ($cb) {
                        $cb($file, false);
                    }
                    return;
                }

                $offset = 0;
                $buf = '';
                $size = $stat['size'];

                eio_read(
                    $file->fd,
                    min($file->chunkSize, $size),
                    0,
                    $pri,
                    $this->readAllGenHandler($cb, $size, $offset, $pri, $buf),
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                    $file
                );
            },
            $pri
        );

        return true;
    }

    /**
     * Generates closure-callback for readAllChunked
     * @param  callable $cb
     * @param  callable $chunkcb
     * @param  integer $size
     * @param  integer $offset
     * @param  integer $pri
     * @return callable
     */
    protected function readAllChunkedGenHandler($cb, $chunkcb, $size, &$offset, $pri)

    {
        return function ($file, $data) use ($cb, $chunkcb, $size, &$offset, $pri) {
            $chunkcb($file, $data);
            $offset += mb_orig_strlen($data);
            $len = min($file->chunkSize, $size - $offset);

            if ($offset >= $size) {
                $cb($file, true);
                return;
            }

            eio_read(
                $file->fd,
                $len,
                $offset,
                $pri,
                $this->readAllChunkedGenHandler($cb, $chunkcb, $size, $offset, $pri),
                $file
            );
        };
    }

    /**
     * Reads file chunk-by-chunk
     * @param  callable $cb Callback

     * @param  callable $chunkcb Callback of chunk

     * @param  integer $pri Priority
     * @return resource|false

     */
    public function readAllChunked($cb = null, $chunkcb = null, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if (!$this->fd) {
            if ($cb) {
                $cb($this, false);
            }
            return false;
        }
        return $this->statRefresh(
            function ($file, $stat) use ($cb, $chunkcb, $pri) {

                if (!$stat) {
                    $cb($file, false);
                    return;
                }

                $offset = 0;
                $size = $stat['size'];

                eio_read(
                    $file->fd,
                    min($file->chunkSize, $size),
                    $offset,
                    $pri,
                    $this->readAllChunkedGenHandler($cb, $chunkcb, $size, $offset, $pri),
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                    $file
                );
            },
            $pri
        );
    }

    /**
     * toString handler
     * @return string
     */
    public function __toString()
    {
        return $this->path;
    }

    /**
     * Set chunk size
     * @param  integer $n Chunk size
     * @return void
     */
    public function setChunkSize($n)
    {
        $this->chunkSize = $n;
    }

    /**
     * Move pointer to arbitrary position
     * @param  integer $offset Offset
     * @param  callable $cb Callback
     * @param  integer $pri Priority
     * @return resource|false
     */
    public function seek($offset, $cb, $pri = EIO_PRI_DEFAULT)
    {
        $cb = CallbackWrapper::forceWrap($cb);
        if (!\EIO::$supported) {
            fseek($this->fd, $offset);
            return false;
        }
        return eio_seek($this->fd, $offset, $pri, $cb, $this);
    }

    /**
     * Get current pointer position
     * @return integer
     */
    public function tell()
    {
        if (\EIO::$supported) {
            return $this->offset;
        }
        return ftell($this->fd);
    }

    /**
     * Close the file
     * @return resource|false
     */
    public function close()
    {
        if ($this->closed) {
            return false;
        }
        $this->closed = true;
        if ($this->fdCacheKey !== null) {
            FileSystem::$fdCache->invalidate($this->fdCacheKey);
        }
        if ($this->fd === null) {
            return false;
        }

        if (!FileSystem::$supported) {
            fclose($this->fd);
            return false;
        }
        $r = eio_close($this->fd, EIO_PRI_MAX);
        $this->fd = null;
        return $r;
    }

    /**
     * Destructor
     */
    public function __destruct()
    {
        $this->close();
    }
}


1			<?php
2			namespace PHPDaemon\FS;
3
4			use PHPDaemon\Core\CallbackWrapper;
5			use PHPDaemon\Network\IOStream;
6			use PHPDaemon\Structures\StackCallbacks;
7
8			/**
9			* File
10			* @package PHPDaemon\FS
11			* @author Vasily Zorin <[email protected]>
12			*/
13			class File
14			{
15			use \PHPDaemon\Traits\ClassWatchdog;
16			use \PHPDaemon\Traits\StaticObjectWatchdog;
17
18			/**
19			* @var integer Priority
20			*/
21			public $priority = 10;
22
23			/**
24			* @var integer Chunk size
25			*/
26			public $chunkSize = 4096;
27
28			/**
29			* @var string $stat hash Stat
30			*/
31			protected $stat;
32
33			/**
34			* @var array Cache of statvfs()
35			*/
36			protected $statvfs;
37
38			/**
39			* @var integer Current offset
40			*/

kakserpom / phpdaemon

File F last analyzed 2021-06-02 17:17 UTC