[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * @version        $Id: registry.php 14401 2010-01-26 14:10:00Z louis $
   4   * @package        Joomla.Framework
   5   * @subpackage    Registry
   6   * @copyright    Copyright (C) 2005 - 2010 Open Source Matters. All rights reserved.
   7   * @license        GNU/GPL, see LICENSE.php
   8   * Joomla! is free software. This version may have been modified pursuant
   9   * to the GNU General Public License, and as distributed it includes or
  10   * is derivative of works licensed under the GNU General Public License or
  11   * other free or open source software licenses.
  12   * See COPYRIGHT.php for copyright notices and details.
  13   */
  14  
  15  // Check to ensure this file is within the rest of the framework
  16  defined('JPATH_BASE') or die();
  17  
  18  //Register the session storage class with the loader
  19  JLoader::register('JRegistryFormat', dirname(__FILE__).DS.'format.php');
  20  
  21  /**
  22   * JRegistry class
  23   *
  24   * @package     Joomla.Framework
  25   * @subpackage    Registry
  26   * @since         1.5
  27   */
  28  class JRegistry extends JObject
  29  {
  30      /**
  31       * Default NameSpace
  32       * @var string
  33       */
  34      var $_defaultNameSpace = null;
  35  
  36      /**
  37       * Registry Object
  38       *  - actually an array of namespace objects
  39       * @var array
  40       */
  41      var $_registry = array ();
  42  
  43      /**
  44       * Constructor
  45       *
  46       * @access    protected
  47       * @param    string    $namespace    Default registry namespace
  48       * @return    void
  49       * @since    1.5
  50       */
  51  	function __construct($namespace = 'default')
  52      {
  53          $this->_defaultNameSpace = $namespace;
  54          $this->makeNameSpace($namespace);
  55      }
  56  
  57      /**
  58       * Returns a reference to a global JRegistry object, only creating it
  59       * if it doesn't already exist.
  60       *
  61       * This method must be invoked as:
  62       *         <pre>$registry =& JRegistry::getInstance($id[, $namespace]);</pre>
  63       *
  64       * @static
  65       * @param    string    $id            An ID for the registry instance
  66       * @param    string    $namespace    The default namespace for the registry object [optional]
  67       * @return    object    The JRegistry object.
  68       * @since    1.5
  69       */
  70      function &getInstance($id, $namespace = 'default')
  71      {
  72          static $instances;
  73  
  74          if (!isset ($instances)) {
  75              $instances = array ();
  76          }
  77  
  78          if (empty ($instances[$id])) {
  79              $instances[$id] = new JRegistry($namespace);
  80          }
  81  
  82          return $instances[$id];
  83      }
  84  
  85      /**
  86       * Create a namespace
  87       *
  88       * @access    public
  89       * @param    string    $namespace    Name of the namespace to create
  90       * @return    boolean    True on success
  91       * @since    1.5
  92       */
  93  	function makeNameSpace($namespace)
  94      {
  95          $this->_registry[$namespace] = array('data' => new stdClass());
  96          return true;
  97      }
  98  
  99      /**
 100       * Get the list of namespaces
 101       *
 102       * @access    public
 103       * @return    array    List of namespaces
 104       * @since    1.5
 105       */
 106  	function getNameSpaces()
 107      {
 108          return array_keys($this->_registry);
 109      }
 110  
 111      /**
 112       * Get a registry value
 113       *
 114       * @access    public
 115       * @param    string    $regpath    Registry path (e.g. joomla.content.showauthor)
 116       * @param    mixed    $default    Optional default value
 117       * @return    mixed    Value of entry or null
 118       * @since    1.5
 119       */
 120  	function getValue($regpath, $default=null)
 121      {
 122          $result = $default;
 123  
 124          // Explode the registry path into an array
 125          if ($nodes = explode('.', $regpath))
 126          {
 127              // Get the namespace
 128              //$namespace = array_shift($nodes);
 129              $count = count($nodes);
 130              if ($count < 2) {
 131                  $namespace    = $this->_defaultNameSpace;
 132                  $nodes[1]    = $nodes[0];
 133              } else {
 134                  $namespace = $nodes[0];
 135              }
 136  
 137              if (isset($this->_registry[$namespace])) {
 138                  $ns = & $this->_registry[$namespace]['data'];
 139                  $pathNodes = $count - 1;
 140  
 141                  //for ($i = 0; $i < $pathNodes; $i ++) {
 142                  for ($i = 1; $i < $pathNodes; $i ++) {
 143                      if((isset($ns->$nodes[$i]))) $ns =& $ns->$nodes[$i];
 144                  }
 145  
 146                  if(isset($ns->$nodes[$i])) {
 147                      $result = $ns->$nodes[$i];
 148                  }
 149              }
 150          }
 151          return $result;
 152      }
 153  
 154      /**
 155       * Set a registry value
 156       *
 157       * @access    public
 158       * @param    string    $regpath     Registry Path (e.g. joomla.content.showauthor)
 159       * @param     mixed    $value        Value of entry
 160       * @return     mixed    Value of old value or boolean false if operation failed
 161       * @since    1.5
 162       */
 163  	function setValue($regpath, $value)
 164      {
 165          // Explode the registry path into an array
 166          $nodes = explode('.', $regpath);
 167  
 168          // Get the namespace
 169          $count = count($nodes);
 170  
 171          if ($count < 2) {
 172              $namespace = $this->_defaultNameSpace;
 173          } else {
 174              $namespace = array_shift($nodes);
 175              $count--;
 176          }
 177  
 178          if (!isset($this->_registry[$namespace])) {
 179              $this->makeNameSpace($namespace);
 180          }
 181  
 182          $ns = & $this->_registry[$namespace]['data'];
 183  
 184          $pathNodes = $count - 1;
 185  
 186          if ($pathNodes < 0) {
 187              $pathNodes = 0;
 188          }
 189  
 190          for ($i = 0; $i < $pathNodes; $i ++)
 191          {
 192              // If any node along the registry path does not exist, create it
 193              if (!isset($ns->$nodes[$i])) {
 194                  $ns->$nodes[$i] = new stdClass();
 195              }
 196              $ns =& $ns->$nodes[$i];
 197          }
 198  
 199          // Get the old value if exists so we can return it
 200          $ns->$nodes[$i] =& $value;
 201  
 202          return $ns->$nodes[$i];
 203      }
 204  
 205      /**
 206       * Load a associative array of values into the default namespace
 207       *
 208       * @access    public
 209       * @param    array    $array        Associative array of value to load
 210       * @param    string    $namepsace     The name of the namespace
 211       * @return    boolean    True on success
 212       * @since    1.5
 213       */
 214  	function loadArray($array, $namespace = null)
 215      {
 216          // If namespace is not set, get the default namespace
 217          if ($namespace == null) {
 218              $namespace = $this->_defaultNameSpace;
 219          }
 220  
 221          if (!isset($this->_registry[$namespace])) {
 222              // If namespace does not exist, make it and load the data
 223              $this->makeNameSpace($namespace);
 224          }
 225  
 226          // Load the variables into the registry's default namespace.
 227          foreach ($array as $k => $v)
 228          {
 229              $this->_registry[$namespace]['data']->$k = $v;
 230          }
 231  
 232          return true;
 233      }
 234  
 235      /**
 236       * Load the public variables of the object into the default namespace.
 237       *
 238       * @access    public
 239       * @param    object    $object        The object holding the public vars to load
 240       * @param    string    $namespace     Namespace to load the INI string into [optional]
 241       * @return    boolean    True on success
 242       * @since    1.5
 243       */
 244  	function loadObject(&$object, $namespace = null)
 245      {
 246          // If namespace is not set, get the default namespace
 247          if ($namespace == null) {
 248              $namespace = $this->_defaultNameSpace;
 249          }
 250  
 251          if (!isset($this->_registry[$namespace])) {
 252              // If namespace does not exist, make it and load the data
 253              $this->makeNameSpace($namespace);
 254          }
 255  
 256          /*
 257           * We want to leave groups that are already in the namespace and add the
 258           * groups loaded into the namespace.  This overwrites any existing group
 259           * with the same name
 260           */
 261          if (is_object( $object ))
 262          {
 263              foreach (get_object_vars($object) as $k => $v) {
 264                  if (substr($k, 0,1) != '_' || $k == '_name') {
 265                      $this->_registry[$namespace]['data']->$k = $v;
 266                  }
 267              }
 268          }
 269  
 270          return true;
 271      }
 272  
 273      /**
 274       * Load the contents of a file into the registry
 275       *
 276       * @access    public
 277       * @param    string    $file        Path to file to load
 278       * @param    string    $format        Format of the file [optional: defaults to INI]
 279       * @param    string    $namespace    Namespace to load the INI string into [optional]
 280       * @return    boolean    True on success
 281       * @since    1.5
 282       */
 283  	function loadFile($file, $format = 'INI', $namespace = null)
 284      {
 285          // Load a file into the given namespace [or default namespace if not given]
 286          $handler =& JRegistryFormat::getInstance($format);
 287  
 288          // If namespace is not set, get the default namespace
 289          if ($namespace == null) {
 290              $namespace = $this->_defaultNameSpace;
 291          }
 292  
 293          // Get the contents of the file
 294          jimport('joomla.filesystem.file');
 295          $data = JFile::read($file);
 296  
 297          if (!isset($this->_registry[$namespace]))
 298          {
 299              // If namespace does not exist, make it and load the data
 300              $this->makeNameSpace($namespace);
 301              $this->_registry[$namespace]['data'] = $handler->stringToObject($data);
 302          }
 303          else
 304          {
 305              // Get the data in object format
 306              $ns = $handler->stringToObject($data);
 307  
 308              /*
 309               * We want to leave groups that are already in the namespace and add the
 310               * groups loaded into the namespace.  This overwrites any existing group
 311               * with the same name
 312               */
 313              foreach (get_object_vars($ns) as $k => $v) {
 314                  $this->_registry[$namespace]['data']->$k = $v;
 315              }
 316          }
 317  
 318          return true;
 319      }
 320  
 321      /**
 322       * Load an XML string into the registry into the given namespace [or default if a namespace is not given]
 323       *
 324       * @access    public
 325       * @param    string    $data        XML formatted string to load into the registry
 326       * @param    string    $namespace    Namespace to load the XML string into [optional]
 327       * @return    boolean    True on success
 328       * @since    1.5
 329       */
 330  	function loadXML($data, $namespace = null)
 331      {
 332          // Load a string into the given namespace [or default namespace if not given]
 333          $handler =& JRegistryFormat::getInstance('XML');
 334  
 335          // If namespace is not set, get the default namespace
 336          if ($namespace == null) {
 337              $namespace = $this->_defaultNameSpace;
 338          }
 339  
 340          if (!isset($this->_registry[$namespace])) {
 341              // If namespace does not exist, make it and load the data
 342              $this->makeNameSpace($namespace);
 343              $this->_registry[$namespace]['data'] =& $handler->stringToObject($data);
 344          } else {
 345              // Get the data in object format
 346              $ns =& $handler->stringToObject($data);
 347  
 348              /*
 349               * We want to leave groups that are already in the namespace and add the
 350               * groups loaded into the namespace.  This overwrites any existing group
 351               * with the same name
 352               */
 353              foreach (get_object_vars($ns) as $k => $v) {
 354                  $this->_registry[$namespace]['data']->$k = $v;
 355              }
 356          }
 357  
 358          return true;
 359      }
 360  
 361      /**
 362       * Load an INI string into the registry into the given namespace [or default if a namespace is not given]
 363       *
 364       * @access    public
 365       * @param    string    $data        INI formatted string to load into the registry
 366       * @param    string    $namespace    Namespace to load the INI string into [optional]
 367       * @return    boolean True on success
 368       * @since    1.5
 369       */
 370  	function loadINI($data, $namespace = null)
 371      {
 372          // Load a string into the given namespace [or default namespace if not given]
 373          $handler =& JRegistryFormat::getInstance('INI');
 374  
 375          // If namespace is not set, get the default namespace
 376          if ($namespace == null) {
 377              $namespace = $this->_defaultNameSpace;
 378          }
 379  
 380          if (!isset($this->_registry[$namespace])) {
 381              // If namespace does not exist, make it and load the data
 382              $this->makeNameSpace($namespace);
 383              $this->_registry[$namespace]['data'] =& $handler->stringToObject($data);
 384          } else {
 385              // Get the data in object format
 386              $ns = $handler->stringToObject($data);
 387  
 388              /*
 389               * We want to leave groups that are already in the namespace and add the
 390               * groups loaded into the namespace.  This overwrites any existing group
 391               * with the same name
 392               */
 393              foreach (get_object_vars($ns) as $k => $v) {
 394                  $this->_registry[$namespace]['data']->$k = $v;
 395              }
 396          }
 397  
 398          return true;
 399      }
 400  
 401      /**
 402       * Merge a JRegistry object into this one
 403       *
 404       * @access    public
 405       * @param    object    $source    Source JRegistry object ot merge
 406       * @return    boolean    True on success
 407       * @since    1.5
 408       */
 409  	function merge(&$source)
 410      {
 411          if (is_a($source, 'JRegistry'))
 412          {
 413              $sns = $source->getNameSpaces();
 414              foreach ($sns as $ns)
 415              {
 416                  if (!isset($this->_registry[$ns]))
 417                  {
 418                      // If namespace does not exist, make it and load the data
 419                      $this->makeNameSpace($ns);
 420                  }
 421  
 422                  // Load the variables into the registry's default namespace.
 423                  foreach ($source->toArray($ns) as $k => $v)
 424                  {
 425                      if ($v != null) {
 426                          $this->_registry[$ns]['data']->$k = $v;
 427                      }
 428                  }
 429              }
 430              return true;
 431          }
 432          return false;
 433      }
 434  
 435      /**
 436       * Get a namespace in a given string format
 437       *
 438       * @access    public
 439       * @param    string    $format        Format to return the string in
 440       * @param    string    $namespace    Namespace to return [optional: null returns the default namespace]
 441       * @param    mixed    $params        Parameters used by the formatter, see formatters for more info
 442       * @return    string    Namespace in string format
 443       * @since    1.5
 444       */
 445  	function toString($format = 'INI', $namespace = null, $params = null)
 446      {
 447          // Return a namespace in a given format
 448          $handler =& JRegistryFormat::getInstance($format);
 449  
 450          // If namespace is not set, get the default namespace
 451          if ($namespace == null) {
 452              $namespace = $this->_defaultNameSpace;
 453          }
 454  
 455          // Get the namespace
 456          $ns = & $this->_registry[$namespace]['data'];
 457  
 458          return $handler->objectToString($ns, $params);
 459      }
 460  
 461      /**
 462       * Transforms a namespace to an array
 463       *
 464       * @access    public
 465       * @param    string    $namespace    Namespace to return [optional: null returns the default namespace]
 466       * @return    array    An associative array holding the namespace data
 467       * @since    1.5
 468       */
 469  	function toArray($namespace = null)
 470      {
 471          // If namespace is not set, get the default namespace
 472          if ($namespace == null) {
 473              $namespace = $this->_defaultNameSpace;
 474          }
 475  
 476          // Get the namespace
 477          $ns = & $this->_registry[$namespace]['data'];
 478  
 479          $array = array();
 480          foreach (get_object_vars( $ns ) as $k => $v) {
 481              $array[$k] = $v;
 482          }
 483  
 484          return $array;
 485      }
 486  
 487      /**
 488       * Transforms a namespace to an object
 489       *
 490       * @access    public
 491       * @param    string    $namespace    Namespace to return [optional: null returns the default namespace]
 492       * @return    object    An an object holding the namespace data
 493       * @since    1.5
 494       */
 495  	function toObject($namespace = null)
 496      {
 497          // If namespace is not set, get the default namespace
 498          if ($namespace == null) {
 499              $namespace = $this->_defaultNameSpace;
 500          }
 501  
 502          // Get the namespace
 503          $ns = & $this->_registry[$namespace]['data'];
 504  
 505          return $ns;
 506      }
 507  
 508  	function __clone()
 509      {
 510          $this->_registry = unserialize(serialize($this->_registry));
 511      }
 512  }