Initial import.

vendor/guzzle/stream/Guzzle/Stream/Stream.php

@@ -0,0 +1,289 @@
+<?php
+
+namespace Guzzle\Stream;
+
+use Guzzle\Common\Exception\InvalidArgumentException;
+
+/**
+ * PHP stream implementation
+ */
+class Stream implements StreamInterface
+{
+    const STREAM_TYPE = 'stream_type';
+    const WRAPPER_TYPE = 'wrapper_type';
+    const IS_LOCAL = 'is_local';
+    const IS_READABLE = 'is_readable';
+    const IS_WRITABLE = 'is_writable';
+    const SEEKABLE = 'seekable';
+
+    /** @var resource Stream resource */
+    protected $stream;
+
+    /** @var int Size of the stream contents in bytes */
+    protected $size;
+
+    /** @var array Stream cached data */
+    protected $cache = array();
+
+    /** @var array Custom stream data */
+    protected $customData = array();
+
+    /** @var array Hash table of readable and writeable stream types for fast lookups */
+    protected static $readWriteHash = array(
+        'read' => array(
+            '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' => array(
+            '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
+        )
+    );
+
+    /**
+     * @param resource $stream Stream resource to wrap
+     * @param int      $size   Size of the stream in bytes. Only pass if the size cannot be obtained from the stream.
+     *
+     * @throws InvalidArgumentException if the stream is not a stream resource
+     */
+    public function __construct($stream, $size = null)
+    {
+        $this->setStream($stream, $size);
+    }
+
+    /**
+     * Closes the stream when the helper is destructed
+     */
+    public function __destruct()
+    {
+        $this->close();
+    }
+
+    public function __toString()
+    {
+        if (!$this->isReadable() || (!$this->isSeekable() && $this->isConsumed())) {
+            return '';
+        }
+
+        $originalPos = $this->ftell();
+        $body = stream_get_contents($this->stream, -1, 0);
+        $this->seek($originalPos);
+
+        return $body;
+    }
+
+    public function close()
+    {
+        if (is_resource($this->stream)) {
+            fclose($this->stream);
+        }
+        $this->cache[self::IS_READABLE] = false;
+        $this->cache[self::IS_WRITABLE] = false;
+    }
+
+    /**
+     * Calculate a hash of a Stream
+     *
+     * @param StreamInterface $stream    Stream to calculate the hash for
+     * @param string          $algo      Hash algorithm (e.g. md5, crc32, etc)
+     * @param bool            $rawOutput Whether or not to use raw output
+     *
+     * @return bool|string Returns false on failure or a hash string on success
+     */
+    public static function getHash(StreamInterface $stream, $algo, $rawOutput = false)
+    {
+        $pos = $stream->ftell();
+        if (!$stream->seek(0)) {
+            return false;
+        }
+
+        $ctx = hash_init($algo);
+        while (!$stream->feof()) {
+            hash_update($ctx, $stream->read(8192));
+        }
+
+        $out = hash_final($ctx, (bool) $rawOutput);
+        $stream->seek($pos);
+
+        return $out;
+    }
+
+    public function getMetaData($key = null)
+    {
+        $meta = stream_get_meta_data($this->stream);
+
+        return !$key ? $meta : (array_key_exists($key, $meta) ? $meta[$key] : null);
+    }
+
+    public function getStream()
+    {
+        return $this->stream;
+    }
+
+    public function setStream($stream, $size = null)
+    {
+        if (!is_resource($stream)) {
+            throw new InvalidArgumentException('Stream must be a resource');
+        }
+
+        $this->size = $size;
+        $this->stream = $stream;
+        $this->rebuildCache();
+
+        return $this;
+    }
+
+    public function detachStream()
+    {
+        $this->stream = null;
+
+        return $this;
+    }
+
+    public function getWrapper()
+    {
+        return $this->cache[self::WRAPPER_TYPE];
+    }
+
+    public function getWrapperData()
+    {
+        return $this->getMetaData('wrapper_data') ?: array();
+    }
+
+    public function getStreamType()
+    {
+        return $this->cache[self::STREAM_TYPE];
+    }
+
+    public function getUri()
+    {
+        return $this->cache['uri'];
+    }
+
+    public function getSize()
+    {
+        if ($this->size !== null) {
+            return $this->size;
+        }
+
+        // If the stream is a file based stream and local, then use fstat
+        clearstatcache(true, $this->cache['uri']);
+        $stats = fstat($this->stream);
+        if (isset($stats['size'])) {
+            $this->size = $stats['size'];
+            return $this->size;
+        } elseif ($this->cache[self::IS_READABLE] && $this->cache[self::SEEKABLE]) {
+            // Only get the size based on the content if the the stream is readable and seekable
+            $pos = $this->ftell();
+            $this->size = strlen((string) $this);
+            $this->seek($pos);
+            return $this->size;
+        }
+
+        return false;
+    }
+
+    public function isReadable()
+    {
+        return $this->cache[self::IS_READABLE];
+    }
+
+    public function isRepeatable()
+    {
+        return $this->cache[self::IS_READABLE] && $this->cache[self::SEEKABLE];
+    }
+
+    public function isWritable()
+    {
+        return $this->cache[self::IS_WRITABLE];
+    }
+
+    public function isConsumed()
+    {
+        return feof($this->stream);
+    }
+
+    public function feof()
+    {
+        return $this->isConsumed();
+    }
+
+    public function isLocal()
+    {
+        return $this->cache[self::IS_LOCAL];
+    }
+
+    public function isSeekable()
+    {
+        return $this->cache[self::SEEKABLE];
+    }
+
+    public function setSize($size)
+    {
+        $this->size = $size;
+
+        return $this;
+    }
+
+    public function seek($offset, $whence = SEEK_SET)
+    {
+        return $this->cache[self::SEEKABLE] ? fseek($this->stream, $offset, $whence) === 0 : false;
+    }
+
+    public function read($length)
+    {
+        return fread($this->stream, $length);
+    }
+
+    public function write($string)
+    {
+        // We can't know the size after writing anything
+        $this->size = null;
+
+        return fwrite($this->stream, $string);
+    }
+
+    public function ftell()
+    {
+        return ftell($this->stream);
+    }
+
+    public function rewind()
+    {
+        return $this->seek(0);
+    }
+
+    public function readLine($maxLength = null)
+    {
+        if (!$this->cache[self::IS_READABLE]) {
+            return false;
+        } else {
+            return $maxLength ? fgets($this->getStream(), $maxLength) : fgets($this->getStream());
+        }
+    }
+
+    public function setCustomData($key, $value)
+    {
+        $this->customData[$key] = $value;
+
+        return $this;
+    }
+
+    public function getCustomData($key)
+    {
+        return isset($this->customData[$key]) ? $this->customData[$key] : null;
+    }
+
+    /**
+     * Reprocess stream metadata
+     */
+    protected function rebuildCache()
+    {
+        $this->cache = stream_get_meta_data($this->stream);
+        $this->cache[self::IS_LOCAL] = stream_is_local($this->stream);
+        $this->cache[self::IS_READABLE] = isset(self::$readWriteHash['read'][$this->cache['mode']]);
+        $this->cache[self::IS_WRITABLE] = isset(self::$readWriteHash['write'][$this->cache['mode']]);
+    }
+}