Returns whether or not the stream is writable.

@return bool
503995
public function isWritable()
    {
        if (!$this->isValidResource($this->resource)) {
            return false;
        }

        $meta = stream_get_meta_data($this->resource);
        $mode = $meta['mode'];

        return (
            strstr($mode, 'x')
            || strstr($mode, 'w')
            || strstr($mode, 'c')
            || strstr($mode, 'a')
            || strstr($mode, '+')
        );
    }
335404
public function writable()
    {
        return file_exists($this->filename) ? is_writable($this->filename) && is_file($this->filename) : $this->writableDir(\dirname($this->filename));
    }
825706
public function isWritable($additionalPath = '')
    {
        $path = $this->realPath($additionalPath);
        
        if ($path === false || !is_writable($path)) {
            return false;
        }
        
        return true;
    }
783297
protected function setRegistryWritableFalse()/*# : bool */
    {
        foreach ($this->lookup_pool as $reg) {
            if ($reg instanceof WritableInterface &&
                !$reg->setWritable(false)) {
                return false;
            }
        }
        return true;
    }
235333
public function isPipe()
    {
        if (\is_null($this->isPipe)) {
            $this->isPipe = false;
            if ($this->isAttached()) {
                $mode = fstat($this->stream)['mode'];
                $this->isPipe = ($mode & 0010000) !== 0;
            }
        }
        return $this->isPipe;
    }
817082
public function isSupported()
    {
        if ( ! is_writable($this->path)) {
            @mkdir($this->path, 0777, true);
        }

        return (bool)is_writable($this->path);
    }
249423
public function isReadable()
    {
        if (null !== ($mode = $this->getMetadata('mode'))) {
            preg_match_all('/[a-z]\D?/', $mode, $matches);

            if (isset($matches[ 0 ])) {
                foreach ($matches[ 0 ] as $match) {
                    if (in_array($match, ['r', 'r+', 'w+', 'a+', 'x+', 'c+'])) {
                        return true;
                        break;
                    }
                }
            }
        }

        return false;
    }
374469
public function isWritable($path)
	{
		$path = Util::normalizePath($path);

		return (bool) $this->adapter->isWritable($path);
	}
805452
public function isWritable(): bool
    {
        if ($this->caching == false) {
            return is_writable($this->getAbsoluteFilePath());
        }

        if ($this->isWritable == null) {
            $this->isWritable = is_writable($this->getAbsoluteFilePath());
        }

        return $this->isWritable;
    }
1178704
protected function writable($path) {
        $fullPath = "{$this->basePath}/$path";
        while (!file_exists($fullPath) && $fullPath != basename($fullPath)) {
            $fullPath = dirname($fullPath);
        }
        return is_writable($fullPath);
    }
492198
public function check(): bool
    {
        $path = \app()->storagePath();

        $this->description = Str::replace($this->description, \compact('path'));

        return $this->checkPathIsWritable($path);
    }
509015
protected function isWritable($filePath)
    {
        return !is_dir($filePath)
            &&
            (file_exists($filePath) ? is_writable($filePath) : is_writable(dirname($filePath)));
    }
726820
public function stream_write($data)
    {
        $tmp = &$this->_data[$this->_datapos];

        $oldlen = $tmp['l'];
        $res = fwrite($tmp['fp'], $data);
        if ($res === false) {
            return false;
        }

        $tmp['p'] = ftell($tmp['fp']);
        if ($tmp['p'] > $oldlen) {
            $tmp['l'] = $tmp['p'];
            $this->_length += ($tmp['l'] - $oldlen);
        }

        return $res;
    }
534697
protected boolean isWritable(WriterInterceptorContext context) {
        return context.getEntity() != null
                && !Boolean.FALSE.equals(requestProvider.get().getProperty(MessageHelper.STREAMING_RANGE_ENABLED))
                && context.getHeaders().containsKey(HttpHeaders.CONTENT_LENGTH)
                && !(context.getEntity() instanceof MediaStreaming);
    }
1236378
def is_streamable(self):
        """"""

        doc = self._request(self.ws_prefix + ".getInfo", True)
        return _extract(doc, "streamable") == "1"
1202963
private function isStreamWritable($path)
    {
        $stream = $this->getStreamByPathScheme($path);
        if ($stream instanceof StreamInterface) {
            return $stream->isWritable();
        }

        return false;
    }
1205755
public function hasReadAccess() : bool
   {

      return $this->isOpen()
         && (
               $this->access == static::ACCESS_READ
            || $this->access == static::ACCESS_READWRITE
         );

   }