vendor/symfony/http-foundation/ParameterBag.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.  * ParameterBag is a container for key/value pairs.
  16.  *
  17.  * @author Fabien Potencier <fabien@symfony.com>
  18.  */
  19. class ParameterBag implements \IteratorAggregate, \Countable
  20. {
  21.     /**
  22.      * Parameter storage.
  23.      */
  24.     protected $parameters;
  26.     public function __construct(array $parameters = [])
  27.     {
  28.         $this->parameters = $parameters;
  29.     }
  31.     /**
  32.      * Returns the parameters.
  33.      *
  34.      * @return array An array of parameters
  35.      */
  36.     public function all()
  37.     {
  38.         return $this->parameters;
  39.     }
  41.     /**
  42.      * Returns the parameter keys.
  43.      *
  44.      * @return array An array of parameter keys
  45.      */
  46.     public function keys()
  47.     {
  48.         return array_keys($this->parameters);
  49.     }
  51.     /**
  52.      * Replaces the current parameters by a new set.
  53.      */
  54.     public function replace(array $parameters = [])
  55.     {
  56.         $this->parameters = $parameters;
  57.     }
  59.     /**
  60.      * Adds parameters.
  61.      */
  62.     public function add(array $parameters = [])
  63.     {
  64.         $this->parameters = array_replace($this->parameters, $parameters);
  65.     }
  67.     /**
  68.      * Returns a parameter by name.
  69.      *
  70.      * @param mixed $default The default value if the parameter key does not exist
  71.      *
  72.      * @return mixed
  73.      */
  74.     public function get(string $key, $default = null)
  75.     {
  76.         return \array_key_exists($key, $this->parameters) ? $this->parameters[$key] : $default;
  77.     }
  79.     /**
  80.      * Sets a parameter by name.
  81.      *
  82.      * @param mixed $value The value
  83.      */
  84.     public function set(string $key, $value)
  85.     {
  86.         $this->parameters[$key] = $value;
  87.     }
  89.     /**
  90.      * Returns true if the parameter is defined.
  91.      *
  92.      * @return bool true if the parameter exists, false otherwise
  93.      */
  94.     public function has(string $key)
  95.     {
  96.         return \array_key_exists($key, $this->parameters);
  97.     }
  99.     /**
  100.      * Removes a parameter.
  101.      */
  102.     public function remove(string $key)
  103.     {
  104.         unset($this->parameters[$key]);
  105.     }
  107.     /**
  108.      * Returns the alphabetic characters of the parameter value.
  109.      *
  110.      * @return string The filtered value
  111.      */
  112.     public function getAlpha(string $key, string $default = '')
  113.     {
  114.         return preg_replace('/[^[:alpha:]]/', '', $this->get($key, $default));
  115.     }
  117.     /**
  118.      * Returns the alphabetic characters and digits of the parameter value.
  119.      *
  120.      * @return string The filtered value
  121.      */
  122.     public function getAlnum(string $key, string $default = '')
  123.     {
  124.         return preg_replace('/[^[:alnum:]]/', '', $this->get($key, $default));
  125.     }
  127.     /**
  128.      * Returns the digits of the parameter value.
  129.      *
  130.      * @return string The filtered value
  131.      */
  132.     public function getDigits(string $key, string $default = '')
  133.     {
  134.         // we need to remove - and + because they're allowed in the filter
  135.         return str_replace(['-', '+'], '', $this->filter($key, $default, FILTER_SANITIZE_NUMBER_INT));
  136.     }
  138.     /**
  139.      * Returns the parameter value converted to integer.
  140.      *
  141.      * @return int The filtered value
  142.      */
  143.     public function getInt(string $key, int $default = 0)
  144.     {
  145.         return (int) $this->get($key, $default);
  146.     }
  148.     /**
  149.      * Returns the parameter value converted to boolean.
  150.      *
  151.      * @return bool The filtered value
  152.      */
  153.     public function getBoolean(string $key, bool $default = false)
  154.     {
  155.         return $this->filter($key, $default, FILTER_VALIDATE_BOOLEAN);
  156.     }
  158.     /**
  159.      * Filter key.
  160.      *
  161.      * @param mixed $default Default = null
  162.      * @param int   $filter  FILTER_* constant
  163.      * @param mixed $options Filter options
  164.      *
  165.      * @see https://php.net/filter-var
  166.      *
  167.      * @return mixed
  168.      */
  169.     public function filter(string $key, $default = null, int $filter = FILTER_DEFAULT, $options = [])
  170.     {
  171.         $value = $this->get($key, $default);
  173.         // Always turn $options into an array - this allows filter_var option shortcuts.
  174.         if (!\is_array($options) && $options) {
  175.             $options = ['flags' => $options];
  176.         }
  178.         // Add a convenience check for arrays.
  179.         if (\is_array($value) && !isset($options['flags'])) {
  180.             $options['flags'] = FILTER_REQUIRE_ARRAY;
  181.         }
  183.         return filter_var($value, $filter, $options);
  184.     }
  186.     /**
  187.      * Returns an iterator for parameters.
  188.      *
  189.      * @return \ArrayIterator An \ArrayIterator instance
  190.      */
  191.     public function getIterator()
  192.     {
  193.         return new \ArrayIterator($this->parameters);
  194.     }
  196.     /**
  197.      * Returns the number of parameters.
  198.      *
  199.      * @return int The number of parameters
  200.      */
  201.     public function count()
  202.     {
  203.         return \count($this->parameters);
  204.     }
  205. }