class PumpStream in Zircon Profile 8

Provides a read only stream that pumps data from a PHP callable.

When invoking the provided callable, the PumpStream will pass the amount of data requested to read to the callable. The callable can choose to ignore this value and return fewer or more bytes than requested. Any extra data returned by the provided callable is buffered internally until drained using the read() function of the PumpStream. The provided callable MUST return false when there is no more data to read.

Hierarchy

• class \GuzzleHttp\Psr7\PumpStream implements StreamInterface

1 file declares its use of PumpStream

PumpStreamTest.php in vendor/guzzlehttp/psr7/tests/PumpStreamTest.php

File

vendor/guzzlehttp/psr7/src/PumpStream.php, line 16

Namespace

GuzzleHttp\Psr7

class PumpStream implements StreamInterface {

  /** @var callable */
  private $source;

  /** @var int */
  private $size;

  /** @var int */
  private $tellPos = 0;

  /** @var array */
  private $metadata;

  /** @var BufferStream */
  private $buffer;

  /**
   * @param callable $source Source of the stream data. The callable MAY
   *                         accept an integer argument used to control the
   *                         amount of data to return. The callable MUST
   *                         return a string when called, or false on error
   *                         or EOF.
   * @param array $options   Stream options:
   *                         - metadata: Hash of metadata to use with stream.
   *                         - size: Size of the stream, if known.
   */
  public function __construct(callable $source, array $options = []) {
    $this->source = $source;
    $this->size = isset($options['size']) ? $options['size'] : null;
    $this->metadata = isset($options['metadata']) ? $options['metadata'] : [];
    $this->buffer = new BufferStream();
  }
  public function __toString() {
    try {
      return copy_to_string($this);
    } catch (\Exception $e) {
      return '';
    }
  }
  public function close() {
    $this
      ->detach();
  }
  public function detach() {
    $this->tellPos = false;
    $this->source = null;
  }
  public function getSize() {
    return $this->size;
  }
  public function tell() {
    return $this->tellPos;
  }
  public function eof() {
    return !$this->source;
  }
  public function isSeekable() {
    return false;
  }
  public function rewind() {
    $this
      ->seek(0);
  }
  public function seek($offset, $whence = SEEK_SET) {
    throw new \RuntimeException('Cannot seek a PumpStream');
  }
  public function isWritable() {
    return false;
  }
  public function write($string) {
    throw new \RuntimeException('Cannot write to a PumpStream');
  }
  public function isReadable() {
    return true;
  }
  public function read($length) {
    $data = $this->buffer
      ->read($length);
    $readLen = strlen($data);
    $this->tellPos += $readLen;
    $remaining = $length - $readLen;
    if ($remaining) {
      $this
        ->pump($remaining);
      $data .= $this->buffer
        ->read($remaining);
      $this->tellPos += strlen($data) - $readLen;
    }
    return $data;
  }
  public function getContents() {
    $result = '';
    while (!$this
      ->eof()) {
      $result .= $this
        ->read(1000000);
    }
    return $result;
  }
  public function getMetadata($key = null) {
    if (!$key) {
      return $this->metadata;
    }
    return isset($this->metadata[$key]) ? $this->metadata[$key] : null;
  }
  private function pump($length) {
    if ($this->source) {
      do {
        $data = call_user_func($this->source, $length);
        if ($data === false || $data === null) {
          $this->source = null;
          return;
        }
        $this->buffer
          ->write($data);
        $length -= strlen($data);
      } while ($length > 0);
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
PumpStream::$buffer	private	property	@var BufferStream
PumpStream::$metadata	private	property	@var array
PumpStream::$size	private	property	@var int
PumpStream::$source	private	property	@var callable
PumpStream::$tellPos	private	property	@var int
PumpStream::close	public	function	Closes the stream and any underlying resources. Overrides StreamInterface::close
PumpStream::detach	public	function	Separates any underlying resources from the stream. Overrides StreamInterface::detach
PumpStream::eof	public	function	Returns true if the stream is at the end of the stream. Overrides StreamInterface::eof
PumpStream::getContents	public	function	Returns the remaining contents in a string Overrides StreamInterface::getContents
PumpStream::getMetadata	public	function	Get stream metadata as an associative array or retrieve a specific key. Overrides StreamInterface::getMetadata
PumpStream::getSize	public	function	Get the size of the stream if known. Overrides StreamInterface::getSize
PumpStream::isReadable	public	function	Returns whether or not the stream is readable. Overrides StreamInterface::isReadable
PumpStream::isSeekable	public	function	Returns whether or not the stream is seekable. Overrides StreamInterface::isSeekable
PumpStream::isWritable	public	function	Returns whether or not the stream is writable. Overrides StreamInterface::isWritable
PumpStream::pump	private	function
PumpStream::read	public	function	Read data from the stream. Overrides StreamInterface::read
PumpStream::rewind	public	function	Seek to the beginning of the stream. Overrides StreamInterface::rewind
PumpStream::seek	public	function	Seek to a position in the stream. Overrides StreamInterface::seek
PumpStream::tell	public	function	Returns the current position of the file read/write pointer Overrides StreamInterface::tell
PumpStream::write	public	function	Write data to the stream. Overrides StreamInterface::write
PumpStream::__construct	public	function
PumpStream::__toString	public	function	Reads all data from the stream into a string, from the beginning to end. Overrides StreamInterface::__toString