1. sfParameterHolder.class.php
  2. /**
 * sfParameterHolder provides a base class for managing parameters.
 *
 * Parameters, in this case, are used to extend classes with additional data
 * that requires no additional logic to manage.
 *
 * @package    symfony
 * @subpackage util
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfParameterHolder.class.php 23922 2009-11-14 14:58:38Z fabien $
 */
  3. class sfParameterHolder implements Serializable
  4. {
  5.   protected $parameters = array();
  7.   /**
  8.    * The constructor for sfParameterHolder.
  9.    */
  10.   public function __construct()
  11.   {
  12.   }
  14.   /**
  15.    * Clears all parameters associated with this request.
  16.    */
  17.   public function clear()
  18.   {
  19.     $this->parameters = array();
  20.   }
  22.   /**
  23.    * Retrieves a parameter.
  24.    *
  25.    * @param  string $name     A parameter name
  26.    * @param  mixed  $default  A default parameter value
  27.    *
  28.    * @return mixed A parameter value, if the parameter exists, otherwise null
  29.    */
  30.   public function & get($name, $default = null)
  31.   {
  32.     if (array_key_exists($name, $this->parameters))
  33.     {
  34.       $value = & $this->parameters[$name];
  35.     }
  36.     else
  37.     {
  38.       $value = $default;
  39.     }
  41.     return $value;
  42.   }
  44.   /**
  45.    * Retrieves an array of parameter names.
  46.    *
  47.    * @return array An indexed array of parameter names
  48.    */
  49.   public function getNames()
  50.   {
  51.     return array_keys($this->parameters);
  52.   }
  54.   /**
  55.    * Retrieves an array of parameters.
  56.    *
  57.    * @return array An associative array of parameters
  58.    */
  59.   public function & getAll()
  60.   {
  61.     return $this->parameters;
  62.   }
  64.   /**
  65.    * Indicates whether or not a parameter exists.
  66.    *
  67.    * @param  string $name  A parameter name
  68.    *
  69.    * @return bool true, if the parameter exists, otherwise false
  70.    */
  71.   public function has($name)
  72.   {
  73.     return array_key_exists($name, $this->parameters);
  74.   }
  76.   /**
  77.    * Remove a parameter.
  78.    *
  79.    * @param  string $name     A parameter name
  80.    * @param  mixed  $default  A default parameter value
  81.    *
  82.    * @return string A parameter value, if the parameter was removed, otherwise null
  83.    */
  84.   public function remove($name, $default = null)
  85.   {
  86.     $retval = $default;
  88.     if (array_key_exists($name, $this->parameters))
  89.     {
  90.       $retval = $this->parameters[$name];
  91.       unset($this->parameters[$name]);
  92.     }
  94.     return $retval;
  95.   }
  97.   /**
  98.    * Sets a parameter.
  99.    *
  100.    * If a parameter with the name already exists the value will be overridden.
  101.    *
  102.    * @param string $name   A parameter name
  103.    * @param mixed  $value  A parameter value
  104.    */
  105.   public function set($name, $value)
  106.   {
  107.     $this->parameters[$name] = $value;
  108.   }
  110.   /**
  111.    * Sets a parameter by reference.
  112.    *
  113.    * If a parameter with the name already exists the value will be overridden.
  114.    *
  115.    * @param string $name   A parameter name
  116.    * @param mixed  $value  A reference to a parameter value
  117.    */
  118.   public function setByRef($name, & $value)
  119.   {
  120.     $this->parameters[$name] =& $value;
  121.   }
  123.   /**
  124.    * Sets an array of parameters.
  125.    *
  126.    * If an existing parameter name matches any of the keys in the supplied
  127.    * array, the associated value will be overridden.
  128.    *
  129.    * @param array $parameters  An associative array of parameters and their associated values
  130.    */
  131.   public function add($parameters)
  132.   {
  133.     if (null === $parameters)
  134.     {
  135.       return;
  136.     }
  138.     foreach ($parameters as $key => $value)
  139.     {
  140.       $this->parameters[$key] = $value;
  141.     }
  142.   }
  144.   /**
  145.    * Sets an array of parameters by reference.
  146.    *
  147.    * If an existing parameter name matches any of the keys in the supplied
  148.    * array, the associated value will be overridden.
  149.    *
  150.    * @param array $parameters  An associative array of parameters and references to their associated values
  151.    */
  152.   public function addByRef(& $parameters)
  153.   {
  154.     foreach ($parameters as $key => &$value)
  155.     {
  156.       $this->parameters[$key] =& $value;
  157.     }
  158.   }
  160.   /**
  161.    * Serializes the current instance.
  162.    *
  163.    * @return array Objects instance
  164.    */
  165.   public function serialize()
  166.   {
  167.     return serialize($this->parameters);
  168.   }
  170.   /**
  171.    * Unserializes a sfParameterHolder instance.
  172.    *
  173.    * @param string $serialized  A serialized sfParameterHolder instance
  174.    */
  175.   public function unserialize($serialized)
  176.   {
  177.     $this->parameters = unserialize($serialized);
  178.   }
  179. }
Debug toolbar