/** * Returns a resource representing the stream. * * @param StreamInterface $stream The stream to get a resource for * * @return resource * @throws \InvalidArgumentException if stream is not readable or writable */ public static function getResource(StreamInterface $stream) { self::register(); if ($stream->isReadable()) { $mode = $stream->isWritable() ? 'r+' : 'r'; } elseif ($stream->isWritable()) { $mode = 'w'; } else { throw new \InvalidArgumentException('The stream must be readable, ' . 'writable, or both.'); } return fopen('guzzle://stream', $mode, null, stream_context_create(['guzzle' => ['stream' => $stream]])); }
public function send(StreamInterface $stream) { if (!$stream->isWritable()) { throw new \InvalidArgumentException('Output stream must be writable'); } if (is_array($this->callback)) { $ref = (new \ReflectionClass(is_object($this->callback[0]) ? get_class($this->callback[0]) : $this->callback[0]))->getMethod($this->callback[1]); } elseif (is_object($this->callback) && !$this->callback instanceof \Closure) { $ref = new \ReflectionMethod(get_class($this->callback), '__invoke'); } else { $ref = new \ReflectionFunction($this->callback); } if ($ref->isGenerator()) { foreach (call_user_func($this->callback) as $chunk) { $stream->write($chunk); } return; } foreach ($ref->getParameters() as $param) { if (NULL !== ($type = $param->getClass())) { if ($type->name === StreamInterface::class || $type->implementsInterface(StreamInterface::class)) { call_user_func($this->callback, $stream); return; } } break; } $stream->write((string) call_user_func($this->callback)); }
public function send(StreamInterface $stream) { if (!$stream->isWritable()) { throw new \InvalidArgumentException('Output stream must be writable'); } $stream->write($this->contents); }
/** * Decorate the given output stream. * * @param StreamInterface $stream * * @throws \InvalidArgumentException When the given stream is not writable. */ public function __construct(StreamInterface $stream) { if (!$stream->isWritable()) { throw new \InvalidArgumentException(sprintf('Decorated stream must be writable, given %s', get_class($stream))); } $this->stream = $stream; }
public function send(StreamInterface $stream) { if (!$stream->isWritable()) { throw new \InvalidArgumentException('Output stream must be writable'); } while (!$this->stream->eof()) { $stream->write($this->stream->read(4096)); } }
public function send(StreamInterface $stream) { if ($this->skipBinary) { return; } if (!$stream->isWritable()) { throw new \InvalidArgumentException('Output stream must be writable'); } $in = ResourceInputStream::fromUrl($this->file->getPathname()); try { while (!$in->eof()) { $stream->write($in->read(4096)); } } finally { $in->close(); } }
protected function sendData(StreamInterface $stream, $prefix, array $data) { if (!$stream->isWritable()) { throw new \InvalidArgumentException('Output stream must be writable'); } foreach ($data as $k => $v) { if (is_numeric($k)) { $field = $prefix == '' ? $k : sprintf('%s[]', $prefix); } else { $field = $prefix == '' ? new UnicodeString($k) : sprintf('%s[%s]', $prefix, new UnicodeString($k)); } if (is_array($v)) { $this->sendData($stream, $field, $v); } else { $stream->write(sprintf("--%s\r\n", $this->boundary)); if ($v instanceof UploadedFileInterface) { $filename = new UnicodeString($v->getFileName()); $type = $v->getMediaType(); $in = $v->getInputStream(); $stream->write(sprintf('Content-Disposition: form-data; name="%s"; filename="%s"; charset="utf-8"', $field, $filename)); $stream->write(sprintf("\r\nContent-Type: %s\r\n", $type)); $stream->write("Content-Transfer-Encoding: binary\r\n"); $stream->write("\r\n"); while (false !== ($chunk = $in->read())) { $stream->write($chunk); } $stream->write("\r\n"); } else { $stream->write(sprintf('Content-Disposition: form-data; name="%s"; charset="utf-8"', $field)); $stream->write("\r\n\r\n"); $stream->write(new UnicodeString($v)); $stream->write("\r\n"); } } } }
/** * Pipe data from an input stream into an output stream. * * @param StreamInterface $in * @param StreamInterface $out * @param int $chunkSize Maximum chunk size being used during copy. * @return int Number of bytes being copied. * * @throws \InvalidArgumentException When input stream is not readable or output stream is not writable. */ public static function pipe(StreamInterface $in, StreamInterface $out, $chunkSize = 8192) { if (!$in->isReadable()) { throw new \InvalidArgumentException(sprintf('Input stream is not readable: %s', get_class($in))); } if (!$out->isWritable()) { throw new \InvalidArgumentException(sprintf('Output stream is not writable: %s', get_class($out))); } $size = 0; while (!$in->eof()) { $size += $out->write($in->read($chunkSize)); } return $size; }
/** * {@inheritdoc} */ public function isWritable() { return $this->stream->isWritable(); }
/** * {@inheritdoc} */ public function isWritable() { return $this->decoratedStream->isWritable(); }
/** * Create StreamInterface associated resource. * * @param StreamInterface $stream * @return resource * @throws WrapperException */ public static function getResource(StreamInterface $stream) { $mode = null; if ($stream->isReadable()) { $mode = 'r'; } if ($stream->isWritable()) { $mode = !empty($mode) ? 'r+' : 'w'; } if (empty($mode)) { throw new WrapperException("Stream is not available in read or write modes."); } return fopen(self::getUri($stream), $mode); }
protected function runMatches(StreamInterface $stream) { return $stream->isWritable(); }
public function testCheckMethods() { $this->assertEquals($this->a->isReadable(), $this->b->isReadable()); $this->assertEquals($this->a->isWritable(), $this->b->isWritable()); $this->assertEquals($this->a->isSeekable(), $this->b->isSeekable()); }