[Summary view] [Print] [Text view]

   1  <?php
   2  
   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   */
  11  
  12  namespace Symfony\Component\HttpFoundation;
  13  
  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 = array();
  22      protected $cacheControl = array();
  23  
  24      /**
  25       * @param array $headers An array of HTTP headers
  26       */
  27      public function __construct(array $headers = array())
  28      {
  29          foreach ($headers as $key => $values) {
  30              $this->set($key, $values);
  31          }
  32      }
  33  
  34      /**
  35       * Returns the headers as a string.
  36       *
  37       * @return string The headers
  38       */
  39      public function __toString()
  40      {
  41          if (!$this->headers) {
  42              return '';
  43          }
  44  
  45          $max = max(array_map('strlen', array_keys($this->headers))) + 1;
  46          $content = '';
  47          ksort($this->headers);
  48          foreach ($this->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          }
  54  
  55          return $content;
  56      }
  57  
  58      /**
  59       * Returns the headers.
  60       *
  61       * @return array An array of headers
  62       */
  63      public function all()
  64      {
  65          return $this->headers;
  66      }
  67  
  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->headers);
  76      }
  77  
  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 = array())
  84      {
  85          $this->headers = array();
  86          $this->add($headers);
  87      }
  88  
  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      }
 100  
 101      /**
 102       * Returns a header value by name.
 103       *
 104       * @param string               $key     The header name
 105       * @param string|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  
 114          if (!array_key_exists($key, $this->headers)) {
 115              if (null === $default) {
 116                  return $first ? null : array();
 117              }
 118  
 119              return $first ? $default : array($default);
 120          }
 121  
 122          if ($first) {
 123              return \count($this->headers[$key]) ? $this->headers[$key][0] : $default;
 124          }
 125  
 126          return $this->headers[$key];
 127      }
 128  
 129      /**
 130       * Sets a header by name.
 131       *
 132       * @param string          $key     The key
 133       * @param string|string[] $values  The value or an array of values
 134       * @param bool            $replace Whether to replace the actual value or not (true by default)
 135       */
 136      public function set($key, $values, $replace = true)
 137      {
 138          $key = str_replace('_', '-', strtolower($key));
 139  
 140          $values = array_values((array) $values);
 141  
 142          if (true === $replace || !isset($this->headers[$key])) {
 143              $this->headers[$key] = $values;
 144          } else {
 145              $this->headers[$key] = array_merge($this->headers[$key], $values);
 146          }
 147  
 148          if ('cache-control' === $key) {
 149              $this->cacheControl = $this->parseCacheControl(implode(', ', $this->headers[$key]));
 150          }
 151      }
 152  
 153      /**
 154       * Returns true if the HTTP header is defined.
 155       *
 156       * @param string $key The HTTP header
 157       *
 158       * @return bool true if the parameter exists, false otherwise
 159       */
 160      public function has($key)
 161      {
 162          return array_key_exists(str_replace('_', '-', strtolower($key)), $this->headers);
 163      }
 164  
 165      /**
 166       * Returns true if the given HTTP header contains the given value.
 167       *
 168       * @param string $key   The HTTP header name
 169       * @param string $value The HTTP value
 170       *
 171       * @return bool true if the value is contained in the header, false otherwise
 172       */
 173      public function contains($key, $value)
 174      {
 175          return \in_array($value, $this->get($key, null, false));
 176      }
 177  
 178      /**
 179       * Removes a header.
 180       *
 181       * @param string $key The HTTP header name
 182       */
 183      public function remove($key)
 184      {
 185          $key = str_replace('_', '-', strtolower($key));
 186  
 187          unset($this->headers[$key]);
 188  
 189          if ('cache-control' === $key) {
 190              $this->cacheControl = array();
 191          }
 192      }
 193  
 194      /**
 195       * Returns the HTTP header value converted to a date.
 196       *
 197       * @param string    $key     The parameter key
 198       * @param \DateTime $default The default value
 199       *
 200       * @return \DateTime|null The parsed DateTime or the default value if the header does not exist
 201       *
 202       * @throws \RuntimeException When the HTTP header is not parseable
 203       */
 204      public function getDate($key, \DateTime $default = null)
 205      {
 206          if (null === $value = $this->get($key)) {
 207              return $default;
 208          }
 209  
 210          if (false === $date = \DateTime::createFromFormat(DATE_RFC2822, $value)) {
 211              throw new \RuntimeException(sprintf('The %s HTTP header is not parseable (%s).', $key, $value));
 212          }
 213  
 214          return $date;
 215      }
 216  
 217      /**
 218       * Adds a custom Cache-Control directive.
 219       *
 220       * @param string $key   The Cache-Control directive name
 221       * @param mixed  $value The Cache-Control directive value
 222       */
 223      public function addCacheControlDirective($key, $value = true)
 224      {
 225          $this->cacheControl[$key] = $value;
 226  
 227          $this->set('Cache-Control', $this->getCacheControlHeader());
 228      }
 229  
 230      /**
 231       * Returns true if the Cache-Control directive is defined.
 232       *
 233       * @param string $key The Cache-Control directive
 234       *
 235       * @return bool true if the directive exists, false otherwise
 236       */
 237      public function hasCacheControlDirective($key)
 238      {
 239          return array_key_exists($key, $this->cacheControl);
 240      }
 241  
 242      /**
 243       * Returns a Cache-Control directive value by name.
 244       *
 245       * @param string $key The directive name
 246       *
 247       * @return mixed|null The directive value if defined, null otherwise
 248       */
 249      public function getCacheControlDirective($key)
 250      {
 251          return array_key_exists($key, $this->cacheControl) ? $this->cacheControl[$key] : null;
 252      }
 253  
 254      /**
 255       * Removes a Cache-Control directive.
 256       *
 257       * @param string $key The Cache-Control directive
 258       */
 259      public function removeCacheControlDirective($key)
 260      {
 261          unset($this->cacheControl[$key]);
 262  
 263          $this->set('Cache-Control', $this->getCacheControlHeader());
 264      }
 265  
 266      /**
 267       * Returns an iterator for headers.
 268       *
 269       * @return \ArrayIterator An \ArrayIterator instance
 270       */
 271      public function getIterator()
 272      {
 273          return new \ArrayIterator($this->headers);
 274      }
 275  
 276      /**
 277       * Returns the number of headers.
 278       *
 279       * @return int The number of headers
 280       */
 281      public function count()
 282      {
 283          return \count($this->headers);
 284      }
 285  
 286      protected function getCacheControlHeader()
 287      {
 288          $parts = array();
 289          ksort($this->cacheControl);
 290          foreach ($this->cacheControl as $key => $value) {
 291              if (true === $value) {
 292                  $parts[] = $key;
 293              } else {
 294                  if (preg_match('#[^a-zA-Z0-9._-]#', $value)) {
 295                      $value = '"'.$value.'"';
 296                  }
 297  
 298                  $parts[] = "$key=$value";
 299              }
 300          }
 301  
 302          return implode(', ', $parts);
 303      }
 304  
 305      /**
 306       * Parses a Cache-Control HTTP header.
 307       *
 308       * @param string $header The value of the Cache-Control HTTP header
 309       *
 310       * @return array An array representing the attribute values
 311       */
 312      protected function parseCacheControl($header)
 313      {
 314          $cacheControl = array();
 315          preg_match_all('#([a-zA-Z][a-zA-Z_-]*)\s*(?:=(?:"([^"]*)"|([^ \t",;]*)))?#', $header, $matches, PREG_SET_ORDER);
 316          foreach ($matches as $match) {
 317              $cacheControl[strtolower($match[1])] = isset($match[3]) ? $match[3] : (isset($match[2]) ? $match[2] : true);
 318          }
 319  
 320          return $cacheControl;
 321      }
 322  }