PHP StreamInterface::isWritable方法代码示例

 /**
  * 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());
 }