source: Dev/branches/cakephp/cake/libs/class_registry.php @ 126

Last change on this file since 126 was 126, checked in by fpvanagthoven, 14 years ago

Cakephp branch.

File size: 9.4 KB
Line 
1<?php
2/**
3 * Class collections.
4 *
5 * A repository for class objects, each registered with a key.
6 *
7 * PHP versions 4 and 5
8 *
9 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
10 * Copyright 2005-2011, Cake Software Foundation, Inc. (http://cakefoundation.org)
11 *
12 * Licensed under The MIT License
13 * Redistributions of files must retain the above copyright notice.
14 *
15 * @copyright     Copyright 2005-2011, Cake Software Foundation, Inc. (http://cakefoundation.org)
16 * @link          http://cakephp.org CakePHP(tm) Project
17 * @package       cake
18 * @subpackage    cake.cake.libs
19 * @since         CakePHP(tm) v 0.9.2
20 * @license       MIT License (http://www.opensource.org/licenses/mit-license.php)
21 */
22
23/**
24 * Class Collections.
25 *
26 * A repository for class objects, each registered with a key.
27 * If you try to add an object with the same key twice, nothing will come of it.
28 * If you need a second instance of an object, give it another key.
29 *
30 * @package       cake
31 * @subpackage    cake.cake.libs
32 */
33class ClassRegistry {
34
35/**
36 * Names of classes with their objects.
37 *
38 * @var array
39 * @access private
40 */
41        var $__objects = array();
42
43/**
44 * Names of class names mapped to the object in the registry.
45 *
46 * @var array
47 * @access private
48 */
49        var $__map = array();
50
51/**
52 * Default constructor parameter settings, indexed by type
53 *
54 * @var array
55 * @access private
56 */
57        var $__config = array();
58
59/**
60 * Return a singleton instance of the ClassRegistry.
61 *
62 * @return ClassRegistry instance
63 * @access public
64 */
65        function &getInstance() {
66                static $instance = array();
67                if (!$instance) {
68                        $instance[0] =& new ClassRegistry();
69                }
70                return $instance[0];
71        }
72
73/**
74 * Loads a class, registers the object in the registry and returns instance of the object. ClassRegistry::init()
75 * is used as a factory for models, and handle correct injecting of settings, that assist in testing.
76 *
77 * Examples
78 * Simple Use: Get a Post model instance ```ClassRegistry::init('Post');```
79 *
80 * Exapanded: ```array('class' => 'ClassName', 'alias' => 'AliasNameStoredInTheRegistry', 'type' => 'Model');```
81 *
82 * Model Classes can accept optional ```array('id' => $id, 'table' => $table, 'ds' => $ds, 'alias' => $alias);```
83 *
84 * When $class is a numeric keyed array, multiple class instances will be stored in the registry,
85 *  no instance of the object will be returned
86 * {{{
87 * array(
88 *              array('class' => 'ClassName', 'alias' => 'AliasNameStoredInTheRegistry', 'type' => 'Model'),
89 *              array('class' => 'ClassName', 'alias' => 'AliasNameStoredInTheRegistry', 'type' => 'Model'),
90 *              array('class' => 'ClassName', 'alias' => 'AliasNameStoredInTheRegistry', 'type' => 'Model')
91 * );
92 * }}}
93 * @param mixed $class as a string or a single key => value array instance will be created,
94 *  stored in the registry and returned.
95 * @param string $type Only model is accepted as a valid value for $type.
96 * @return object instance of ClassName
97 * @access public
98 * @static
99 */
100        function &init($class, $type = null) {
101                $_this =& ClassRegistry::getInstance();
102                $id = $false = false;
103                $true = true;
104
105                if (!$type) {
106                        $type = 'Model';
107                }
108
109                if (is_array($class)) {
110                        $objects = $class;
111                        if (!isset($class[0])) {
112                                $objects = array($class);
113                        }
114                } else {
115                        $objects = array(array('class' => $class));
116                }
117                $defaults = isset($_this->__config[$type]) ? $_this->__config[$type] : array();
118                $count = count($objects);
119
120                foreach ($objects as $key => $settings) {
121                        if (is_array($settings)) {
122                                $pluginPath = null;
123                                $settings = array_merge($defaults, $settings);
124                                $class = $settings['class'];
125                               
126                                list($plugin, $class) = pluginSplit($class);
127                                if ($plugin) {
128                                        $pluginPath = $plugin . '.';
129                                }
130
131                                if (empty($settings['alias'])) {
132                                        $settings['alias'] = $class;
133                                }
134                                $alias = $settings['alias'];
135
136                                if ($model =& $_this->__duplicate($alias, $class)) {
137                                        $_this->map($alias, $class);
138                                        return $model;
139                                }
140
141                                if (class_exists($class) || App::import($type, $pluginPath . $class)) {
142                                        ${$class} =& new $class($settings);
143                                } elseif ($type === 'Model') {
144                                        if ($plugin && class_exists($plugin . 'AppModel')) {
145                                                $appModel = $plugin . 'AppModel';
146                                        } else {
147                                                $appModel = 'AppModel';
148                                        }
149                                        $settings['name'] = $class;
150                                        ${$class} =& new $appModel($settings);
151                                }
152
153                                if (!isset(${$class})) {
154                                        trigger_error(sprintf(__('(ClassRegistry::init() could not create instance of %1$s class %2$s ', true), $class, $type), E_USER_WARNING);
155                                        return $false;
156                                }
157
158                                if ($type !== 'Model') {
159                                        $_this->addObject($alias, ${$class});
160                                } else {
161                                        $_this->map($alias, $class);
162                                }
163                        } elseif (is_numeric($settings)) {
164                                trigger_error(__('(ClassRegistry::init() Attempted to create instance of a class with a numeric name', true), E_USER_WARNING);
165                                return $false;
166                        }
167                }
168
169                if ($count > 1) {
170                        return $true;
171                }
172                return ${$class};
173        }
174
175/**
176 * Add $object to the registry, associating it with the name $key.
177 *
178 * @param string $key   Key for the object in registry
179 * @param mixed $object Object to store
180 * @return boolean True if the object was written, false if $key already exists
181 * @access public
182 * @static
183 */
184        function addObject($key, &$object) {
185                $_this =& ClassRegistry::getInstance();
186                $key = Inflector::underscore($key);
187                if (!isset($_this->__objects[$key])) {
188                        $_this->__objects[$key] =& $object;
189                        return true;
190                }
191                return false;
192        }
193
194/**
195 * Remove object which corresponds to given key.
196 *
197 * @param string $key   Key of object to remove from registry
198 * @return void
199 * @access public
200 * @static
201 */
202        function removeObject($key) {
203                $_this =& ClassRegistry::getInstance();
204                $key = Inflector::underscore($key);
205                if (isset($_this->__objects[$key])) {
206                        unset($_this->__objects[$key]);
207                }
208        }
209
210/**
211 * Returns true if given key is present in the ClassRegistry.
212 *
213 * @param string $key Key to look for
214 * @return boolean true if key exists in registry, false otherwise
215 * @access public
216 * @static
217 */
218        function isKeySet($key) {
219                $_this =& ClassRegistry::getInstance();
220                $key = Inflector::underscore($key);
221                if (isset($_this->__objects[$key])) {
222                        return true;
223                } elseif (isset($_this->__map[$key])) {
224                        return true;
225                }
226                return false;
227        }
228
229/**
230 * Get all keys from the registry.
231 *
232 * @return array Set of keys stored in registry
233 * @access public
234 * @static
235 */
236        function keys() {
237                $_this =& ClassRegistry::getInstance();
238                return array_keys($_this->__objects);
239        }
240
241/**
242 * Return object which corresponds to given key.
243 *
244 * @param string $key Key of object to look for
245 * @return mixed Object stored in registry or boolean false if the object does not exist.
246 * @access public
247 * @static
248 */
249        function &getObject($key) {
250                $_this =& ClassRegistry::getInstance();
251                $key = Inflector::underscore($key);
252                $return = false;
253                if (isset($_this->__objects[$key])) {
254                        $return =& $_this->__objects[$key];
255                } else {
256                        $key = $_this->__getMap($key);
257                        if (isset($_this->__objects[$key])) {
258                                $return =& $_this->__objects[$key];
259                        }
260                }
261                return $return;
262        }
263
264/**
265 * Sets the default constructor parameter for an object type
266 *
267 * @param string $type Type of object.  If this parameter is omitted, defaults to "Model"
268 * @param array $param The parameter that will be passed to object constructors when objects
269 *                      of $type are created
270 * @return mixed Void if $param is being set.  Otherwise, if only $type is passed, returns
271 *               the previously-set value of $param, or null if not set.
272 * @access public
273 * @static
274 */
275        function config($type, $param = array()) {
276                $_this =& ClassRegistry::getInstance();
277
278                if (empty($param) && is_array($type)) {
279                        $param = $type;
280                        $type = 'Model';
281                } elseif (is_null($param)) {
282                        unset($_this->__config[$type]);
283                } elseif (empty($param) && is_string($type)) {
284                        return isset($_this->__config[$type]) ? $_this->__config[$type] : null;
285                }
286                $_this->__config[$type] = $param;
287        }
288
289/**
290 * Checks to see if $alias is a duplicate $class Object
291 *
292 * @param string $alias
293 * @param string $class
294 * @return boolean
295 * @access private
296 * @static
297 */
298        function &__duplicate($alias,  $class) {
299                $duplicate = false;
300                if ($this->isKeySet($alias)) {
301                        $model =& $this->getObject($alias);
302                        if (is_object($model) && (is_a($model, $class) || $model->alias === $class)) {
303                                $duplicate =& $model;
304                        }
305                        unset($model);
306                }
307                return $duplicate;
308        }
309
310/**
311 * Add a key name pair to the registry to map name to class in the registry.
312 *
313 * @param string $key Key to include in map
314 * @param string $name Key that is being mapped
315 * @access public
316 * @static
317 */
318        function map($key, $name) {
319                $_this =& ClassRegistry::getInstance();
320                $key = Inflector::underscore($key);
321                $name = Inflector::underscore($name);
322                if (!isset($_this->__map[$key])) {
323                        $_this->__map[$key] = $name;
324                }
325        }
326
327/**
328 * Get all keys from the map in the registry.
329 *
330 * @return array Keys of registry's map
331 * @access public
332 * @static
333 */
334        function mapKeys() {
335                $_this =& ClassRegistry::getInstance();
336                return array_keys($_this->__map);
337        }
338
339/**
340 * Return the name of a class in the registry.
341 *
342 * @param string $key Key to find in map
343 * @return string Mapped value
344 * @access private
345 * @static
346 */
347        function __getMap($key) {
348                if (isset($this->__map[$key])) {
349                        return $this->__map[$key];
350                }
351        }
352
353/**
354 * Flushes all objects from the ClassRegistry.
355 *
356 * @return void
357 * @access public
358 * @static
359 */
360        function flush() {
361                $_this =& ClassRegistry::getInstance();
362                $_this->__objects = array();
363                $_this->__map = array();
364        }
365}
Note: See TracBrowser for help on using the repository browser.