CakePHP
  • Documentation
    • Book
    • API
    • Videos
    • Reporting Security Issues
    • Privacy Policy
    • Logos & Trademarks
  • Business Solutions
  • Swag
  • Road Trip
  • Team
  • Community
    • Community
    • Get Involved
    • Issues (GitHub)
    • Bakery
    • Featured Resources
    • Training
    • Meetups
    • My CakePHP
    • CakeFest
    • Newsletter
    • Linkedin
    • YouTube
    • Facebook
    • Twitter
    • Mastodon
    • Help & Support
    • Forum
    • Stack Overflow
    • Slack
    • Paid Support
CakePHP

C CakePHP 2.4 API

  • Overview
  • Tree
  • Deprecated
  • Version:
    • 2.4
      • 4.2
      • 4.1
      • 4.0
      • 3.9
      • 3.8
      • 3.7
      • 3.6
      • 3.5
      • 3.4
      • 3.3
      • 3.2
      • 3.1
      • 3.0
      • 2.10
      • 2.9
      • 2.8
      • 2.7
      • 2.6
      • 2.5
      • 2.4
      • 2.3
      • 2.2
      • 2.1
      • 2.0
      • 1.3
      • 1.2

Packages

  • Cake
    • Cache
      • Engine
    • Configure
    • Console
      • Command
        • Task
    • Controller
      • Component
        • Acl
        • Auth
    • Core
    • Error
    • Event
    • I18n
    • Log
      • Engine
    • Model
      • Behavior
      • Datasource
        • Database
        • Session
      • Validator
    • Network
      • Email
      • Http
    • Routing
      • Filter
      • Route
    • TestSuite
      • Coverage
      • Fixture
      • Reporter
    • Utility
    • View
      • Helper

Classes

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

Generated using CakePHP API Docs