1. sfNamespacedParameterHolder.class.php
  2. /**
 * sfNamespacedParameterHolder provides a class for managing parameters
 * with support for namespaces.
 *
 * 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: sfNamespacedParameterHolder.class.php 23922 2009-11-14 14:58:38Z fabien $
 */
  3. class sfNamespacedParameterHolder extends sfParameterHolder
  4. {
  5.   protected $default_namespace = null;
  6.   protected $parameters = array();
  8.   /**
  9.    * The constructor for sfNamespacedParameterHolder.
  10.    *
  11.    * The default namespace may be overridden at initialization as follows:
  12.    * <code>
  13.    * <?php
  14.    * $mySpecialPH = new sfNamespacedParameterHolder('symfony/special');
  15.    * ?>
  16.    * </code>
  17.    */
  18.   public function __construct($namespace = 'symfony/default')
  19.   {
  20.     $this->default_namespace = $namespace;
  21.   }
  23.   /**
  24.    * Sets the default namespace value.
  25.    *
  26.    * @param string $namespace  Default namespace
  27.    * @param bool   $move       Move all values of the old default namespace to the new one or not
  28.    */
  29.   public function setDefaultNamespace($namespace, $move = true)
  30.   {
  31.     if ($move)
  32.     {
  33.       $values = $this->removeNamespace();
  34.       $this->addByRef($values, $namespace);
  35.     }
  37.     $this->default_namespace = $namespace;
  38.   }
  40.   /**
  41.    * Get the default namespace value.
  42.    *
  43.    * The $default_namespace is defined as 'symfony/default'.
  44.    *
  45.    * @return string The default namespace
  46.    */
  47.   public function getDefaultNamespace()
  48.   {
  49.     return $this->default_namespace;
  50.   }
  52.   /**
  53.    * Clear all parameters associated with this request.
  54.    */
  55.   public function clear()
  56.   {
  57.     $this->parameters = null;
  58.     $this->parameters = array();
  59.   }
  61.   /**
  62.    * Retrieve a parameter with an optionally specified namespace.
  63.    *
  64.    * An isolated namespace may be identified by providing a value for the third
  65.    * argument.  If not specified, the default namespace 'symfony/default' is
  66.    * used.
  67.    *
  68.    * @param string $name     A parameter name
  69.    * @param mixed  $default  A default parameter value
  70.    * @param string $ns       A parameter namespace
  71.    *
  72.    * @return mixed A parameter value, if the parameter exists, otherwise null
  73.    */
  74.   public function & get($name, $default = null, $ns = null)
  75.   {
  76.     if (!$ns)
  77.     {
  78.       $ns = $this->default_namespace;
  79.     }
  81.     if (isset($this->parameters[$ns][$name]))
  82.     {
  83.       $value = & $this->parameters[$ns][$name];
  84.     }
  85.     else
  86.     {
  87.       $value = $default;
  88.     }
  90.     return $value;
  91.   }
  93.   /**
  94.    * Retrieve an array of parameter names from an optionally specified namespace.
  95.    *
  96.    * @param  string $ns  A parameter namespace.
  97.    *
  98.    * @return array An indexed array of parameter names, if the namespace exists, otherwise null
  99.    */
  100.   public function getNames($ns = null)
  101.   {
  102.     if (!$ns)
  103.     {
  104.       $ns = $this->default_namespace;
  105.     }
  107.     if (isset($this->parameters[$ns]))
  108.     {
  109.       return array_keys($this->parameters[$ns]);
  110.     }
  112.     return array();
  113.   }
  115.   /**
  116.    * Retrieve an array of parameter namespaces.
  117.    *
  118.    * @return array An indexed array of parameter namespaces
  119.    */
  120.   public function getNamespaces()
  121.   {
  122.     return array_keys($this->parameters);
  123.   }
  125.   /**
  126.    * Retrieve an array of parameters, within a namespace.
  127.    *
  128.    * This method is limited to a namespace.  Without any argument,
  129.    * it returns the parameters of the default namespace.  If a 
  130.    * namespace is passed as an argument, only the parameters of the
  131.    * specified namespace are returned.
  132.    *
  133.    * @param  string $ns  A parameter namespace
  134.    *
  135.    * @return array An associative array of parameters
  136.    */
  137.   public function & getAll($ns = null)
  138.   {
  139.     if (!$ns)
  140.     {
  141.       $ns = $this->default_namespace;
  142.     }
  144.     $parameters = array();
  146.     if (isset($this->parameters[$ns]))
  147.     {
  148.       $parameters = $this->parameters[$ns];
  149.     }
  151.     return $parameters;
  152.   }
  154.   /**
  155.    * Indicates whether or not a parameter exists.
  156.    *
  157.    * @param  string $name  A parameter name
  158.    * @param  string $ns    A parameter namespace
  159.    *
  160.    * @return bool true, if the parameter exists, otherwise false
  161.    */
  162.   public function has($name, $ns = null)
  163.   {
  164.     if (!$ns)
  165.     {
  166.       $ns = $this->default_namespace;
  167.     }
  169.     return isset($this->parameters[$ns][$name]);
  170.   }
  172.   /**
  173.    * Indicates whether or not A parameter namespace exists.
  174.    *
  175.    * @param  string $ns  A parameter namespace
  176.    *
  177.    * @return bool true, if the namespace exists, otherwise false
  178.    */
  179.   public function hasNamespace($ns)
  180.   {
  181.     return isset($this->parameters[$ns]);
  182.   }
  184.   /**
  185.    * Remove a parameter.
  186.    *
  187.    * @param  string $name     A parameter name
  188.    * @param  mixed  $default  A default parameter value
  189.    * @param  string $ns       A parameter namespace
  190.    *
  191.    * @return string A parameter value, if the parameter was removed, otherwise null
  192.    */
  193.   public function remove($name, $default = null, $ns = null)
  194.   {
  195.     if (!$ns)
  196.     {
  197.       $ns = $this->default_namespace;
  198.     }
  200.     $retval = $default;
  202.     if (isset($this->parameters[$ns]) && array_key_exists($name, $this->parameters[$ns]))
  203.     {
  204.       $retval = $this->parameters[$ns][$name];
  205.       unset($this->parameters[$ns][$name]);
  206.     }
  208.     return $retval;
  209.   }
  211.   /**
  212.    * Remove A parameter namespace and all of its associated parameters.
  213.    *
  214.    * @param string $ns  A parameter namespace.
  215.    */
  216.   public function & removeNamespace($ns = null)
  217.   {
  218.     if (!$ns)
  219.     {
  220.       $ns = $this->default_namespace;
  221.     }
  223.     $retval = null;
  225.     if (isset($this->parameters[$ns]))
  226.     {
  227.       $retval =& $this->parameters[$ns];
  228.       unset($this->parameters[$ns]);
  229.     }
  231.     return $retval;
  232.   }
  234.   /**
  235.    * Set a parameter.
  236.    *
  237.    * If a parameter with the name already exists the value will be overridden.
  238.    *
  239.    * @param string $name   A parameter name
  240.    * @param mixed  $value  A parameter value
  241.    * @param string $ns     A parameter namespace
  242.    */
  243.   public function set($name, $value, $ns = null)
  244.   {
  245.     if (!$ns)
  246.     {
  247.       $ns = $this->default_namespace;
  248.     }
  250.     if (!isset($this->parameters[$ns]))
  251.     {
  252.       $this->parameters[$ns] = array();
  253.     }
  255.     $this->parameters[$ns][$name] = $value;
  256.   }
  258.   /**
  259.    * Set a parameter by reference.
  260.    *
  261.    * If a parameter with the name already exists the value will be overridden.
  262.    *
  263.    * @param string $name   A parameter name
  264.    * @param mixed  $value  A reference to a parameter value
  265.    * @param string $ns     A parameter namespace
  266.    */
  267.   public function setByRef($name, & $value, $ns = null)
  268.   {
  269.     if (!$ns)
  270.     {
  271.       $ns = $this->default_namespace;
  272.     }
  274.     if (!isset($this->parameters[$ns]))
  275.     {
  276.       $this->parameters[$ns] = array();
  277.     }
  279.     $this->parameters[$ns][$name] =& $value;
  280.   }
  282.   /**
  283.    * Set an array of parameters.
  284.    *
  285.    * If an existing parameter name matches any of the keys in the supplied
  286.    * array, the associated value will be overridden.
  287.    *
  288.    * @param array  $parameters  An associative array of parameters and their associated values
  289.    * @param string $ns          A parameter namespace
  290.    */
  291.   public function add($parameters, $ns = null)
  292.   {
  293.     if ($parameters === null) return;
  295.     if (!$ns)
  296.     {
  297.       $ns = $this->default_namespace;
  298.     }
  300.     if (!isset($this->parameters[$ns]))
  301.     {
  302.       $this->parameters[$ns] = array();
  303.     }
  305.     foreach ($parameters as $key => $value)
  306.     {
  307.       $this->parameters[$ns][$key] = $value;
  308.     }
  309.   }
  311.   /**
  312.    * Set an array of parameters by reference.
  313.    *
  314.    * If an existing parameter name matches any of the keys in the supplied
  315.    * array, the associated value will be overridden.
  316.    *
  317.    * @param array  $parameters  An associative array of parameters and references to their associated values
  318.    * @param string $ns          A parameter namespace
  319.    */
  320.   public function addByRef(& $parameters, $ns = null)
  321.   {
  322.     if (!$ns)
  323.     {
  324.       $ns = $this->default_namespace;
  325.     }
  327.     if (!isset($this->parameters[$ns]))
  328.     {
  329.       $this->parameters[$ns] = array();
  330.     }
  332.     foreach ($parameters as $key => &$value)
  333.     {
  334.       $this->parameters[$ns][$key] =& $value;
  335.     }
  336.   }
  338.   /**
  339.    * Serializes the current instance.
  340.    *
  341.    * @return array Objects instance
  342.    */
  343.   public function serialize()
  344.   {
  345.     return serialize(array($this->default_namespace, $this->parameters));
  346.   }
  348.   /**
  349.    * Unserializes a sfNamespacedParameterHolder instance.
  350.    *
  351.    * @param string $serialized  A serialized sfNamespacedParameterHolder instance
  352.    */
  353.   public function unserialize($serialized)
  354.   {
  355.     $data = unserialize($serialized);
  357.     $this->default_namespace = $data[0];
  358.     $this->parameters = $data[1];
  359.   }
  360. }
Debug toolbar