[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  namespace GuzzleHttp\Psr7;
   4  
   5  use Psr\Http\Message\StreamInterface;
   6  
   7  /**
   8   * Provides a read only stream that pumps data from a PHP callable.
   9   *
  10   * When invoking the provided callable, the PumpStream will pass the amount of
  11   * data requested to read to the callable. The callable can choose to ignore
  12   * this value and return fewer or more bytes than requested. Any extra data
  13   * returned by the provided callable is buffered internally until drained using
  14   * the read() function of the PumpStream. The provided callable MUST return
  15   * false when there is no more data to read.
  16   */
  17  class PumpStream implements StreamInterface
  18  {
  19      /** @var callable */
  20      private $source;
  21  
  22      /** @var int */
  23      private $size;
  24  
  25      /** @var int */
  26      private $tellPos = 0;
  27  
  28      /** @var array */
  29      private $metadata;
  30  
  31      /** @var BufferStream */
  32      private $buffer;
  33  
  34      /**
  35       * @param callable $source Source of the stream data. The callable MAY
  36       *                         accept an integer argument used to control the
  37       *                         amount of data to return. The callable MUST
  38       *                         return a string when called, or false on error
  39       *                         or EOF.
  40       * @param array $options   Stream options:
  41       *                         - metadata: Hash of metadata to use with stream.
  42       *                         - size: Size of the stream, if known.
  43       */
  44      public function __construct(callable $source, array $options = [])
  45      {
  46          $this->source = $source;
  47          $this->size = isset($options['size']) ? $options['size'] : null;
  48          $this->metadata = isset($options['metadata']) ? $options['metadata'] : [];
  49          $this->buffer = new BufferStream();
  50      }
  51  
  52      public function __toString()
  53      {
  54          try {
  55              return Utils::copyToString($this);
  56          } catch (\Exception $e) {
  57              return '';
  58          }
  59      }
  60  
  61      public function close()
  62      {
  63          $this->detach();
  64      }
  65  
  66      public function detach()
  67      {
  68          $this->tellPos = false;
  69          $this->source = null;
  70  
  71          return null;
  72      }
  73  
  74      public function getSize()
  75      {
  76          return $this->size;
  77      }
  78  
  79      public function tell()
  80      {
  81          return $this->tellPos;
  82      }
  83  
  84      public function eof()
  85      {
  86          return !$this->source;
  87      }
  88  
  89      public function isSeekable()
  90      {
  91          return false;
  92      }
  93  
  94      public function rewind()
  95      {
  96          $this->seek(0);
  97      }
  98  
  99      public function seek($offset, $whence = SEEK_SET)
 100      {
 101          throw new \RuntimeException('Cannot seek a PumpStream');
 102      }
 103  
 104      public function isWritable()
 105      {
 106          return false;
 107      }
 108  
 109      public function write($string)
 110      {
 111          throw new \RuntimeException('Cannot write to a PumpStream');
 112      }
 113  
 114      public function isReadable()
 115      {
 116          return true;
 117      }
 118  
 119      public function read($length)
 120      {
 121          $data = $this->buffer->read($length);
 122          $readLen = strlen($data);
 123          $this->tellPos += $readLen;
 124          $remaining = $length - $readLen;
 125  
 126          if ($remaining) {
 127              $this->pump($remaining);
 128              $data .= $this->buffer->read($remaining);
 129              $this->tellPos += strlen($data) - $readLen;
 130          }
 131  
 132          return $data;
 133      }
 134  
 135      public function getContents()
 136      {
 137          $result = '';
 138          while (!$this->eof()) {
 139              $result .= $this->read(1000000);
 140          }
 141  
 142          return $result;
 143      }
 144  
 145      public function getMetadata($key = null)
 146      {
 147          if (!$key) {
 148              return $this->metadata;
 149          }
 150  
 151          return isset($this->metadata[$key]) ? $this->metadata[$key] : null;
 152      }
 153  
 154      private function pump($length)
 155      {
 156          if ($this->source) {
 157              do {
 158                  $data = call_user_func($this->source, $length);
 159                  if ($data === false || $data === null) {
 160                      $this->source = null;
 161                      return;
 162                  }
 163                  $this->buffer->write($data);
 164                  $length -= strlen($data);
 165              } while ($length > 0);
 166          }
 167      }
 168  }