Returns the size of the limited subset of data, or null if the wrapped
stream returns null for getSize.

@return int|null
6190
public function getSize()
    {
        $size = $this->stream->getSize();
        if ($size === null) {
            // this shouldn't happen on a seekable stream I don't think...
            $pos = $this->stream->tell();
            $this->stream->seek(0, SEEK_END);
            $size = $this->stream->tell();
            $this->stream->seek($pos);
        }
        if ($this->limit === -1) {
            return $size - $this->offset;
        } else {
            return min([$this->limit, $size - $this->offset]);
        }
    }
1110125
public function getCellSize()
    {

        if (is_null($this->cellsizeCache)) {
            $dataType = $this->getDataType();

            if ($dataType->isInFile()) {
                throw new ErrorException("Size-getter for data-cells stored in file is not implemented yet!");
            }

            if (!is_null($this->length)) {
                $this->cellsizeCache = $this->getLength()+$this->getSecondLength();

            } else {
                $length = $dataType->getByteLength();
    
                $this->cellsizeCache = (int)$length;
            }
        }

        return $this->cellsizeCache;
    }
1186210
public function getSize() : int
    {
        $files = $this->getFiles();
        $size = 0;
        foreach($files as $file) {
            $size += $file->getSize();
        }
        return $size;
    }
1023241
public function getLength()
    {
        return in_array($this->schema, $this->lengthSchemas, true) ? $this->size : null;
    }
250675
public function getSize()
    {
        if (is_null($this->size)) {
            $this->size = is_null($this->getFile()) ? 0 : $this->getFile()->getSize();
        }
        return $this->size;
    }
75487
private function calculateSize()
    {
        // Clear the stat cache if the stream has a URI
        if ($this->uri) {
            clearstatcache(true, $this->uri);
        }

        $stats = fstat($this->stream);
        if (isset($stats[static::META_SIZE])) {
            $this->size = $stats[static::META_SIZE];

            return $this->size;
        }

        return null;
    }
461900
public function getBytes()
    {
        if ($this->isDirty && $this->bytes) {
            return $this->bytes;
        }
        if ($this->isDirty && $this->filename) {
            return file_get_contents($this->filename);
        }
        if ($this->riakGridFSFile instanceof \RiakGridFSFile) {
            return $this->riakGridFSFile->getBytes();
        }
        return null;
    }
934442
public function getSize()
    {
        $size = $this->getParameters()->get('size');
        if (\is_numeric($size)) {
            $size = (int) $size;
        }

        return $size;
    }
408604
public function size()
    {
        eZDebugSetting::writeDebug( 'kernel-clustering', "dfs::size()" );
        return isset( $this->metaData['size'] ) ? (int)$this->metaData['size'] : null;
    }
791878
protected function getSizeInfo()
	{
		$size = array();
		// since we check $i + 1 we need to stop one step earlier
		$this->dataLength = strlen($this->data) - 1;

		$sofStartRead = true;

		// Look through file for SOF marker
		for ($i = 2; $i < $this->dataLength; $i++)
		{
			$marker = $this->getNextMarker($i, $sofStartRead);

			if (in_array($marker, $this->sofMarkers))
			{
				// Extract size info from SOF marker
				return $this->extractSizeInfo($i);
			}
			else
			{
				// Extract length only
				$markerLength = $this->extractMarkerLength($i);

				if ($markerLength < 2)
				{
					return $size;
				}

				$i += $markerLength - 1;
				continue;
			}
		}

		return $size;
	}
1203436
public function size():int
    {
        if ($this->file == null) {
            throw new Server500(new \ArrayObject(array("explain" =>
                "Cannot get size for unopened file",
                "solution" =>
                    "Please open the file with [FileListener::open] before trying to get the size.")));
        }
        return (filesize($this->filepath));
    }
876478
protected int getSize()
   {      
      if (tc.isEntryEnabled()) SibTr.entry(this, tc, "getSize");
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "getSize", ""+size);
      return size;
   }
864195
public int getSize() {
        return 20 + (sacl == null ? 0 : sacl.getSize())
                + (dacl == null ? 0 : dacl.getSize())
                + (owner == null ? 0 : owner.getSize())
                + (group == null ? 0 : group.getSize());
    }
289428
public function getSizeValue()
    {
        if (is_null($this->size)) {
            $this->size = $this->getFirst('size');
        }

        return $this->size;
    }
1189365
@Override
    public int size () {
        return 4 + ( this.hashAlgos != null ? 2 * this.hashAlgos.length : 0 ) + ( this.salt != null ? this.salt.length : 0 );
    }
112938
public function getContentLength(): ?int
    {
        $result = $this->getRequest()->getHeader('Content-Length');

        return $result ? (int) $result[0] : null;
    }
400442
public function getSize() {

	    $bytestotal = 0;
	    $path 		= realpath($this -> directory -> getPath());

	    if($path !== false) {

	        foreach(new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($path, \FilesystemIterator :: SKIP_DOTS)) as $object) {
	            $bytestotal += $object->getSize();
	        }
	    }

	    return $bytestotal;
	}