PHP FilesystemInterface::read方法代码示例

 /**
  * {@inheritdoc}
  */
 public function find($path)
 {
     if ($this->filesystem->has($path) === false) {
         throw new NotLoadableException(sprintf('Source image "%s" not found.', $path));
     }
     $mimeType = $this->filesystem->getMimetype($path);
     return new Binary($this->filesystem->read($path), $mimeType, $this->extensionGuesser->guess($mimeType));
 }

 public function getContents($spiBinaryFileId)
 {
     try {
         return $this->filesystem->read($spiBinaryFileId);
     } catch (FlysystemNotFoundException $e) {
         throw new BinaryFileNotFoundException($spiBinaryFileId, $e);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function fromFile($file) : Workout
 {
     $content = $this->filesystem->read($file);
     if ($content === false) {
         throw new UnreadableFileException();
     }
     return $this->fromString($content);
 }

 /**
  * {@inheritdoc}
  */
 public function read($path)
 {
     try {
         return $this->filesystem->read($path);
     } catch (FileNotFoundException $exception) {
         return false;
     }
 }

 /**
  * Get the contents of a file.
  *
  * @param  string  $path
  * @return string
  *
  * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
  */
 public function get($path)
 {
     try {
         return $this->driver->read($path);
     } catch (FileNotFoundException $e) {
         throw new ContractFileNotFoundException($path, $e->getCode(), $e);
     }
 }

 /**
  * Get an item from the storage.
  *
  * @param string $key
  *
  * @return string|null
  */
 public function get($key)
 {
     try {
         if ($data = $this->flysystem->read($key)) {
             return $data;
         }
     } catch (FileNotFoundException $e) {
         //
     }
 }

 /**
  * @param ServerRequestInterface $request
  *
  * @return mixed|null
  */
 public function data(ServerRequestInterface $request)
 {
     $url = $request->getUri()->getPath();
     $parameters = array_merge($request->getQueryParams(), $request->getParsedBody());
     $file = $this->file($url, $parameters);
     if (!$this->filesystem->has($file)) {
         $file = $this->defaultFile($url);
     }
     if (!$this->filesystem->has($file)) {
         return null;
     }
     return $this->filesystem->read($file);
 }

 /**
  * {@inheritDoc}
  */
 public function load($path)
 {
     try {
         $contents = $this->filesystem->read($path);
     } catch (FileNotFoundException $e) {
         throw new Exception\ImageNotFoundException(sprintf('Source image not found in "%s"', $path));
     }
     $mimeType = $this->filesystem->getMimeType($path);
     if ($mimeType === false) {
         // Mime Type could not be detected
         return $contents;
     }
     return new Binary($contents, $mimeType);
 }

 /**
  * Generate manipulated image.
  * @param  string                $path   Image path.
  * @param  array                 $params Image manipulation params.
  * @return string                Cache path.
  * @throws FileNotFoundException
  * @throws FilesystemException
  */
 public function makeImage($path, array $params)
 {
     $sourcePath = $this->getSourcePath($path);
     $cachedPath = $this->getCachePath($path, $params);
     if ($this->cacheFileExists($path, $params) === true) {
         return $cachedPath;
     }
     if ($this->sourceFileExists($path) === false) {
         throw new FileNotFoundException('Could not find the image `' . $sourcePath . '`.');
     }
     $source = $this->source->read($sourcePath);
     if ($source === false) {
         throw new FilesystemException('Could not read the image `' . $sourcePath . '`.');
     }
     // We need to write the image to the local disk before
     // doing any manipulations. This is because EXIF data
     // can only be read from an actual file.
     $tmp = tempnam(sys_get_temp_dir(), 'Glide');
     if (file_put_contents($tmp, $source) === false) {
         throw new FilesystemException('Unable to write temp file for `' . $sourcePath . '`.');
     }
     try {
         $write = $this->cache->write($cachedPath, $this->api->run($tmp, $this->getAllParams($params)));
         if ($write === false) {
             throw new FilesystemException('Could not write the image `' . $cachedPath . '`.');
         }
     } catch (FileExistsException $exception) {
         // This edge case occurs when the target already exists
         // because it's currently be written to disk in another
         // request. It's best to just fail silently.
     }
     unlink($tmp);
     return $cachedPath;
 }

 /**
  * Read session data
  * @link http://php.net/manual/en/sessionhandlerinterface.read.php
  * @param string $session_id The session id to read data for.
  * @return string <p>
  * Returns an encoded string of the read data.
  * If nothing was read, it must return an empty string.
  * Note this value is returned internally to PHP for processing.
  * </p>
  * @since 5.4.0
  */
 public function read($session_id)
 {
     if ($this->driver->has($path = $this->path . $session_id)) {
         return $this->driver->read($path);
     }
     return '';
 }

 /**
  * Read a file.
  *
  * @param string $path
  * @return string
  * @throws IoReadException
  */
 public function read($path)
 {
     if (($ret = $this->fs->read($path)) === false) {
         throw new IoReadException("File {$path} could not be read.");
     }
     return $ret;
 }

 /**
  * Reads settings content of a namespace
  *
  * @param  string $namespace
  * @return array
  */
 protected function read($namespace)
 {
     $file = $this->adapter->getFileName($namespace);
     if (!$this->fileSystem->has($file)) {
         return [];
     }
     return $this->adapter->onRead($this->fileSystem->read($file));
 }

 /**
  * Read stub file
  *
  * @param string $content
  * @param array $arguments
  * @return mixed
  */
 protected function read($stub_path)
 {
     $content = $this->stubbox->read($stub_path);
     if ($content === false) {
         throw new InvalidArgumentException("File '{$stub_path}' is not found.");
     }
     return $content;
 }

 /**
  * @param ReflectionClass $reflection
  * @param FilesystemInterface $filesystem
  * @param null $name
  */
 public function __construct(ReflectionClass $reflection, FilesystemInterface $filesystem, $name = null)
 {
     $this->reflection = $reflection;
     $this->template = $filesystem->read("/Console/stubs/method.stub");
     $this->name = $name;
     $this->classParameters = $this->getClassParameters();
     $this->uses = $this->getUsages();
     $this->methodParameterNames = $this->getMethodParameters();
     $this->requestParameters = $this->getRequestParameters();
 }

 /**
  * Extracts user defined PHP Type's from a source php file.
  *
  * @param  string $package
  * @param  string $version
  * @param  string $file
  * @return array
  */
 private function getTypes($package, $version, $file)
 {
     $fullPath = $this->vendorDir . '/' . $package . '/' . $version . '/' . $file;
     $src = $this->filesystem->read($fullPath);
     $ast = $this->parser->parse($src);
     $this->traverser->addVisitor($this->typeExtracator);
     $this->traverser->traverse($ast);
     $this->traverser->removeVisitor($this->typeExtracator);
     return $this->typeExtracator->getTypes();
 }