You are here

class PumpStream in Auth0 Single Sign On 8.2

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

Expanded class hierarchy of PumpStream

File

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

Namespace

GuzzleHttp\Psr7
View source
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

Namesort descending 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