vendor/nyholm/psr7/src/ServerRequest.php line 16

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Nyholm\Psr7;
  7. use Psr\Http\Message\{ServerRequestInterface, StreamInterface, UploadedFileInterface, UriInterface};
  9. /**
  10.  * @author Michael Dowling and contributors to guzzlehttp/psr7
  11.  * @author Tobias Nyholm <tobias.nyholm@gmail.com>
  12.  * @author Martijn van der Ven <martijn@vanderven.se>
  13.  *
  14.  * @final This class should never be extended. See https://github.com/Nyholm/psr7/blob/master/doc/final.md
  15.  */
  16. class ServerRequest implements ServerRequestInterface
  17. {
  18.     use MessageTrait;
  19.     use RequestTrait;
  21.     /** @var array */
  22.     private $attributes = [];
  24.     /** @var array */
  25.     private $cookieParams = [];
  27.     /** @var array|object|null */
  28.     private $parsedBody;
  30.     /** @var array */
  31.     private $queryParams = [];
  33.     /** @var array */
  34.     private $serverParams;
  36.     /** @var UploadedFileInterface[] */
  37.     private $uploadedFiles = [];
  39.     /**
  40.      * @param string $method HTTP method
  41.      * @param string|UriInterface $uri URI
  42.      * @param array $headers Request headers
  43.      * @param string|resource|StreamInterface|null $body Request body
  44.      * @param string $version Protocol version
  45.      * @param array $serverParams Typically the $_SERVER superglobal
  46.      */
  47.     public function __construct(string $method, $uri, array $headers = [], $body = null, string $version = '1.1', array $serverParams = [])
  48.     {
  49.         $this->serverParams = $serverParams;
  51.         if (!($uri instanceof UriInterface)) {
  52.             $uri = new Uri($uri);
  53.         }
  55.         $this->method = $method;
  56.         $this->uri = $uri;
  57.         $this->setHeaders($headers);
  58.         $this->protocol = $version;
  60.         if (!$this->hasHeader('Host')) {
  61.             $this->updateHostFromUri();
  62.         }
  64.         // If we got no body, defer initialization of the stream until ServerRequest::getBody()
  65.         if ('' !== $body && null !== $body) {
  66.             $this->stream = Stream::create($body);
  67.         }
  68.     }
  70.     public function getServerParams(): array
  71.     {
  72.         return $this->serverParams;
  73.     }
  75.     public function getUploadedFiles(): array
  76.     {
  77.         return $this->uploadedFiles;
  78.     }
  80.     public function withUploadedFiles(array $uploadedFiles)
  81.     {
  82.         $new = clone $this;
  83.         $new->uploadedFiles = $uploadedFiles;
  85.         return $new;
  86.     }
  88.     public function getCookieParams(): array
  89.     {
  90.         return $this->cookieParams;
  91.     }
  93.     public function withCookieParams(array $cookies)
  94.     {
  95.         $new = clone $this;
  96.         $new->cookieParams = $cookies;
  98.         return $new;
  99.     }
  101.     public function getQueryParams(): array
  102.     {
  103.         return $this->queryParams;
  104.     }
  106.     public function withQueryParams(array $query)
  107.     {
  108.         $new = clone $this;
  109.         $new->queryParams = $query;
  111.         return $new;
  112.     }
  114.     public function getParsedBody()
  115.     {
  116.         return $this->parsedBody;
  117.     }
  119.     public function withParsedBody($data)
  120.     {
  121.         if (!\is_array($data) && !\is_object($data) && null !== $data) {
  122.             throw new \InvalidArgumentException('First parameter to withParsedBody MUST be object, array or null');
  123.         }
  125.         $new = clone $this;
  126.         $new->parsedBody = $data;
  128.         return $new;
  129.     }
  131.     public function getAttributes(): array
  132.     {
  133.         return $this->attributes;
  134.     }
  136.     public function getAttribute($attribute, $default = null)
  137.     {
  138.         if (false === \array_key_exists($attribute, $this->attributes)) {
  139.             return $default;
  140.         }
  142.         return $this->attributes[$attribute];
  143.     }
  145.     public function withAttribute($attribute, $value): self
  146.     {
  147.         $new = clone $this;
  148.         $new->attributes[$attribute] = $value;
  150.         return $new;
  151.     }
  153.     public function withoutAttribute($attribute): self
  154.     {
  155.         if (false === \array_key_exists($attribute, $this->attributes)) {
  156.             return $this;
  157.         }
  159.         $new = clone $this;
  160.         unset($new->attributes[$attribute]);
  162.         return $new;
  163.     }
  164. }