AbstractMimeTransferStreamDecorator::getSize() - Code Metrics - Inspection of "Refactor UUStream" - zbateson/stream-decorators - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 24daad...73f9da )

by Zaahid

created 2018-07-17 01:45 UTC

AbstractMimeTransferStreamDecorator::getSize() A

↳ Parent: AbstractMimeTransferStreamDecorator

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php
/**
 * This file is part of the ZBateson\StreamDecorators project.
 *
 * @license http://opensource.org/licenses/bsd-license.php BSD
 */
namespace ZBateson\StreamDecorators;

use Psr\Http\Message\StreamInterface;
use GuzzleHttp\Psr7\StreamDecoratorTrait;

/**
 * A default abstract implementation of GuzzleHttp\Psr7 StreamInterface for MIME
 * message transfer encodings that:
 *
 *  o Implements a getSize operation, reading to the end of the stream to
 *    determine the stream's size, and seeking back to the current position
 *  o Implements a seek operation, reading and discarding the desired number of
 *    bytes from the decorator as a 'seek' operation
 *  o Provides a $position member for subclasses and a default 'tell'
 *    implementation returning it
 *  o Uses StreamDecoratorTrait, setting method visibility to protected and
 *    changing their names to getRawSize, seekRaw, tellRaw, writeRaw and readRaw
 *
 * @author Zaahid Bateson
 */
abstract class AbstractMimeTransferStreamDecorator implements StreamInterface
{
    use StreamDecoratorTrait {
        StreamDecoratorTrait::getSize as protected getRawSize;
        StreamDecoratorTrait::seek as protected seekRaw;
        StreamDecoratorTrait::tell as protected tellRaw;
        StreamDecoratorTrait::write as protected writeRaw;
        StreamDecoratorTrait::read as protected readRaw;
        StreamDecoratorTrait::detach as protected detachRaw;
        StreamDecoratorTrait::close as protected closeRaw;
    }

    /**
     * @var int current read/write position
     */
    protected $position = 0;

    /**
     * To determine the size of the underlying stream, the entire contents are
     * read and discarded.  Therefore calling getSize is an expensive operation.
     *
     * @return int
     */
    public function getSize()
    {
        return $this->getSizeWithSeekBack(true);
        return $this->getSizeWithSeekBack(/** @scrutinizer ignore-type */ true);
    }

    /**
     * Can optionally seek back to the current position.
     *
     * Useful when called from seek with SEEK_END, there's no need to seek back
     * to the current position when called within seek.
     *
     * @param type $seekBack
filter:
    dependency_paths: ["lib/*"]
     */
    private function getSizeWithSeekBack($seekBack) {
        $pos = $this->position;
        $this->rewind();
        while (!$this->eof()) {
            $this->read(1048576);
        }
        $length = $this->position;
        if ($seekBack) {

            $this->seek($pos);
        }
        return $length;
    }

    /**
     * Overridden to return the calculated position as bytes in the decoded
     * stream.
     *
     * @return int
     */
    public function tell()
    {
        return $this->position;
    }

    /**
     * Called before seeking to the specified offset, can be overridden by
     * sub-classes to reset internal buffers, etc...
     */
    protected function beforeSeek() {
        // do nothing.
    }

    /**
     * Seeks to the given position.
     *
     * This operation basically reads and discards to the given position because
     * the size of the underlying stream can't be calculated otherwise, and is
     * an expensive operation.
     *
     * @param int $offset
     * @param int $whence
     */
    public function seek($offset, $whence = SEEK_SET)
    {
        $pos = $offset;
        if ($whence === SEEK_CUR) {
            $pos = $this->tell() + $offset;
        } elseif ($whence === SEEK_END) {
            $pos = $this->getSizeWithSeekBack(false) + $offset;
            $pos = $this->getSizeWithSeekBack(/** @scrutinizer ignore-type */ false) + $offset;
        }
        // $this->position may not report actual position, for instance if the
        // underlying stream has been moved ahead.  Checking if the requested
        // position is the same as $pos before moving can cause problems when
        // using a LimitStream for instance after the parent stream has been
        // read from, etc...
        $this->beforeSeek($pos);
               beforeSeek($pos);
        $this->seekRaw(0);
        $this->position = 0;
        
        // to avoid memory issues
        while ($pos > 10240 && !$this->eof()) {
            $this->read(10240);
            $pos -= 10240;
        }
        $this->read($pos);
    }

    /**
     * Override to implement 'write' functionality and write bytes to the
     * underlying stream.
     *
     * @param string $string
     * @return int the number of bytes written
     */
    public abstract function write($string);

    /**
     * Override to implement read functionality, reading $length bytes from the
     * underlying stream
     *
     * @param int $length
     * @return string the string that was read
     */
    public abstract function read($length);

    /**
     * Flushes the underlying stream object if it's an instance of
     * AbstractMimeTransferStreamDecorator.
     */
    public function flush()
    {
        if ($this->stream && $this->stream instanceof AbstractMimeTransferStreamDecorator) {
            $this->stream->flush();
        }
    }

    /**
     * Overridden to call flush() before detaching.
     */
    public function detach()
    {
        $this->flush();
        $this->detachRaw();
    }

    /**
     * Overridden to call flush() before detaching.
     */
    public function close()
    {
        $this->flush();
        $this->closeRaw();
    }
}


zbateson / stream-decorators

Push — master ( 24daad...73f9da )

AbstractMimeTransferStreamDecorator::getSize() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like