Merge branch 'master' of http://git.tine20.org/git/Syncope
[tine20] / tine20 / library / Syncope / lib / Syncope / Registry.php
1 <?php
2 /**
3  * Zend Framework
4  *
5  * LICENSE
6  *
7  * This source file is subject to the new BSD license that is bundled
8  * with this package in the file LICENSE.txt.
9  * It is also available through the world-wide-web at this URL:
10  * http://framework.zend.com/license/new-bsd
11  * If you did not receive a copy of the license and are unable to
12  * obtain it through the world-wide-web, please send an email
13  * to license@zend.com so we can send you a copy immediately.
14  *
15  * @category   Syncope
16  * @package    Syncope_Registry
17  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
18  * @license    http://framework.zend.com/license/new-bsd     New BSD License
19  * @version    $Id: Registry.php 10020 2009-08-18 14:34:09Z j.fischer@metaways.de $
20  */
21
22 /**
23  * Generic storage class helps to manage global data.
24  *
25  * @category   Syncope
26  * @package    Syncope_Registry
27  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
28  * @license    http://framework.zend.com/license/new-bsd     New BSD License
29  */
30 class Syncope_Registry extends ArrayObject
31 {
32     const CALENDAR_DATA_CLASS = 'calendar_data_class';
33     const CONTACTS_DATA_CLASS = 'contacts_data_class';
34     const EMAIL_DATA_CLASS    = 'email_data_class';
35     const TASKS_DATA_CLASS    = 'tasks_data_class';
36     
37     const DATABASE            = 'database';
38     const TRANSACTIONMANAGER  = 'transactionmanager';
39     
40     /**
41      * Class name of the singleton registry object.
42      * @var string
43      */
44     private static $_registryClassName = 'Syncope_Registry';
45
46     /**
47      * Registry object provides storage for shared objects.
48      * @var Syncope_Registry
49      */
50     private static $_registry = null;
51
52     /**
53      * Retrieves the default registry instance.
54      *
55      * @return Syncope_Registry
56      */
57     public static function getInstance()
58     {
59         if (self::$_registry === null) {
60             self::init();
61         }
62
63         return self::$_registry;
64     }
65
66     /**
67      * @return Zend_Db_Adapter_Abstract
68      */
69     public static function getDatabase()
70     {
71         return self::get(self::DATABASE);
72     }
73     
74     /**
75      * return transaction manager class 
76      * 
77      * @return Syncope_TransactionManagerInterface
78      */
79     public static function getTransactionManager()
80     {
81         return self::get(self::TRANSACTIONMANAGER);
82     } 
83     
84     /**
85      * Set the default registry instance to a specified instance.
86      *
87      * @param Syncope_Registry $registry An object instance of type Syncope_Registry,
88      *   or a subclass.
89      * @return void
90      * @throws Zend_Exception if registry is already initialized.
91      */
92     public static function setInstance(Syncope_Registry $registry)
93     {
94         if (self::$_registry !== null) {
95             require_once 'Zend/Exception.php';
96             throw new Zend_Exception('Registry is already initialized');
97         }
98
99         self::setClassName(get_class($registry));
100         self::$_registry = $registry;
101     }
102
103     /**
104      * Initialize the default registry instance.
105      *
106      * @return void
107      */
108     protected static function init()
109     {
110         self::setInstance(new self::$_registryClassName());
111     }
112
113     /**
114      * Set the class name to use for the default registry instance.
115      * Does not affect the currently initialized instance, it only applies
116      * for the next time you instantiate.
117      *
118      * @param string $registryClassName
119      * @return void
120      * @throws Zend_Exception if the registry is initialized or if the
121      *   class name is not valid.
122      */
123     public static function setClassName($registryClassName = 'Syncope_Registry')
124     {
125         if (self::$_registry !== null) {
126             require_once 'Zend/Exception.php';
127             throw new Zend_Exception('Registry is already initialized');
128         }
129
130         if (!is_string($registryClassName)) {
131             require_once 'Zend/Exception.php';
132             throw new Zend_Exception("Argument is not a class name");
133         }
134
135         /**
136          * @see Zend_Loader
137          */
138         if (!class_exists($registryClassName)) {
139             require_once 'Zend/Loader.php';
140             Zend_Loader::loadClass($registryClassName);
141         }
142
143         self::$_registryClassName = $registryClassName;
144     }
145
146     /**
147      * Unset the default registry instance.
148      * Primarily used in tearDown() in unit tests.
149      * @returns void
150      */
151     public static function _unsetInstance()
152     {
153         self::$_registry = null;
154     }
155
156     /**
157      * getter method, basically same as offsetGet().
158      *
159      * This method can be called from an object of type Syncope_Registry, or it
160      * can be called statically.  In the latter case, it uses the default
161      * static instance stored in the class.
162      *
163      * @param string $index - get the value associated with $index
164      * @return mixed
165      * @throws Zend_Exception if no entry is registerd for $index.
166      */
167     public static function get($index)
168     {
169         $instance = self::getInstance();
170
171         if (!$instance->offsetExists($index)) {
172             require_once 'Zend/Exception.php';
173             throw new Zend_Exception("No entry is registered for key '$index'");
174         }
175
176         return $instance->offsetGet($index);
177     }
178
179     /**
180      * setter method, basically same as offsetSet().
181      *
182      * This method can be called from an object of type Syncope_Registry, or it
183      * can be called statically.  In the latter case, it uses the default
184      * static instance stored in the class.
185      *
186      * @param string $index The location in the ArrayObject in which to store
187      *   the value.
188      * @param mixed $value The object to store in the ArrayObject.
189      * @return void
190      */
191     public static function set($index, $value)
192     {
193         $instance = self::getInstance();
194         $instance->offsetSet($index, $value);
195     }
196
197     public static function setDatabase(Zend_Db_Adapter_Abstract $db)
198     {
199         self::set(self::DATABASE, $db);
200     }
201     
202     public static function setCalendarDataClass($className)
203     {
204         if (!class_exists($className)) {
205             throw new InvalidArgumentException('invalid $_className provided');
206         }
207     
208         self::set(self::CALENDAR_DATA_CLASS, $className);
209     }
210     
211     public static function setContactsDataClass($className)
212     {
213         if (!class_exists($className)) {
214             throw new InvalidArgumentException('invalid $_className provided');
215         }
216     
217         self::set(self::CONTACTS_DATA_CLASS, $className);
218     }
219     
220     public static function setEmailDataClass($className)
221     {
222         if (!class_exists($className)) {
223             throw new InvalidArgumentException('invalid $_className provided');
224         }
225     
226         self::set(self::EMAIL_DATA_CLASS, $className);
227     }
228     
229     public static function setTasksDataClass($className)
230     {
231         if (!class_exists($className)) {
232             throw new InvalidArgumentException('invalid $_className provided');
233         }
234     
235         self::set(self::TASKS_DATA_CLASS, $className);
236     }
237     
238     public static function setTransactionManager($manager)
239     {
240         self::set(self::TRANSACTIONMANAGER, $manager);
241     }
242     
243     /**
244      * Returns TRUE if the $index is a named value in the registry,
245      * or FALSE if $index was not found in the registry.
246      *
247      * @param  string $index
248      * @return boolean
249      */
250     public static function isRegistered($index)
251     {
252         if (self::$_registry === null) {
253             return false;
254         }
255         return self::$_registry->offsetExists($index);
256     }
257
258     /**
259      * Constructs a parent ArrayObject with default
260      * ARRAY_AS_PROPS to allow acces as an object
261      *
262      * @param array $array data array
263      * @param integer $flags ArrayObject flags
264      */
265     public function __construct($array = array(), $flags = parent::ARRAY_AS_PROPS)
266     {
267         parent::__construct($array, $flags);
268     }
269
270     /**
271      * @param string $index
272      * @returns mixed
273      *
274      * Workaround for http://bugs.php.net/bug.php?id=40442 (ZF-960).
275      */
276     public function offsetExists($index)
277     {
278         return array_key_exists($index, $this);
279     }
280
281 }