Stream.php in Lockr 7.3

Namespace

GuzzleHttp\Psr7

File

vendor/guzzlehttp/psr7/src/Stream.php

<?php

namespace GuzzleHttp\Psr7;

use Psr\Http\Message\StreamInterface;

/**
 * PHP stream implementation.
 *
 * @var $stream
 */
class Stream implements StreamInterface {
  private $stream;
  private $size;
  private $seekable;
  private $readable;
  private $writable;
  private $uri;
  private $customMetadata;

  /** @var array Hash of readable and writable stream types */
  private static $readWriteHash = [
    'read' => [
      'r' => true,
      'w+' => true,
      'r+' => true,
      'x+' => true,
      'c+' => true,
      'rb' => true,
      'w+b' => true,
      'r+b' => true,
      'x+b' => true,
      'c+b' => true,
      'rt' => true,
      'w+t' => true,
      'r+t' => true,
      'x+t' => true,
      'c+t' => true,
      'a+' => true,
      'rb+' => true,
    ],
    'write' => [
      'w' => true,
      'w+' => true,
      'rw' => true,
      'r+' => true,
      'x+' => true,
      'c+' => true,
      'wb' => true,
      'w+b' => true,
      'r+b' => true,
      'rb+' => true,
      'x+b' => true,
      'c+b' => true,
      'w+t' => true,
      'r+t' => true,
      'x+t' => true,
      'c+t' => true,
      'a' => true,
      'a+' => true,
    ],
  ];

  /**
   * This constructor accepts an associative array of options.
   *
   * - size: (int) If a read stream would otherwise have an indeterminate
   *   size, but the size is known due to foreknowledge, then you can
   *   provide that size, in bytes.
   * - metadata: (array) Any additional metadata to return when the metadata
   *   of the stream is accessed.
   *
   * @param resource $stream  Stream resource to wrap.
   * @param array    $options Associative array of options.
   *
   * @throws \InvalidArgumentException if the stream is not a stream resource
   */
  public function __construct($stream, $options = []) {
    if (!is_resource($stream)) {
      throw new \InvalidArgumentException('Stream must be a resource');
    }
    if (isset($options['size'])) {
      $this->size = $options['size'];
    }
    $this->customMetadata = isset($options['metadata']) ? $options['metadata'] : [];
    $this->stream = $stream;
    $meta = stream_get_meta_data($this->stream);
    $this->seekable = $meta['seekable'];
    $this->readable = isset(self::$readWriteHash['read'][$meta['mode']]);
    $this->writable = isset(self::$readWriteHash['write'][$meta['mode']]);
    $this->uri = $this
      ->getMetadata('uri');
  }

  /**
   * Closes the stream when the destructed
   */
  public function __destruct() {
    $this
      ->close();
  }
  public function __toString() {
    try {
      $this
        ->seek(0);
      return (string) stream_get_contents($this->stream);
    } catch (\Exception $e) {
      return '';
    }
  }
  public function getContents() {
    if (!isset($this->stream)) {
      throw new \RuntimeException('Stream is detached');
    }
    $contents = stream_get_contents($this->stream);
    if ($contents === false) {
      throw new \RuntimeException('Unable to read stream contents');
    }
    return $contents;
  }
  public function close() {
    if (isset($this->stream)) {
      if (is_resource($this->stream)) {
        fclose($this->stream);
      }
      $this
        ->detach();
    }
  }
  public function detach() {
    if (!isset($this->stream)) {
      return null;
    }
    $result = $this->stream;
    unset($this->stream);
    $this->size = $this->uri = null;
    $this->readable = $this->writable = $this->seekable = false;
    return $result;
  }
  public function getSize() {
    if ($this->size !== null) {
      return $this->size;
    }
    if (!isset($this->stream)) {
      return null;
    }

    // Clear the stat cache if the stream has a URI
    if ($this->uri) {
      clearstatcache(true, $this->uri);
    }
    $stats = fstat($this->stream);
    if (isset($stats['size'])) {
      $this->size = $stats['size'];
      return $this->size;
    }
    return null;
  }
  public function isReadable() {
    return $this->readable;
  }
  public function isWritable() {
    return $this->writable;
  }
  public function isSeekable() {
    return $this->seekable;
  }
  public function eof() {
    if (!isset($this->stream)) {
      throw new \RuntimeException('Stream is detached');
    }
    return feof($this->stream);
  }
  public function tell() {
    if (!isset($this->stream)) {
      throw new \RuntimeException('Stream is detached');
    }
    $result = ftell($this->stream);
    if ($result === false) {
      throw new \RuntimeException('Unable to determine stream position');
    }
    return $result;
  }
  public function rewind() {
    $this
      ->seek(0);
  }
  public function seek($offset, $whence = SEEK_SET) {
    if (!isset($this->stream)) {
      throw new \RuntimeException('Stream is detached');
    }
    if (!$this->seekable) {
      throw new \RuntimeException('Stream is not seekable');
    }
    if (fseek($this->stream, $offset, $whence) === -1) {
      throw new \RuntimeException('Unable to seek to stream position ' . $offset . ' with whence ' . var_export($whence, true));
    }
  }
  public function read($length) {
    if (!isset($this->stream)) {
      throw new \RuntimeException('Stream is detached');
    }
    if (!$this->readable) {
      throw new \RuntimeException('Cannot read from non-readable stream');
    }
    if ($length < 0) {
      throw new \RuntimeException('Length parameter cannot be negative');
    }
    if (0 === $length) {
      return '';
    }
    $string = fread($this->stream, $length);
    if (false === $string) {
      throw new \RuntimeException('Unable to read from stream');
    }
    return $string;
  }
  public function write($string) {
    if (!isset($this->stream)) {
      throw new \RuntimeException('Stream is detached');
    }
    if (!$this->writable) {
      throw new \RuntimeException('Cannot write to a non-writable stream');
    }

    // We can't know the size after writing anything
    $this->size = null;
    $result = fwrite($this->stream, $string);
    if ($result === false) {
      throw new \RuntimeException('Unable to write to stream');
    }
    return $result;
  }
  public function getMetadata($key = null) {
    if (!isset($this->stream)) {
      return $key ? null : [];
    }
    elseif (!$key) {
      return $this->customMetadata + stream_get_meta_data($this->stream);
    }
    elseif (isset($this->customMetadata[$key])) {
      return $this->customMetadata[$key];
    }
    $meta = stream_get_meta_data($this->stream);
    return isset($meta[$key]) ? $meta[$key] : null;
  }

}

Classes

Name	Description
Stream	PHP stream implementation.