interface/modules/zend_modules/library/Zend/Config/Config.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Config;
  11
  12 use ArrayAccess;
  13 use Countable;
  14 use Iterator;
  15
  16 /**
  17  * Provides a property based interface to an array.
  18  * The data are read-only unless $allowModifications is set to true
  19  * on construction.
  20  *
  21  * Implements Countable, Iterator and ArrayAccess
  22  * to facilitate easy access to the data.
  23  */
  24 class Config implements Countable, Iterator, ArrayAccess
  25 {
  26     /**
  27      * Whether modifications to configuration data are allowed.
  28      *
  29      * @var bool
  30      */
  31     protected $allowModifications;
  32
  33     /**
  34      * Number of elements in configuration data.
  35      *
  36      * @var int
  37      */
  38     protected $count;
  39
  40     /**
  41      * Data within the configuration.
  42      *
  43      * @var array
  44      */
  45     protected $data = array();
  46
  47     /**
  48      * Used when unsetting values during iteration to ensure we do not skip
  49      * the next element.
  50      *
  51      * @var bool
  52      */
  53     protected $skipNextIteration;
  54
  55     /**
  56      * Constructor.
  57      *
  58      * Data is read-only unless $allowModifications is set to true
  59      * on construction.
  60      *
  61      * @param  array   $array
  62      * @param  bool $allowModifications
  63      */
  64     public function __construct(array $array, $allowModifications = false)
  65     {
  66         $this->allowModifications = (bool) $allowModifications;
  67
  68         foreach ($array as $key => $value) {
  69             if (is_array($value)) {
  70                 $this->data[$key] = new static($value, $this->allowModifications);
  71             } else {
  72                 $this->data[$key] = $value;
  73             }
  74
  75             $this->count++;
  76         }
  77     }
  78
  79     /**
  80      * Retrieve a value and return $default if there is no element set.
  81      *
  82      * @param  string $name
  83      * @param  mixed  $default
  84      * @return mixed
  85      */
  86     public function get($name, $default = null)
  87     {
  88         if (array_key_exists($name, $this->data)) {
  89             return $this->data[$name];
  90         }
  91
  92         return $default;
  93     }
  94
  95     /**
  96      * Magic function so that $obj->value will work.
  97      *
  98      * @param  string $name
  99      * @return mixed
 100      */
 101     public function __get($name)
 102     {
 103         return $this->get($name);
 104     }
 105
 106     /**
 107      * Set a value in the config.
 108      *
 109      * Only allow setting of a property if $allowModifications  was set to true
 110      * on construction. Otherwise, throw an exception.
 111      *
 112      * @param  string $name
 113      * @param  mixed  $value
 114      * @return void
 115      * @throws Exception\RuntimeException
 116      */
 117     public function __set($name, $value)
 118     {
 119         if ($this->allowModifications) {
 120
 121             if (is_array($value)) {
 122                 $value = new static($value, true);
 123             }
 124
 125             if (null === $name) {
 126                 $this->data[] = $value;
 127             } else {
 128                 $this->data[$name] = $value;
 129             }
 130
 131             $this->count++;
 132         } else {
 133             throw new Exception\RuntimeException('Config is read only');
 134         }
 135     }
 136
 137     /**
 138      * Deep clone of this instance to ensure that nested Zend\Configs are also
 139      * cloned.
 140      *
 141      * @return void
 142      */
 143     public function __clone()
 144     {
 145         $array = array();
 146
 147         foreach ($this->data as $key => $value) {
 148             if ($value instanceof self) {
 149                 $array[$key] = clone $value;
 150             } else {
 151                 $array[$key] = $value;
 152             }
 153         }
 154
 155         $this->data = $array;
 156     }
 157
 158     /**
 159      * Return an associative array of the stored data.
 160      *
 161      * @return array
 162      */
 163     public function toArray()
 164     {
 165         $array = array();
 166         $data  = $this->data;
 167
 168         /** @var self $value */
 169         foreach ($data as $key => $value) {
 170             if ($value instanceof self) {
 171                 $array[$key] = $value->toArray();
 172             } else {
 173                 $array[$key] = $value;
 174             }
 175         }
 176
 177         return $array;
 178     }
 179
 180     /**
 181      * isset() overloading
 182      *
 183      * @param  string $name
 184      * @return bool
 185      */
 186     public function __isset($name)
 187     {
 188         return isset($this->data[$name]);
 189     }
 190
 191     /**
 192      * unset() overloading
 193      *
 194      * @param  string $name
 195      * @return void
 196      * @throws Exception\InvalidArgumentException
 197      */
 198     public function __unset($name)
 199     {
 200         if (!$this->allowModifications) {
 201             throw new Exception\InvalidArgumentException('Config is read only');
 202         } elseif (isset($this->data[$name])) {
 203             unset($this->data[$name]);
 204             $this->count--;
 205             $this->skipNextIteration = true;
 206         }
 207     }
 208
 209     /**
 210      * count(): defined by Countable interface.
 211      *
 212      * @see    Countable::count()
 213      * @return int
 214      */
 215     public function count()
 216     {
 217         return $this->count;
 218     }
 219
 220     /**
 221      * current(): defined by Iterator interface.
 222      *
 223      * @see    Iterator::current()
 224      * @return mixed
 225      */
 226     public function current()
 227     {
 228         $this->skipNextIteration = false;
 229         return current($this->data);
 230     }
 231
 232     /**
 233      * key(): defined by Iterator interface.
 234      *
 235      * @see    Iterator::key()
 236      * @return mixed
 237      */
 238     public function key()
 239     {
 240         return key($this->data);
 241     }
 242
 243     /**
 244      * next(): defined by Iterator interface.
 245      *
 246      * @see    Iterator::next()
 247      * @return void
 248      */
 249     public function next()
 250     {
 251         if ($this->skipNextIteration) {
 252             $this->skipNextIteration = false;
 253             return;
 254         }
 255
 256         next($this->data);
 257     }
 258
 259     /**
 260      * rewind(): defined by Iterator interface.
 261      *
 262      * @see    Iterator::rewind()
 263      * @return void
 264      */
 265     public function rewind()
 266     {
 267         $this->skipNextIteration = false;
 268         reset($this->data);
 269     }
 270
 271     /**
 272      * valid(): defined by Iterator interface.
 273      *
 274      * @see    Iterator::valid()
 275      * @return bool
 276      */
 277     public function valid()
 278     {
 279         return ($this->key() !== null);
 280     }
 281
 282     /**
 283      * offsetExists(): defined by ArrayAccess interface.
 284      *
 285      * @see    ArrayAccess::offsetExists()
 286      * @param  mixed $offset
 287      * @return bool
 288      */
 289     public function offsetExists($offset)
 290     {
 291         return $this->__isset($offset);
 292     }
 293
 294     /**
 295      * offsetGet(): defined by ArrayAccess interface.
 296      *
 297      * @see    ArrayAccess::offsetGet()
 298      * @param  mixed $offset
 299      * @return mixed
 300      */
 301     public function offsetGet($offset)
 302     {
 303         return $this->__get($offset);
 304     }
 305
 306     /**
 307      * offsetSet(): defined by ArrayAccess interface.
 308      *
 309      * @see    ArrayAccess::offsetSet()
 310      * @param  mixed $offset
 311      * @param  mixed $value
 312      * @return void
 313      */
 314     public function offsetSet($offset, $value)
 315     {
 316         $this->__set($offset, $value);
 317     }
 318
 319     /**
 320      * offsetUnset(): defined by ArrayAccess interface.
 321      *
 322      * @see    ArrayAccess::offsetUnset()
 323      * @param  mixed $offset
 324      * @return void
 325      */
 326     public function offsetUnset($offset)
 327     {
 328         $this->__unset($offset);
 329     }
 330
 331     /**
 332      * Merge another Config with this one.
 333      *
 334      * For duplicate keys, the following will be performed:
 335      * - Nested Configs will be recursively merged.
 336      * - Items in $merge with INTEGER keys will be appended.
 337      * - Items in $merge with STRING keys will overwrite current values.
 338      *
 339      * @param  Config $merge
 340      * @return Config
 341      */
 342     public function merge(Config $merge)
 343     {
 344         /** @var Config $value */
 345         foreach ($merge as $key => $value) {
 346             if (array_key_exists($key, $this->data)) {
 347                 if (is_int($key)) {
 348                     $this->data[] = $value;
 349                 } elseif ($value instanceof self && $this->data[$key] instanceof self) {
 350                     $this->data[$key]->merge($value);
 351                 } else {
 352                     if ($value instanceof self) {
 353                         $this->data[$key] = new static($value->toArray(), $this->allowModifications);
 354                     } else {
 355                         $this->data[$key] = $value;
 356                     }
 357                 }
 358             } else {
 359                 if ($value instanceof self) {
 360                     $this->data[$key] = new static($value->toArray(), $this->allowModifications);
 361                 } else {
 362                     $this->data[$key] = $value;
 363                 }
 364
 365                 $this->count++;
 366             }
 367         }
 368
 369         return $this;
 370     }
 371
 372     /**
 373      * Prevent any more modifications being made to this instance.
 374      *
 375      * Useful after merge() has been used to merge multiple Config objects
 376      * into one object which should then not be modified again.
 377      *
 378      * @return void
 379      */
 380     public function setReadOnly()
 381     {
 382         $this->allowModifications = false;
 383
 384         /** @var Config $value */
 385         foreach ($this->data as $value) {
 386             if ($value instanceof self) {
 387                 $value->setReadOnly();
 388             }
 389         }
 390     }
 391
 392     /**
 393      * Returns whether this Config object is read only or not.
 394      *
 395      * @return bool
 396      */
 397     public function isReadOnly()
 398     {
 399         return !$this->allowModifications;
 400     }
 401 }