Na}{

File Content: BufferedStream.php

<?php

namespace Http\Message\Stream;

use Psr\Http\Message\StreamInterface;

/**
 * Decorator to make any stream seekable.
 *
 * Internally it buffers an existing StreamInterface into a php://temp resource (or memory). By default it will use
 * 2 megabytes of memory before writing to a temporary disk file.
 *
 * Due to this, very large stream can suffer performance issue (i/o slowdown).
 */
class BufferedStream implements StreamInterface
{
    /** @var resource The buffered resource used to seek previous data */
    private $resource;

/** @var int|null size of the stream if available */
    private $size;

/** @var StreamInterface The underlying stream decorated by this class */
    private $stream;

/** @var int How many bytes were written */
    private $written = 0;

/**
     * @param StreamInterface $stream        Decorated stream
     * @param bool            $useFileBuffer Whether to use a file buffer (write to a file, if data exceed a certain size)
     *                                       by default, set this to false to only use memory
     * @param int             $memoryBuffer  In conjunction with using file buffer, limit (in bytes) from which it begins to buffer
     *                                       the data in a file
     */
    public function __construct(StreamInterface $stream, $useFileBuffer = true, $memoryBuffer = 2097152)
    {
        $this->stream = $stream;
        $this->size = $stream->getSize();

if ($useFileBuffer) {
            $this->resource = fopen('php://temp/maxmemory:'.$memoryBuffer, 'rw+');
        } else {
            $this->resource = fopen('php://memory', 'rw+');
        }

if (false === $this->resource) {
            throw new \RuntimeException('Cannot create a resource over temp or memory implementation');
        }
    }

public function __toString(): string
    {
        try {
            $this->rewind();

return $this->getContents();
        } catch (\Throwable $throwable) {
            return '';
        }
    }

public function close(): void
    {
        if (null === $this->resource) {
            throw new \RuntimeException('Cannot close on a detached stream');
        }

$this->stream->close();
        fclose($this->resource);
    }

public function detach()
    {
        if (null === $this->resource) {
            return null;
        }

// Force reading the remaining data of the stream
        $this->getContents();

$resource = $this->resource;
        $this->stream->close();
        $this->stream = null;
        $this->resource = null;

return $resource;
    }

public function getSize(): ?int
    {
        if (null === $this->resource) {
            return null;
        }

if (null === $this->size && $this->stream->eof()) {
            return $this->written;
        }

return $this->size;
    }

public function tell(): int
    {
        if (null === $this->resource) {
            throw new \RuntimeException('Cannot tell on a detached stream');
        }

$tell = ftell($this->resource);
        if (false === $tell) {
            throw new \RuntimeException('ftell failed');
        }

return $tell;
    }

public function eof(): bool
    {
        if (null === $this->resource) {
            throw new \RuntimeException('Cannot call eof on a detached stream');
        }

// We are at the end only when both our resource and underlying stream are at eof
        return $this->stream->eof() && (ftell($this->resource) === $this->written);
    }

public function isSeekable(): bool
    {
        return null !== $this->resource;
    }

public function seek(int $offset, int $whence = SEEK_SET): void
    {
        if (null === $this->resource) {
            throw new \RuntimeException('Cannot seek on a detached stream');
        }

fseek($this->resource, $offset, $whence);
    }

public function rewind(): void
    {
        if (null === $this->resource) {
            throw new \RuntimeException('Cannot rewind on a detached stream');
        }

rewind($this->resource);
    }

public function isWritable(): bool
    {
        return false;
    }

public function write(string $string): int
    {
        throw new \RuntimeException('Cannot write on this stream');
    }

public function isReadable(): bool
    {
        return null !== $this->resource;
    }

public function read(int $length): string
    {
        if (null === $this->resource) {
            throw new \RuntimeException('Cannot read on a detached stream');
        }
        if ($length < 0) {
            throw new \InvalidArgumentException('Can not read a negative amount of bytes');
        }
        if (0 === $length) {
            return '';
        }

$read = '';

// First read from the resource
        if (ftell($this->resource) !== $this->written) {
            $read = fread($this->resource, $length);
        }
        if (false === $read) {
            throw new \RuntimeException('Failed to read from resource');
        }

$bytesRead = strlen($read);

if ($bytesRead < $length) {
            $streamRead = $this->stream->read($length - $bytesRead);

// Write on the underlying stream what we read
            $this->written += fwrite($this->resource, $streamRead);
            $read .= $streamRead;
        }

return $read;
    }

public function getContents(): string
    {
        if (null === $this->resource) {
            throw new \RuntimeException('Cannot read on a detached stream');
        }

$read = '';

while (!$this->eof()) {
            $read .= $this->read(8192);
        }

return $read;
    }

public function getMetadata(?string $key = null)
    {
        if (null === $this->resource) {
            if (null === $key) {
                return [];
            }

return null;
        }

$metadata = stream_get_meta_data($this->resource);

if (null === $key) {
            return $metadata;
        }

if (!array_key_exists($key, $metadata)) {
            return null;
        }

return $metadata[$key];
    }
}