<?php namespace PhpZip\IO\Stream; use Psr\Http\Message\StreamInterface; /** * Implement PSR Message Stream. */ class ResponseStream implements StreamInterface { /** @var array */ 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, ], 'write' => [ 'w' => true, 'w+' => true, 'rw' => true, 'r+' => true, 'x+' => true, 'c+' => true, 'wb' => true, 'w+b' => true, 'r+b' => true, 'x+b' => true, 'c+b' => true, 'w+t' => true, 'r+t' => true, 'x+t' => true, 'c+t' => true, 'a' => true, 'a+' => true, ], ]; /** @var resource */ private $stream; /** @var int|null */ private $size; /** @var bool */ private $seekable; /** @var bool */ private $readable; /** @var bool */ private $writable; /** @var string|null */ private $uri; /** * @param resource $stream stream resource to wrap * * @throws \InvalidArgumentException if the stream is not a stream resource */ public function __construct($stream) { if (!\is_resource($stream)) { throw new \InvalidArgumentException('Stream must be a resource'); } $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'); } /** * Get stream metadata as an associative array or retrieve a specific key. * * The keys returned are identical to the keys returned from PHP's * stream_get_meta_data() function. * * @see http://php.net/manual/en/function.stream-get-meta-data.php * * @param string $key specific metadata to retrieve * * @return array|mixed|null Returns an associative array if no key is * provided. Returns a specific key value if a key is provided and the * value is found, or null if the key is not found. */ public function getMetadata($key = null) { if (!$this->stream) { return $key ? null : []; } $meta = stream_get_meta_data($this->stream); return isset($meta[$key]) ? $meta[$key] : null; } /** * Reads all data from the stream into a string, from the beginning to end. * * This method MUST attempt to seek to the beginning of the stream before * reading data and read the stream until the end is reached. * * Warning: This could attempt to load a large amount of data into memory. * * This method MUST NOT raise an exception in order to conform with PHP's * string casting operations. * * @see http://php.net/manual/en/language.oop5.magic.php#object.tostring * * @return string */ public function __toString() { if (!$this->stream) { return ''; } $this->rewind(); return (string) stream_get_contents($this->stream); } /** * Seek to the beginning of the stream. * * If the stream is not seekable, this method will raise an exception; * otherwise, it will perform a seek(0). * * @throws \RuntimeException on failure * * @see http://www.php.net/manual/en/function.fseek.php * @see seek() */ public function rewind() { $this->seekable && rewind($this->stream); } /** * Get the size of the stream if known. * * @return int|null returns the size in bytes if known, or null if unknown */ public function getSize() { if ($this->size !== null) { return $this->size; } if (!$this->stream) { return null; } // Clear the stat cache if the stream has a URI if ($this->uri !== null) { clearstatcache(true, $this->uri); } $stats = fstat($this->stream); if (isset($stats['size'])) { $this->size = $stats['size']; return $this->size; } return null; } /** * Returns the current position of the file read/write pointer. * * @throws \RuntimeException on error * * @return int Position of the file pointer */ public function tell() { return $this->stream ? ftell($this->stream) : false; } /** * Returns true if the stream is at the end of the stream. * * @return bool */ public function eof() { return !$this->stream || feof($this->stream); } /** * Returns whether or not the stream is seekable. * * @return bool */ public function isSeekable() { return $this->seekable; } /** * Seek to a position in the stream. * * @see http://www.php.net/manual/en/function.fseek.php * * @param int $offset Stream offset * @param int $whence Specifies how the cursor position will be calculated * based on the seek offset. Valid values are identical to the built-in * PHP $whence values for `fseek()`. SEEK_SET: Set position equal to * offset bytes SEEK_CUR: Set position to current location plus offset * SEEK_END: Set position to end-of-stream plus offset. * * @throws \RuntimeException on failure */ public function seek($offset, $whence = \SEEK_SET) { $this->seekable && fseek($this->stream, $offset, $whence); } /** * Returns whether or not the stream is writable. * * @return bool */ public function isWritable() { return $this->writable; } /** * Write data to the stream. * * @param string $string the string that is to be written * * @throws \RuntimeException on failure * * @return int returns the number of bytes written to the stream */ public function write($string) { $this->size = null; return $this->writable ? fwrite($this->stream, $string) : false; } /** * Returns whether or not the stream is readable. * * @return bool */ public function isReadable() { return $this->readable; } /** * Read data from the stream. * * @param int $length Read up to $length bytes from the object and return * them. Fewer than $length bytes may be returned if underlying stream * call returns fewer bytes. * * @throws \RuntimeException if an error occurs * * @return string returns the data read from the stream, or an empty string * if no bytes are available */ public function read($length) { return $this->readable ? fread($this->stream, $length) : ''; } /** * Returns the remaining contents in a string. * * @throws \RuntimeException if unable to read or an error occurs while * reading * * @return string */ public function getContents() { return $this->stream ? stream_get_contents($this->stream) : ''; } /** * Closes the stream when the destructed. */ public function __destruct() { $this->close(); } /** * Closes the stream and any underlying resources. */ public function close() { if (\is_resource($this->stream)) { fclose($this->stream); } $this->detach(); } /** * Separates any underlying resources from the stream. * * After the stream has been detached, the stream is in an unusable state. * * @return resource|null Underlying PHP stream, if any */ public function detach() { $result = $this->stream; $this->stream = null; $this->size = null; $this->uri = null; $this->readable = false; $this->writable = false; $this->seekable = false; return $result; } }