Development

/branches/1.3/lib/util/sfNamespacedParameterHolder.class.php

You must first sign up to be able to contribute.

root/branches/1.3/lib/util/sfNamespacedParameterHolder.class.php

Revision 29521, 9.3 kB (checked in by fabien, 5 years ago)

[1.3, 1.4] fixed E_STRICT compatbility of some unit tests (closes #8522)

  • Property svn:mime-type set to text/x-php
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
Line 
1 <?php
2
3 /*
4  * This file is part of the symfony package.
5  * (c) 2004-2006 Fabien Potencier <fabien.potencier@symfony-project.com>
6  * (c) 2004-2006 Sean Kerr <sean@code-box.org>
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 /**
13  * sfNamespacedParameterHolder provides a class for managing parameters
14  * with support for namespaces.
15  *
16  * Parameters, in this case, are used to extend classes with additional data
17  * that requires no additional logic to manage.
18  *
19  * @package    symfony
20  * @subpackage util
21  * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
22  * @author     Sean Kerr <sean@code-box.org>
23  * @version    SVN: $Id$
24  */
25 class sfNamespacedParameterHolder extends sfParameterHolder
26 {
27   protected $default_namespace = null;
28   protected $parameters = array();
29
30   /**
31    * The constructor for sfNamespacedParameterHolder.
32    *
33    * The default namespace may be overridden at initialization as follows:
34    * <code>
35    * <?php
36    * $mySpecialPH = new sfNamespacedParameterHolder('symfony/special');
37    * ?>
38    * </code>
39    */
40   public function __construct($namespace = 'symfony/default')
41   {
42     $this->default_namespace = $namespace;
43   }
44
45   /**
46    * Sets the default namespace value.
47    *
48    * @param string $namespace  Default namespace
49    * @param bool   $move       Move all values of the old default namespace to the new one or not
50    */
51   public function setDefaultNamespace($namespace, $move = true)
52   {
53     if ($move)
54     {
55       if (null !== $values = $this->removeNamespace())
56       {
57           $this->addByRef($values, $namespace);
58       }
59     }
60
61     $this->default_namespace = $namespace;
62   }
63
64   /**
65    * Get the default namespace value.
66    *
67    * The $default_namespace is defined as 'symfony/default'.
68    *
69    * @return string The default namespace
70    */
71   public function getDefaultNamespace()
72   {
73     return $this->default_namespace;
74   }
75
76   /**
77    * Clear all parameters associated with this request.
78    */
79   public function clear()
80   {
81     $this->parameters = null;
82     $this->parameters = array();
83   }
84
85   /**
86    * Retrieve a parameter with an optionally specified namespace.
87    *
88    * An isolated namespace may be identified by providing a value for the third
89    * argument.  If not specified, the default namespace 'symfony/default' is
90    * used.
91    *
92    * @param string $name     A parameter name
93    * @param mixed  $default  A default parameter value
94    * @param string $ns       A parameter namespace
95    *
96    * @return mixed A parameter value, if the parameter exists, otherwise null
97    */
98   public function & get($name, $default = null, $ns = null)
99   {
100     if (!$ns)
101     {
102       $ns = $this->default_namespace;
103     }
104
105     if (isset($this->parameters[$ns][$name]))
106     {
107       $value = & $this->parameters[$ns][$name];
108     }
109     else if (isset($this->parameters[$ns]))
110     {
111       $value = sfToolkit::getArrayValueForPath($this->parameters[$ns], $name, $default);
112     }
113     else
114     {
115       $value = $default;
116     }
117
118     return $value;
119   }
120
121   /**
122    * Retrieve an array of parameter names from an optionally specified namespace.
123    *
124    * @param  string $ns  A parameter namespace.
125    *
126    * @return array An indexed array of parameter names, if the namespace exists, otherwise null
127    */
128   public function getNames($ns = null)
129   {
130     if (!$ns)
131     {
132       $ns = $this->default_namespace;
133     }
134
135     if (isset($this->parameters[$ns]))
136     {
137       return array_keys($this->parameters[$ns]);
138     }
139
140     return array();
141   }
142
143   /**
144    * Retrieve an array of parameter namespaces.
145    *
146    * @return array An indexed array of parameter namespaces
147    */
148   public function getNamespaces()
149   {
150     return array_keys($this->parameters);
151   }
152
153   /**
154    * Retrieve an array of parameters, within a namespace.
155    *
156    * This method is limited to a namespace.  Without any argument,
157    * it returns the parameters of the default namespace.  If a
158    * namespace is passed as an argument, only the parameters of the
159    * specified namespace are returned.
160    *
161    * @param  string $ns  A parameter namespace
162    *
163    * @return array An associative array of parameters
164    */
165   public function & getAll($ns = null)
166   {
167     if (!$ns)
168     {
169       $ns = $this->default_namespace;
170     }
171
172     $parameters = array();
173
174     if (isset($this->parameters[$ns]))
175     {
176       $parameters = $this->parameters[$ns];
177     }
178
179     return $parameters;
180   }
181
182   /**
183    * Indicates whether or not a parameter exists.
184    *
185    * @param  string $name  A parameter name
186    * @param  string $ns    A parameter namespace
187    *
188    * @return bool true, if the parameter exists, otherwise false
189    */
190   public function has($name, $ns = null)
191   {
192     if (!$ns)
193     {
194       $ns = $this->default_namespace;
195     }
196
197     if (isset($this->parameters[$ns][$name]))
198     {
199       return true;
200     }
201     else if (isset($this->parameters[$ns]))
202     {
203       return sfToolkit::hasArrayValueForPath($this->parameters[$ns], $name);
204     }
205
206     return false;
207   }
208
209   /**
210    * Indicates whether or not A parameter namespace exists.
211    *
212    * @param  string $ns  A parameter namespace
213    *
214    * @return bool true, if the namespace exists, otherwise false
215    */
216   public function hasNamespace($ns)
217   {
218     return isset($this->parameters[$ns]);
219   }
220
221   /**
222    * Remove a parameter.
223    *
224    * @param  string $name     A parameter name
225    * @param  mixed  $default  A default parameter value
226    * @param  string $ns       A parameter namespace
227    *
228    * @return string A parameter value, if the parameter was removed, otherwise null
229    */
230   public function remove($name, $default = null, $ns = null)
231   {
232     if (!$ns)
233     {
234       $ns = $this->default_namespace;
235     }
236
237     $retval = $default;
238
239     if (isset($this->parameters[$ns]) && array_key_exists($name, $this->parameters[$ns]))
240     {
241       $retval = $this->parameters[$ns][$name];
242       unset($this->parameters[$ns][$name]);
243     }
244     else
245     {
246       $retval = sfToolkit::removeArrayValueForPath($this->parameters[$ns], $name, $default);
247     }
248
249     return $retval;
250   }
251
252   /**
253    * Remove A parameter namespace and all of its associated parameters.
254    *
255    * @param string $ns  A parameter namespace.
256    */
257   public function & removeNamespace($ns = null)
258   {
259     if (!$ns)
260     {
261       $ns = $this->default_namespace;
262     }
263
264     $retval = null;
265
266     if (isset($this->parameters[$ns]))
267     {
268       $retval =& $this->parameters[$ns];
269       unset($this->parameters[$ns]);
270     }
271
272     return $retval;
273   }
274
275   /**
276    * Set a parameter.
277    *
278    * If a parameter with the name already exists the value will be overridden.
279    *
280    * @param string $name   A parameter name
281    * @param mixed  $value  A parameter value
282    * @param string $ns     A parameter namespace
283    */
284   public function set($name, $value, $ns = null)
285   {
286     if (!$ns)
287     {
288       $ns = $this->default_namespace;
289     }
290
291     if (!isset($this->parameters[$ns]))
292     {
293       $this->parameters[$ns] = array();
294     }
295
296     $this->parameters[$ns][$name] = $value;
297   }
298
299   /**
300    * Set a parameter by reference.
301    *
302    * If a parameter with the name already exists the value will be overridden.
303    *
304    * @param string $name   A parameter name
305    * @param mixed  $value  A reference to a parameter value
306    * @param string $ns     A parameter namespace
307    */
308   public function setByRef($name, & $value, $ns = null)
309   {
310     if (!$ns)
311     {
312       $ns = $this->default_namespace;
313     }
314
315     if (!isset($this->parameters[$ns]))
316     {
317       $this->parameters[$ns] = array();
318     }
319
320     $this->parameters[$ns][$name] =& $value;
321   }
322
323   /**
324    * Set an array of parameters.
325    *
326    * If an existing parameter name matches any of the keys in the supplied
327    * array, the associated value will be overridden.
328    *
329    * @param array  $parameters  An associative array of parameters and their associated values
330    * @param string $ns          A parameter namespace
331    */
332   public function add($parameters, $ns = null)
333   {
334     if ($parameters === null) return;
335
336     if (!$ns)
337     {
338       $ns = $this->default_namespace;
339     }
340
341     if (!isset($this->parameters[$ns]))
342     {
343       $this->parameters[$ns] = array();
344     }
345
346     foreach ($parameters as $key => $value)
347     {
348       $this->parameters[$ns][$key] = $value;
349     }
350   }
351
352   /**
353    * Set an array of parameters by reference.
354    *
355    * If an existing parameter name matches any of the keys in the supplied
356    * array, the associated value will be overridden.
357    *
358    * @param array  $parameters  An associative array of parameters and references to their associated values
359    * @param string $ns          A parameter namespace
360    */
361   public function addByRef(& $parameters, $ns = null)
362   {
363     if (!$ns)
364     {
365       $ns = $this->default_namespace;
366     }
367
368     if (!isset($this->parameters[$ns]))
369     {
370       $this->parameters[$ns] = array();
371     }
372
373     foreach ($parameters as $key => &$value)
374     {
375       $this->parameters[$ns][$key] =& $value;
376     }
377   }
378
379   /**
380    * Serializes the current instance.
381    *
382    * @return array Objects instance
383    */
384   public function serialize()
385   {
386     return serialize(array($this->default_namespace, $this->parameters));
387   }
388
389   /**
390    * Unserializes a sfNamespacedParameterHolder instance.
391    *
392    * @param string $serialized  A serialized sfNamespacedParameterHolder instance
393    */
394   public function unserialize($serialized)
395   {
396     $data = unserialize($serialized);
397
398     $this->default_namespace = $data[0];
399     $this->parameters = $data[1];
400   }
401 }
402
Note: See TracBrowser for help on using the browser.