class UploadedFile in Zircon Profile 8

Hierarchy

• class \Zend\Diactoros\UploadedFile implements UploadedFileInterface

1 file declares its use of UploadedFile

DiactorosFactory.php in vendor/symfony/psr-http-message-bridge/Factory/DiactorosFactory.php

File

vendor/zendframework/zend-diactoros/src/UploadedFile.php, line 17

Namespace

Zend\Diactoros

class UploadedFile implements UploadedFileInterface {

  /**
   * @var string
   */
  private $clientFilename;

  /**
   * @var string
   */
  private $clientMediaType;

  /**
   * @var int
   */
  private $error;

  /**
   * @var null|string
   */
  private $file;

  /**
   * @var bool
   */
  private $moved = false;

  /**
   * @var int
   */
  private $size;

  /**
   * @var null|StreamInterface
   */
  private $stream;
  public function __construct($streamOrFile, $size, $errorStatus, $clientFilename = null, $clientMediaType = null) {
    if ($errorStatus === UPLOAD_ERR_OK) {
      if (is_string($streamOrFile)) {
        $this->file = $streamOrFile;
      }
      if (is_resource($streamOrFile)) {
        $this->stream = new Stream($streamOrFile);
      }
      if (!$this->file && !$this->stream) {
        if (!$streamOrFile instanceof StreamInterface) {
          throw new InvalidArgumentException('Invalid stream or file provided for UploadedFile');
        }
        $this->stream = $streamOrFile;
      }
    }
    if (!is_int($size)) {
      throw new InvalidArgumentException('Invalid size provided for UploadedFile; must be an int');
    }
    $this->size = $size;
    if (!is_int($errorStatus) || 0 > $errorStatus || 8 < $errorStatus) {
      throw new InvalidArgumentException('Invalid error status for UploadedFile; must be an UPLOAD_ERR_* constant');
    }
    $this->error = $errorStatus;
    if (null !== $clientFilename && !is_string($clientFilename)) {
      throw new InvalidArgumentException('Invalid client filename provided for UploadedFile; must be null or a string');
    }
    $this->clientFilename = $clientFilename;
    if (null !== $clientMediaType && !is_string($clientMediaType)) {
      throw new InvalidArgumentException('Invalid client media type provided for UploadedFile; must be null or a string');
    }
    $this->clientMediaType = $clientMediaType;
  }

  /**
   * {@inheritdoc}
   * @throws \RuntimeException if the upload was not successful.
   */
  public function getStream() {
    if ($this->error !== UPLOAD_ERR_OK) {
      throw new RuntimeException('Cannot retrieve stream due to upload error');
    }
    if ($this->moved) {
      throw new RuntimeException('Cannot retrieve stream after it has already been moved');
    }
    if ($this->stream instanceof StreamInterface) {
      return $this->stream;
    }
    $this->stream = new Stream($this->file);
    return $this->stream;
  }

  /**
   * {@inheritdoc}
   *
   * @see http://php.net/is_uploaded_file
   * @see http://php.net/move_uploaded_file
   * @param string $targetPath Path to which to move the uploaded file.
   * @throws \RuntimeException if the upload was not successful.
   * @throws \InvalidArgumentException if the $path specified is invalid.
   * @throws \RuntimeException on any error during the move operation, or on
   *     the second or subsequent call to the method.
   */
  public function moveTo($targetPath) {
    if ($this->error !== UPLOAD_ERR_OK) {
      throw new RuntimeException('Cannot retrieve stream due to upload error');
    }
    if (!is_string($targetPath)) {
      throw new InvalidArgumentException('Invalid path provided for move operation; must be a string');
    }
    if (empty($targetPath)) {
      throw new InvalidArgumentException('Invalid path provided for move operation; must be a non-empty string');
    }
    if ($this->moved) {
      throw new RuntimeException('Cannot move file; already moved!');
    }
    $sapi = PHP_SAPI;
    switch (true) {
      case empty($sapi) || 0 === strpos($sapi, 'cli') || !$this->file:

        // Non-SAPI environment, or no filename present
        $this
          ->writeFile($targetPath);
        break;
      default:

        // SAPI environment, with file present
        if (false === move_uploaded_file($this->file, $targetPath)) {
          throw new RuntimeException('Error occurred while moving uploaded file');
        }
        break;
    }
    $this->moved = true;
  }

  /**
   * {@inheritdoc}
   *
   * @return int|null The file size in bytes or null if unknown.
   */
  public function getSize() {
    return $this->size;
  }

  /**
   * {@inheritdoc}
   *
   * @see http://php.net/manual/en/features.file-upload.errors.php
   * @return int One of PHP's UPLOAD_ERR_XXX constants.
   */
  public function getError() {
    return $this->error;
  }

  /**
   * {@inheritdoc}
   *
   * @return string|null The filename sent by the client or null if none
   *     was provided.
   */
  public function getClientFilename() {
    return $this->clientFilename;
  }

  /**
   * {@inheritdoc}
   */
  public function getClientMediaType() {
    return $this->clientMediaType;
  }

  /**
   * Write internal stream to given path
   *
   * @param string $path
   */
  private function writeFile($path) {
    $handle = fopen($path, 'wb+');
    if (false === $handle) {
      throw new RuntimeException('Unable to write to designated path');
    }
    $stream = $this
      ->getStream();
    $stream
      ->rewind();
    while (!$stream
      ->eof()) {
      fwrite($handle, $stream
        ->read(4096));
    }
    fclose($handle);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
UploadedFile::$clientFilename	private	property
UploadedFile::$clientMediaType	private	property
UploadedFile::$error	private	property
UploadedFile::$file	private	property
UploadedFile::$moved	private	property
UploadedFile::$size	private	property
UploadedFile::$stream	private	property
UploadedFile::getClientFilename	public	function	Overrides UploadedFileInterface::getClientFilename
UploadedFile::getClientMediaType	public	function	Retrieve the media type sent by the client. Overrides UploadedFileInterface::getClientMediaType
UploadedFile::getError	public	function	Overrides UploadedFileInterface::getError
UploadedFile::getSize	public	function	Overrides UploadedFileInterface::getSize
UploadedFile::getStream	public	function	Overrides UploadedFileInterface::getStream
UploadedFile::moveTo	public	function	Overrides UploadedFileInterface::moveTo
UploadedFile::writeFile	private	function	Write internal stream to given path
UploadedFile::__construct	public	function