Subversion Repositories SmartDukaan

<?php
/**
 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link          http://cakephp.org CakePHP(tm) Project
 * @package       Cake.Utility
 * @since         CakePHP(tm) v 0.9.2
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

/**
 * Included libraries.
 */
App::uses('Model', 'Model');
App::uses('AppModel', 'Model');
App::uses('ConnectionManager', 'Model');

/**
 * Class Collections.
 *
 * A repository for class objects, each registered with a key.
 * If you try to add an object with the same key twice, nothing will come of it.
 * If you need a second instance of an object, give it another key.
 *
 * @package       Cake.Utility
 */
class ClassRegistry {

/**
 * Names of classes with their objects.
 *
 * @var array
 */
        protected $_objects = array();

/**
 * Names of class names mapped to the object in the registry.
 *
 * @var array
 */
        protected $_map = array();

/**
 * Default constructor parameter settings, indexed by type
 *
 * @var array
 */
        protected $_config = array();

/**
 * Return a singleton instance of the ClassRegistry.
 *
 * @return ClassRegistry instance
 */
        public static function getInstance() {
                static $instance = array();
                if (!$instance) {
                        $instance[0] = new ClassRegistry();
                }
                return $instance[0];
        }

/**
 * Loads a class, registers the object in the registry and returns instance of the object. ClassRegistry::init()
 * is used as a factory for models, and handle correct injecting of settings, that assist in testing.
 *
 * Examples
 * Simple Use: Get a Post model instance ```ClassRegistry::init('Post');```
 *
 * Expanded: ```array('class' => 'ClassName', 'alias' => 'AliasNameStoredInTheRegistry');```
 *
 * Model Classes can accept optional ```array('id' => $id, 'table' => $table, 'ds' => $ds, 'alias' => $alias);```
 *
 * When $class is a numeric keyed array, multiple class instances will be stored in the registry,
 *  no instance of the object will be returned
 * {{{
 * array(
 *              array('class' => 'ClassName', 'alias' => 'AliasNameStoredInTheRegistry'),
 *              array('class' => 'ClassName', 'alias' => 'AliasNameStoredInTheRegistry'),
 *              array('class' => 'ClassName', 'alias' => 'AliasNameStoredInTheRegistry')
 * );
 * }}}
 *
 * @param string|array $class as a string or a single key => value array instance will be created,
 *  stored in the registry and returned.
 * @param bool $strict if set to true it will return false if the class was not found instead
 *      of trying to create an AppModel
 * @return object instance of ClassName.
 * @throws CakeException when you try to construct an interface or abstract class.
 */
        public static function init($class, $strict = false) {
                $_this = ClassRegistry::getInstance();

                if (is_array($class)) {
                        $objects = $class;
                        if (!isset($class[0])) {
                                $objects = array($class);
                        }
                } else {
                        $objects = array(array('class' => $class));
                }
                $defaults = array();
                if (isset($_this->_config['Model'])) {
                        $defaults = $_this->_config['Model'];
                }
                $count = count($objects);
                $availableDs = null;

                foreach ($objects as $settings) {
                        if (is_numeric($settings)) {
                                trigger_error(__d('cake_dev', '(ClassRegistry::init() Attempted to create instance of a class with a numeric name'), E_USER_WARNING);
                                return false;
                        }

                        if (is_array($settings)) {
                                $pluginPath = null;
                                $settings += $defaults;
                                $class = $settings['class'];

                                list($plugin, $class) = pluginSplit($class);
                                if ($plugin) {
                                        $pluginPath = $plugin . '.';
                                        $settings['plugin'] = $plugin;
                                }

                                if (empty($settings['alias'])) {
                                        $settings['alias'] = $class;
                                }
                                $alias = $settings['alias'];

                                $model = $_this->_duplicate($alias, $class);
                                if ($model) {
                                        $_this->map($alias, $class);
                                        return $model;
                                }

                                App::uses($plugin . 'AppModel', $pluginPath . 'Model');
                                App::uses($class, $pluginPath . 'Model');

                                if (class_exists($class) || interface_exists($class)) {
                                        $reflection = new ReflectionClass($class);
                                        if ($reflection->isAbstract() || $reflection->isInterface()) {
                                                throw new CakeException(__d('cake_dev', 'Cannot create instance of %s, as it is abstract or is an interface', $class));
                                        }
                                        $testing = isset($settings['testing']) ? $settings['testing'] : false;
                                        if ($testing) {
                                                $settings['ds'] = 'test';
                                                $defaultProperties = $reflection->getDefaultProperties();
                                                if (isset($defaultProperties['useDbConfig'])) {
                                                        $useDbConfig = $defaultProperties['useDbConfig'];
                                                        if ($availableDs === null) {
                                                                $availableDs = array_keys(ConnectionManager::enumConnectionObjects());
                                                        }
                                                        if (in_array('test_' . $useDbConfig, $availableDs)) {
                                                                $useDbConfig = 'test_' . $useDbConfig;
                                                        }
                                                        if (strpos($useDbConfig, 'test') === 0) {
                                                                $settings['ds'] = $useDbConfig;
                                                        }
                                                }
                                        }
                                        if ($reflection->getConstructor()) {
                                                $instance = $reflection->newInstance($settings);
                                        } else {
                                                $instance = $reflection->newInstance();
                                        }
                                        if ($strict && !$instance instanceof Model) {
                                                $instance = null;
                                        }
                                }
                                if (!isset($instance)) {
                                        $appModel = 'AppModel';
                                        if ($strict) {
                                                return false;
                                        } elseif ($plugin && class_exists($plugin . 'AppModel')) {
                                                $appModel = $plugin . 'AppModel';
                                        }
                                        if (!empty($appModel)) {
                                                $settings['name'] = $class;
                                                $instance = new $appModel($settings);
                                        }

                                        if (!isset($instance)) {
                                                trigger_error(__d('cake_dev', '(ClassRegistry::init() could not create instance of %s', $class), E_USER_WARNING);
                                                return false;
                                        }
                                }
                                $_this->map($alias, $class);
                        }
                }

                if ($count > 1) {
                        return true;
                }
                return $instance;
        }

/**
 * Add $object to the registry, associating it with the name $key.
 *
 * @param string $key Key for the object in registry
 * @param object $object Object to store
 * @return bool True if the object was written, false if $key already exists
 */
        public static function addObject($key, $object) {
                $_this = ClassRegistry::getInstance();
                $key = Inflector::underscore($key);
                if (!isset($_this->_objects[$key])) {
                        $_this->_objects[$key] = $object;
                        return true;
                }
                return false;
        }

/**
 * Remove object which corresponds to given key.
 *
 * @param string $key Key of object to remove from registry
 * @return void
 */
        public static function removeObject($key) {
                $_this = ClassRegistry::getInstance();
                $key = Inflector::underscore($key);
                if (isset($_this->_objects[$key])) {
                        unset($_this->_objects[$key]);
                }
        }

/**
 * Returns true if given key is present in the ClassRegistry.
 *
 * @param string $key Key to look for
 * @return bool true if key exists in registry, false otherwise
 */
        public static function isKeySet($key) {
                $_this = ClassRegistry::getInstance();
                $key = Inflector::underscore($key);

                return isset($_this->_objects[$key]) || isset($_this->_map[$key]);
        }

/**
 * Get all keys from the registry.
 *
 * @return array Set of keys stored in registry
 */
        public static function keys() {
                return array_keys(ClassRegistry::getInstance()->_objects);
        }

/**
 * Return object which corresponds to given key.
 *
 * @param string $key Key of object to look for
 * @return mixed Object stored in registry or boolean false if the object does not exist.
 */
        public static function getObject($key) {
                $_this = ClassRegistry::getInstance();
                $key = Inflector::underscore($key);
                $return = false;
                if (isset($_this->_objects[$key])) {
                        $return = $_this->_objects[$key];
                } else {
                        $key = $_this->_getMap($key);
                        if (isset($_this->_objects[$key])) {
                                $return = $_this->_objects[$key];
                        }
                }
                return $return;
        }

/**
 * Sets the default constructor parameter for an object type
 *
 * @param string $type Type of object. If this parameter is omitted, defaults to "Model"
 * @param array $param The parameter that will be passed to object constructors when objects
 *                      of $type are created
 * @return mixed Void if $param is being set. Otherwise, if only $type is passed, returns
 *               the previously-set value of $param, or null if not set.
 */
        public static function config($type, $param = array()) {
                $_this = ClassRegistry::getInstance();

                if (empty($param) && is_array($type)) {
                        $param = $type;
                        $type = 'Model';
                } elseif ($param === null) {
                        unset($_this->_config[$type]);
                } elseif (empty($param) && is_string($type)) {
                        return isset($_this->_config[$type]) ? $_this->_config[$type] : null;
                }
                if (isset($_this->_config[$type]['testing'])) {
                        $param['testing'] = true;
                }
                $_this->_config[$type] = $param;
        }

/**
 * Checks to see if $alias is a duplicate $class Object
 *
 * @param string $alias Alias to check.
 * @param string $class Class name.
 * @return bool
 */
        protected function &_duplicate($alias, $class) {
                $duplicate = false;
                if ($this->isKeySet($alias)) {
                        $model = $this->getObject($alias);
                        if (is_object($model) && ($model instanceof $class || $model->alias === $class)) {
                                $duplicate = $model;
                        }
                        unset($model);
                }
                return $duplicate;
        }

/**
 * Add a key name pair to the registry to map name to class in the registry.
 *
 * @param string $key Key to include in map
 * @param string $name Key that is being mapped
 * @return void
 */
        public static function map($key, $name) {
                $_this = ClassRegistry::getInstance();
                $key = Inflector::underscore($key);
                $name = Inflector::underscore($name);
                if (!isset($_this->_map[$key])) {
                        $_this->_map[$key] = $name;
                }
        }

/**
 * Get all keys from the map in the registry.
 *
 * @return array Keys of registry's map
 */
        public static function mapKeys() {
                return array_keys(ClassRegistry::getInstance()->_map);
        }

/**
 * Return the name of a class in the registry.
 *
 * @param string $key Key to find in map
 * @return string Mapped value
 */
        protected function _getMap($key) {
                if (isset($this->_map[$key])) {
                        return $this->_map[$key];
                }
        }

/**
 * Flushes all objects from the ClassRegistry.
 *
 * @return void
 */
        public static function flush() {
                $_this = ClassRegistry::getInstance();
                $_this->_objects = array();
                $_this->_map = array();
        }

}