vendor/symfony/http-foundation/HeaderBag.php line 19

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\HttpFoundation;
  14. /**
  15.  * HeaderBag is a container for HTTP headers.
  16.  *
  17.  * @author Fabien Potencier <fabien@symfony.com>
  18.  */
  19. class HeaderBag implements \IteratorAggregate, \Countable
  20. {
  21.     protected $headers = [];
  22.     protected $cacheControl = [];
  24.     /**
  25.      * @param array $headers An array of HTTP headers
  26.      */
  27.     public function __construct(array $headers = [])
  28.     {
  29.         foreach ($headers as $key => $values) {
  30.             $this->set($key, $values);
  31.         }
  32.     }
  34.     /**
  35.      * Returns the headers as a string.
  36.      *
  37.      * @return string The headers
  38.      */
  39.     public function __toString()
  40.     {
  41.         if (!$headers = $this->all()) {
  42.             return '';
  43.         }
  45.         ksort($headers);
  46.         $max = max(array_map('strlen', array_keys($headers))) + 1;
  47.         $content = '';
  48.         foreach ($headers as $name => $values) {
  49.             $name = implode('-', array_map('ucfirst', explode('-', $name)));
  50.             foreach ($values as $value) {
  51.                 $content .= sprintf("%-{$max}s %s\r\n", $name.':', $value);
  52.             }
  53.         }
  55.         return $content;
  56.     }
  58.     /**
  59.      * Returns the headers.
  60.      *
  61.      * @return array An array of headers
  62.      */
  63.     public function all()
  64.     {
  65.         return $this->headers;
  66.     }
  68.     /**
  69.      * Returns the parameter keys.
  70.      *
  71.      * @return array An array of parameter keys
  72.      */
  73.     public function keys()
  74.     {
  75.         return array_keys($this->all());
  76.     }
  78.     /**
  79.      * Replaces the current HTTP headers by a new set.
  80.      *
  81.      * @param array $headers An array of HTTP headers
  82.      */
  83.     public function replace(array $headers = [])
  84.     {
  85.         $this->headers = [];
  86.         $this->add($headers);
  87.     }
  89.     /**
  90.      * Adds new headers the current HTTP headers set.
  91.      *
  92.      * @param array $headers An array of HTTP headers
  93.      */
  94.     public function add(array $headers)
  95.     {
  96.         foreach ($headers as $key => $values) {
  97.             $this->set($key, $values);
  98.         }
  99.     }
  101.     /**
  102.      * Returns a header value by name.
  103.      *
  104.      * @param string      $key     The header name
  105.      * @param string|null $default The default value
  106.      * @param bool        $first   Whether to return the first value or all header values
  107.      *
  108.      * @return string|string[]|null The first header value or default value if $first is true, an array of values otherwise
  109.      */
  110.     public function get($key, $default = null, $first = true)
  111.     {
  112.         $key = str_replace('_', '-', strtolower($key));
  113.         $headers = $this->all();
  115.         if (!\array_key_exists($key, $headers)) {
  116.             if (null === $default) {
  117.                 return $first ? null : [];
  118.             }
  120.             return $first ? $default : [$default];
  121.         }
  123.         if ($first) {
  124.             if (!$headers[$key]) {
  125.                 return $default;
  126.             }
  128.             if (null === $headers[$key][0]) {
  129.                 return null;
  130.             }
  132.             return (string) $headers[$key][0];
  133.         }
  135.         return $headers[$key];
  136.     }
  138.     /**
  139.      * Sets a header by name.
  140.      *
  141.      * @param string          $key     The key
  142.      * @param string|string[] $values  The value or an array of values
  143.      * @param bool            $replace Whether to replace the actual value or not (true by default)
  144.      */
  145.     public function set($key, $values, $replace = true)
  146.     {
  147.         $key = str_replace('_', '-', strtolower($key));
  149.         if (\is_array($values)) {
  150.             $values = array_values($values);
  152.             if (true === $replace || !isset($this->headers[$key])) {
  153.                 $this->headers[$key] = $values;
  154.             } else {
  155.                 $this->headers[$key] = array_merge($this->headers[$key], $values);
  156.             }
  157.         } else {
  158.             if (true === $replace || !isset($this->headers[$key])) {
  159.                 $this->headers[$key] = [$values];
  160.             } else {
  161.                 $this->headers[$key][] = $values;
  162.             }
  163.         }
  165.         if ('cache-control' === $key) {
  166.             $this->cacheControl = $this->parseCacheControl(implode(', ', $this->headers[$key]));
  167.         }
  168.     }
  170.     /**
  171.      * Returns true if the HTTP header is defined.
  172.      *
  173.      * @param string $key The HTTP header
  174.      *
  175.      * @return bool true if the parameter exists, false otherwise
  176.      */
  177.     public function has($key)
  178.     {
  179.         return \array_key_exists(str_replace('_', '-', strtolower($key)), $this->all());
  180.     }
  182.     /**
  183.      * Returns true if the given HTTP header contains the given value.
  184.      *
  185.      * @param string $key   The HTTP header name
  186.      * @param string $value The HTTP value
  187.      *
  188.      * @return bool true if the value is contained in the header, false otherwise
  189.      */
  190.     public function contains($key, $value)
  191.     {
  192.         return \in_array($value, $this->get($key, null, false));
  193.     }
  195.     /**
  196.      * Removes a header.
  197.      *
  198.      * @param string $key The HTTP header name
  199.      */
  200.     public function remove($key)
  201.     {
  202.         $key = str_replace('_', '-', strtolower($key));
  204.         unset($this->headers[$key]);
  206.         if ('cache-control' === $key) {
  207.             $this->cacheControl = [];
  208.         }
  209.     }
  211.     /**
  212.      * Returns the HTTP header value converted to a date.
  213.      *
  214.      * @param string    $key     The parameter key
  215.      * @param \DateTime $default The default value
  216.      *
  217.      * @return \DateTime|null The parsed DateTime or the default value if the header does not exist
  218.      *
  219.      * @throws \RuntimeException When the HTTP header is not parseable
  220.      */
  221.     public function getDate($key, \DateTime $default = null)
  222.     {
  223.         if (null === $value = $this->get($key)) {
  224.             return $default;
  225.         }
  227.         if (false === $date = \DateTime::createFromFormat(DATE_RFC2822, $value)) {
  228.             throw new \RuntimeException(sprintf('The %s HTTP header is not parseable (%s).', $key, $value));
  229.         }
  231.         return $date;
  232.     }
  234.     /**
  235.      * Adds a custom Cache-Control directive.
  236.      *
  237.      * @param string $key   The Cache-Control directive name
  238.      * @param mixed  $value The Cache-Control directive value
  239.      */
  240.     public function addCacheControlDirective($key, $value = true)
  241.     {
  242.         $this->cacheControl[$key] = $value;
  244.         $this->set('Cache-Control', $this->getCacheControlHeader());
  245.     }
  247.     /**
  248.      * Returns true if the Cache-Control directive is defined.
  249.      *
  250.      * @param string $key The Cache-Control directive
  251.      *
  252.      * @return bool true if the directive exists, false otherwise
  253.      */
  254.     public function hasCacheControlDirective($key)
  255.     {
  256.         return \array_key_exists($key, $this->cacheControl);
  257.     }
  259.     /**
  260.      * Returns a Cache-Control directive value by name.
  261.      *
  262.      * @param string $key The directive name
  263.      *
  264.      * @return mixed|null The directive value if defined, null otherwise
  265.      */
  266.     public function getCacheControlDirective($key)
  267.     {
  268.         return \array_key_exists($key, $this->cacheControl) ? $this->cacheControl[$key] : null;
  269.     }
  271.     /**
  272.      * Removes a Cache-Control directive.
  273.      *
  274.      * @param string $key The Cache-Control directive
  275.      */
  276.     public function removeCacheControlDirective($key)
  277.     {
  278.         unset($this->cacheControl[$key]);
  280.         $this->set('Cache-Control', $this->getCacheControlHeader());
  281.     }
  283.     /**
  284.      * Returns an iterator for headers.
  285.      *
  286.      * @return \ArrayIterator An \ArrayIterator instance
  287.      */
  288.     public function getIterator()
  289.     {
  290.         return new \ArrayIterator($this->headers);
  291.     }
  293.     /**
  294.      * Returns the number of headers.
  295.      *
  296.      * @return int The number of headers
  297.      */
  298.     public function count()
  299.     {
  300.         return \count($this->headers);
  301.     }
  303.     protected function getCacheControlHeader()
  304.     {
  305.         $parts = [];
  306.         ksort($this->cacheControl);
  307.         foreach ($this->cacheControl as $key => $value) {
  308.             if (true === $value) {
  309.                 $parts[] = $key;
  310.             } else {
  311.                 if (preg_match('#[^a-zA-Z0-9._-]#', $value)) {
  312.                     $value = '"'.$value.'"';
  313.                 }
  315.                 $parts[] = "$key=$value";
  316.             }
  317.         }
  319.         return implode(', ', $parts);
  320.     }
  322.     /**
  323.      * Parses a Cache-Control HTTP header.
  324.      *
  325.      * @param string $header The value of the Cache-Control HTTP header
  326.      *
  327.      * @return array An array representing the attribute values
  328.      */
  329.     protected function parseCacheControl($header)
  330.     {
  331.         $cacheControl = [];
  332.         preg_match_all('#([a-zA-Z][a-zA-Z_-]*)\s*(?:=(?:"([^"]*)"|([^ \t",;]*)))?#', $header, $matches, PREG_SET_ORDER);
  333.         foreach ($matches as $match) {
  334.             $cacheControl[strtolower($match[1])] = isset($match[3]) ? $match[3] : (isset($match[2]) ? $match[2] : true);
  335.         }
  337.         return $cacheControl;
  338.     }
  339. }