Returns the size of the signature hash.

@param Reader $reader The archive file reader.

@return integer The size of the signature hash.
19769
private function getSize(Reader $reader)
    {
        $reader->seek(-12, SEEK_END);

        $size = unpack('V', $reader->read(4));
        $size = (int) $size[1];

        return $size;
    }
1341368
public function getSize()
    {
        if ($this->isDirty && $this->bytes) {
            return strlen($this->bytes);
        }
        if ($this->isDirty && $this->filename) {
            return filesize($this->filename);
        }
        if ($this->mongoGridFSFile instanceof \MongoGridFSFile) {
            return $this->mongoGridFSFile->getSize();
        }
        return 0;
    }
1368584
public function readUIntBySize($size)
    {
        if ($size === self::UNSIGNED_CHAR_LENGTH) {
            return $this->readUInt8();
        }
        if ($size === self::UNSIGNED_SHORT_LENGTH) {
            return $this->readUInt16();
        }
        if ($size === self::UNSIGNED_INT24_LENGTH) {
            return $this->readUInt24();
        }
        if ($size === self::UNSIGNED_INT32_LENGTH) {
            return $this->readUInt32();
        }
        if ($size === self::UNSIGNED_INT40_LENGTH) {
            return $this->readUInt40();
        }
        if ($size === self::UNSIGNED_INT48_LENGTH) {
            return $this->readUInt48();
        }
        if ($size === self::UNSIGNED_INT56_LENGTH) {
            return $this->readUInt56();
        }
        if ($size === self::UNSIGNED_INT64_LENGTH) {
            return $this->readUInt64();
        }

        throw new BinaryDataReaderException('$size ' . $size . ' not handled');
    }
95114
private function parseCustomIcon(ProtectedXMLReader $reader)
	{
		$uuid = null;
		$data = null;
		$d = $reader->depth();
		while($reader->read($d))
		{
			if($reader->isElement(self::XML_UUID))
				$uuid = $reader->readTextInside();
			elseif($reader->isElement(self::XML_DATA))
				$data = $reader->readTextInside();
		}
		if(!empty($uuid) && !empty($data))
		{
			if($this->_customIcons == null)
				$this->_customIcons = array();
			$this->_customIcons[$uuid] = $data;
		}
	}
725351
public function markAsRead()
    {
        $entries = $this->get();

        $count = 0;

        foreach ($entries as $entry) {
            if ($entry->markAsRead()) {
                ++$count;
            }
        }

        return $count;
    }
858510
private function verifyFileSize($size)
    {
        $max = $this->config['max_size'];
        if ($max > 0 && $size > $max) {
            throw FileSizeException::fileIsTooBig($size, $max);
        }

        return $size;
    }
130175
public function getBlockSize() {
        return mcrypt_get_block_size($this->supportedAlgos[$this->algo], $this->supportedModes[$this->mode]);
    }
1104328
public function getReader()
    {
        if ($this->reader) {
            return $this->reader;
        }

        $className = $this->getDoctrineAnnotationReaderClassName();

        $r = new ReflectionClass($className);

        $instance = $r->newInstance();

        if (!$instance instanceof DoctrineAnnotationsReaderInterface) {
            $errMsg = sprintf('Reader not implement %s', DoctrineAnnotationsReaderInterface::class);
            throw new Exception\InvalidDoctrineAnnotationsReaderException($errMsg);
        }

        $this->reader = $instance;

        return $this->reader;
    }
728496
public function read($size = 1024)
    {
        if ($this->driver === self::DRIVER_SOCKET) {
            return socket_read($this->sock, $size);
        } else {
            return fread($this->sock, $size);
        }
    }
1302727
public function getReadHash(): string
    {
        $hash = hash_final($this->read_hash, true);
        if ($this->rev) {
            $hash = strrev($hash);
        }
        $this->read_hash = null;
        $this->read_check_after = 0;
        $this->read_check_pos = 0;

        return $hash;
    }
1238914
public function getUserReadStatusAttribute()
    {
        if (!$this->old && auth()->check()) {
            if (is_null($this->reader)) {
                return self::STATUS_UNREAD;
            }

            return ($this->updatedSince($this->reader)) ? self::STATUS_UPDATED : false;
        }

        return false;
    }
1158254
public function getStructureSize(BytesWalker $walker)
    {
        $marker = $walker->read(1);

        // if tiny size, no more bytes to read, the size is encoded in the low nibble
        if ($this->isMarkerHigh($marker, Constants::STRUCTURE_TINY)) {
            return $this->getLowNibbleValue($marker);
        }
    }
1252985
public function createWeight(Zend_Search_Lucene_Interface $reader)
    {
        include_once 'Zend/Search/Lucene/Search/Weight/MultiTerm.php';
        $this->_weight = new Zend_Search_Lucene_Search_Weight_MultiTerm($this, $reader);
        return $this->_weight;
    }
1272128
public function EntryRead($Bytes = -1)
    {
        $Actual = $this->EntryActualSize();
        if ($Bytes < 0 || $Bytes > $Actual) {
            $Bytes = $Actual;
        }
        return $Bytes > 0 ? $this->ZipObject->getFromIndex($this->Index, $Bytes) : '';
    }
1071876
public function getSize($format = true)
    {
        if ($format) {
            return Conversion::formatSizeUnits($this->result['size_download']);
        }
        return $this->result['size_download'];
    }
408725
def Deserialize(self, reader):
        
        self.Type = reader.ReadByte()
        self.Hashes = reader.ReadHashes()
1341470
public function get_size()
  {
    if ( $this->file && $this->size === 0 ){
      $this->size = filesize($this->file);
    }
    return $this->size;
  }