[Summary view]

   1  <?php
   2  
   3  declare(strict_types=1);
   4  
   5  namespace GuzzleHttp\Psr7;
   6  
   7  use Psr\Http\Message\StreamInterface;
   8  
   9  /**
  10   * Stream decorator that can cache previously read bytes from a sequentially
  11   * read stream.
  12   */
  13  final class CachingStream implements StreamInterface
  14  {
  15      use StreamDecoratorTrait;
  16  
  17      /** @var StreamInterface Stream being wrapped */
  18      private $remoteStream;
  19  
  20      /** @var int Number of bytes to skip reading due to a write on the buffer */
  21      private $skipReadBytes = 0;
  22  
  23      /**
  24       * @var StreamInterface
  25       */
  26      private $stream;
  27  
  28      /**
  29       * We will treat the buffer object as the body of the stream
  30       *
  31       * @param StreamInterface $stream Stream to cache. The cursor is assumed to be at the beginning of the stream.
  32       * @param StreamInterface $target Optionally specify where data is cached
  33       */
  34      public function __construct(
  35          StreamInterface $stream,
  36          StreamInterface $target = null
  37      ) {
  38          $this->remoteStream = $stream;
  39          $this->stream = $target ?: new Stream(Utils::tryFopen('php://temp', 'r+'));
  40      }
  41  
  42      public function getSize(): ?int
  43      {
  44          $remoteSize = $this->remoteStream->getSize();
  45  
  46          if (null === $remoteSize) {
  47              return null;
  48          }
  49  
  50          return max($this->stream->getSize(), $remoteSize);
  51      }
  52  
  53      public function rewind(): void
  54      {
  55          $this->seek(0);
  56      }
  57  
  58      public function seek($offset, $whence = SEEK_SET): void
  59      {
  60          if ($whence === SEEK_SET) {
  61              $byte = $offset;
  62          } elseif ($whence === SEEK_CUR) {
  63              $byte = $offset + $this->tell();
  64          } elseif ($whence === SEEK_END) {
  65              $size = $this->remoteStream->getSize();
  66              if ($size === null) {
  67                  $size = $this->cacheEntireStream();
  68              }
  69              $byte = $size + $offset;
  70          } else {
  71              throw new \InvalidArgumentException('Invalid whence');
  72          }
  73  
  74          $diff = $byte - $this->stream->getSize();
  75  
  76          if ($diff > 0) {
  77              // Read the remoteStream until we have read in at least the amount
  78              // of bytes requested, or we reach the end of the file.
  79              while ($diff > 0 && !$this->remoteStream->eof()) {
  80                  $this->read($diff);
  81                  $diff = $byte - $this->stream->getSize();
  82              }
  83          } else {
  84              // We can just do a normal seek since we've already seen this byte.
  85              $this->stream->seek($byte);
  86          }
  87      }
  88  
  89      public function read($length): string
  90      {
  91          // Perform a regular read on any previously read data from the buffer
  92          $data = $this->stream->read($length);
  93          $remaining = $length - strlen($data);
  94  
  95          // More data was requested so read from the remote stream
  96          if ($remaining) {
  97              // If data was written to the buffer in a position that would have
  98              // been filled from the remote stream, then we must skip bytes on
  99              // the remote stream to emulate overwriting bytes from that
 100              // position. This mimics the behavior of other PHP stream wrappers.
 101              $remoteData = $this->remoteStream->read(
 102                  $remaining + $this->skipReadBytes
 103              );
 104  
 105              if ($this->skipReadBytes) {
 106                  $len = strlen($remoteData);
 107                  $remoteData = substr($remoteData, $this->skipReadBytes);
 108                  $this->skipReadBytes = max(0, $this->skipReadBytes - $len);
 109              }
 110  
 111              $data .= $remoteData;
 112              $this->stream->write($remoteData);
 113          }
 114  
 115          return $data;
 116      }
 117  
 118      public function write($string): int
 119      {
 120          // When appending to the end of the currently read stream, you'll want
 121          // to skip bytes from being read from the remote stream to emulate
 122          // other stream wrappers. Basically replacing bytes of data of a fixed
 123          // length.
 124          $overflow = (strlen($string) + $this->tell()) - $this->remoteStream->tell();
 125          if ($overflow > 0) {
 126              $this->skipReadBytes += $overflow;
 127          }
 128  
 129          return $this->stream->write($string);
 130      }
 131  
 132      public function eof(): bool
 133      {
 134          return $this->stream->eof() && $this->remoteStream->eof();
 135      }
 136  
 137      /**
 138       * Close both the remote stream and buffer stream
 139       */
 140      public function close(): void
 141      {
 142          $this->remoteStream->close();
 143          $this->stream->close();
 144      }
 145  
 146      private function cacheEntireStream(): int
 147      {
 148          $target = new FnStream(['write' => 'strlen']);
 149          Utils::copyToStream($this, $target);
 150  
 151          return $this->tell();
 152      }
 153  }