Static method getInstance() conflicts with getInstance() in class BaseRegistry,
[core.git] / inc / loader / class_ClassLoader.php
1 <?php
2 /**
3  * This class loads class include files with a specific prefix and suffix
4  *
5  * @author              Roland Haeder <webmaster@ship-simu.org>
6  * @version             0.0.0
7  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2011 Core Developer Team
8  * @license             GNU GPL 3.0 or any newer version
9  * @link                http://www.ship-simu.org
10  *
11  * This program is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program. If not, see <http://www.gnu.org/licenses/>.
23  *
24  * ----------------------------------
25  * 1.3
26  *  - Constructor is now empty and factory method 'createClassLoader' is created
27  *  - renamed loadClasses to scanClassPath
28  *  - Added initLoader()
29  * 1.2
30  *  - ClassLoader rewritten to PHP SPL's own RecursiveIteratorIterator class
31  * 1.1
32  *  - loadClasses rewritten to fix some notices
33  * 1.0
34  *  - Initial release
35  * ----------------------------------
36  */
37 class ClassLoader {
38         /**
39          * Instance of this class
40          */
41         private static $selfInstance = NULL;
42
43         /**
44          * Array with all classes
45          */
46         private $classes = array();
47
48         /**
49          * List of loaded classes
50          */
51         private $loadedClasses = array();
52
53         /**
54          * Suffix with extension for all class files
55          */
56         private $prefix = 'class_';
57
58         /**
59          * Suffix with extension for all class files
60          */
61         private $suffix = '.php';
62
63         /**
64          * A list for directory names (no leading/trailing slashes!) which not be scanned by the path scanner
65          * @see scanLocalPath
66          */
67         private $ignoreList = array();
68
69         /**
70          * Debug this class loader? (true = yes, false = no)
71          */
72         private $debug = false;
73
74         /**
75          * Wether the file list is cached or not
76          */
77         private $listCached = false;
78
79         /**
80          * Wethe class content has been cached
81          */
82         private $classesCached = false;
83
84         /**
85          * Filename for the list cache
86          */
87         private $listCacheFQFN = '';
88
89         /**
90          * Cache for class content
91          */
92         private $classCacheFQFN = '';
93
94         /**
95          * Counter for loaded include files
96          */
97         private $total = 0;
98
99         /**
100          * The protected constructor. Please use the factory method below, or use
101          * getSelfInstance() for singleton
102          *
103          * @return      void
104          */
105         protected function __construct () {
106                 // Is currently empty
107         }
108
109         /**
110          * The destructor makes it sure all caches got flushed
111          *
112          * @return      void
113          */
114         public function __destruct () {
115                 // Skip here if dev-mode
116                 if (defined('DEVELOPER')) {
117                         return;
118                 } // END - if
119
120                 // Skip here if already cached
121                 if ($this->listCached === false) {
122                         // Writes the cache file of our list away
123                         $cacheContent = serialize($this->classes);
124                         file_put_contents($this->listCacheFQFN, $cacheContent);
125                 } // END - if
126
127                 // Skip here if already cached
128                 if ($this->classesCached === false) {
129                         // Generate a full-cache of all classes
130                         $cacheContent = '';
131                         foreach ($this->loadedClasses as $fqfn) {
132                                 // Load the file
133                                 $cacheContent .= file_get_contents($fqfn);
134                         } // END - foreach
135
136                         // And write it away
137                         file_put_contents($this->classCacheFQFN, $cacheContent);
138                 } // END - if
139         }
140
141         /**
142          * Our renamed factory method
143          *
144          * @param       $configInstance Configuration class instance
145          * @return      void
146          */
147         public static final function createClassLoader (FrameworkConfiguration $configInstance) {
148                 // Get a new instance
149                 $loaderInstance = new ClassLoader();
150
151                 // Init the instance
152                 $loaderInstance->initLoader($configInstance);
153
154                 // Return the prepared instance
155                 return $loaderInstance;
156         }
157
158         /**
159          * Initializes our loader class
160          *
161          * @param       $configInstance Configuration class instance
162          * @return      void
163          */
164         protected function initLoader (FrameworkConfiguration $configInstance) {
165                 // Set configuration instance
166                 $this->configInstance = $configInstance;
167
168                 // Construct the FQFN for the cache
169                 if (!defined('DEVELOPER')) {
170                         $this->listCacheFQFN  = $this->configInstance->getConfigEntry('local_db_path') . 'list-' . $this->configInstance->getConfigEntry('app_name') . '.cache';
171                         $this->classCacheFQFN = $this->configInstance->getConfigEntry('local_db_path') . 'class-' . $this->configInstance->getConfigEntry('app_name') . '.cache';
172                 } // END - if
173
174                 // Set suffix and prefix from configuration
175                 $this->suffix = $configInstance->getConfigEntry('class_suffix');
176                 $this->prefix = $configInstance->getConfigEntry('class_prefix');
177
178                 // Set own instance
179                 self::$selfInstance = $this;
180
181                 // Skip here if no dev-mode
182                 if (defined('DEVELOPER')) {
183                         return;
184                 } // END - if
185
186                 // IS the cache there?
187                 if (file_exists($this->listCacheFQFN)) {
188                         // Get content
189                         $cacheContent = file_get_contents($this->listCacheFQFN);
190
191                         // And convert it
192                         $this->classes = unserialize($cacheContent);
193
194                         // List has been restored from cache!
195                         $this->listCached = true;
196                 } // END - if
197
198                 // Does the class cache exist?
199                 if (file_exists($this->classCacheFQFN)) {
200                         // Then include it
201                         require($this->classCacheFQFN);
202
203                         // Mark the class cache as loaded
204                         $this->classesCached = true;
205                 } // END - if
206         }
207
208         /**
209          * Autoload-function
210          *
211          * @param       $className      Name of the class to load
212          * @return      void
213          */
214         public static function autoLoad ($className) {
215                 // Try to include this class
216                 self::getSelfInstance()->includeClass($className);
217         }
218
219         /**
220          * Singleton getter for an instance of this class
221          *
222          * @return      $selfInstance           A singleton instance of this class
223          */
224         public static final function getSelfInstance () {
225                 // Is the instance there?
226                 if (is_null(self::$selfInstance)) {
227                         // Get a new one
228                         self::$selfInstance = ClassLoader::createClassLoader(FrameworkConfiguration::getSelfInstance());
229                 } // END - if
230
231                 // Return the instance
232                 return self::$selfInstance;
233         }
234
235         /**
236          * Scans recursively a local path for class files which must have a prefix and a suffix as given by $this->suffix and $this->prefix
237          *
238          * @param       $basePath               The relative base path to 'base_path' constant for all classes
239          * @param       $ignoreList             An optional list (array forced) of directory and file names which shall be ignored
240          * @return      void
241          */
242         public function scanClassPath ($basePath, array $ignoreList = array() ) {
243                 // Is a list has been restored from cache, don't read it again
244                 if ($this->listCached === true) {
245                         // Abort here
246                         return;
247                 } // END - if
248
249                 // Directories which our class loader ignores by default while
250                 // deep-scanning the directory structure.
251                 $ignoreList[] = '.';
252                 $ignoreList[] = '..';
253                 $ignoreList[] = '.htaccess';
254                 $ignoreList[] = '.svn';
255
256                 // Keep it in class for later usage
257                 $this->ignoreList = $ignoreList;
258
259                 // Set base directory which holds all our classes, we should use an
260                 // absolute path here so is_dir(), is_file() and so on will always
261                 // find the correct files and dirs.
262                 $basePath2 = realpath($basePath);
263
264                 // If the basePath is false it is invalid
265                 if ($basePath2 === false) {
266                         /* @todo: Do not die here. */
267                         die('Cannot read ' . $basePath . ' !');
268                 } else {
269                         // Set base path
270                         $basePath = $basePath2;
271                 }
272
273                 // Get a new iterator
274                 //* DEBUG: */ echo "<strong>Base path: {$basePath}</strong><br />\n";
275                 $iterator = new RecursiveDirectoryIterator($basePath);
276                 $recursive = new RecursiveIteratorIterator($iterator);
277                 foreach ($recursive as $entry) {
278                         // Get filename from iterator
279                         $fileName = $entry->getFileName();
280
281                         // Get the FQFN and add it to our class list
282                         $fqfn = $entry->getRealPath();
283
284                         // Is this file wanted?
285                         //* DEBUG: */ echo "FOUND:{$fileName}<br />\n";
286                         if ((!in_array($fileName, $this->ignoreList)) && (filesize($fqfn) > 100) && (substr($fileName, 0, strlen($this->prefix)) == $this->prefix) && (substr($fileName, -strlen($this->suffix), strlen($this->suffix)) == $this->suffix)) {
287                                 //* DEBUG: */ echo "ADD: {$fileName}<br />\n";
288                                 // Add it to the list
289                                 $this->classes[$fileName] = $fqfn;
290                         } // END - if
291                 } // END - foreach
292         }
293
294         /**
295          * Load extra config files
296          *
297          * @return      void
298          */
299         public function loadExtraConfigs () {
300                 // Backup old prefix
301                 $oldPrefix = $this->prefix;
302
303                 // Set new prefix (temporary!)
304                 $this->prefix = 'config-';
305
306                 // Set base directory
307                 $basePath = $this->configInstance->getConfigEntry('base_path') . 'inc/config/';
308
309                 // Load all classes from the config directory
310                 $this->scanClassPath($basePath);
311
312                 // Include these extra configs now
313                 $this->includeExtraConfigs();
314
315                 // Set the prefix back
316                 $this->prefix = $oldPrefix;
317         }
318
319         /**
320          * Tries to find the given class in our list. This method ignores silently
321          * missing classes or interfaces. So if you use class_exists() this method
322          * does not interrupt your program.
323          *
324          * @param       $className      The class we shall load
325          * @return      void
326          */
327         public function includeClass ($className) {
328                 // Create a name with prefix and suffix
329                 $fileName = $this->prefix . $className . $this->suffix;
330
331                 // Now look it up in our index
332                 if ((isset($this->classes[$fileName])) && (!in_array($this->classes[$fileName], $this->loadedClasses))) {
333                         // File is found and not loaded so load it only once
334                         //* DEBUG: */ echo "LOAD: ".$fileName." - Start<br />\n";
335                         require($this->classes[$fileName]);
336                         //* DEBUG: */ echo "LOAD: ".$fileName." - End<br />\n";
337
338                         // Count this include
339                         $this->total++;
340
341                         // Mark this class as loaded
342                         $this->loadedClasses[] = $this->classes[$fileName];
343
344                         // Remove it from classes list
345                         unset($this->classes[$fileName]);
346
347                         // Developer mode excludes caching (better debugging)
348                         if (!defined('DEVELOPER')) {
349                                 // Reset cache
350                                 $this->classesCached = false;
351                         } // END - if
352                 } // END - if
353         }
354
355         /**
356          * Includes all extra config files
357          *
358          * @return      void
359          */
360         private function includeExtraConfigs () {
361                 // Run through all class names (should not be much)
362                 foreach ($this->classes as $fileName => $fqfn) {
363                         // Is this a config?
364                         if (substr($fileName, 0, strlen($this->prefix)) == $this->prefix) {
365                                 // Then include it
366                                 require($fqfn);
367
368                                 // Remove it from the list
369                                 unset($this->classes[$fileName]);
370                         } // END - if
371                 } // END - foreach
372         }
373
374         /**
375          * Getter for total include counter
376          *
377          * @return      $total  Total loaded include files
378          */
379         public final function getTotal () {
380                 return $this->total;
381         }
382
383         /**
384          * Getter for a printable list of included classes/interfaces/exceptions
385          *
386          * @param       $includeList    A printable include list
387          */
388         public function getPrintableIncludeList () {
389                 // Prepare the list
390                 $includeList = '';
391                 foreach ($this->loadedClasses as $classFile) {
392                         $includeList .= basename($classFile)."<br />\n";
393                 } // END - foreach
394
395                 // And return it
396                 return $includeList;
397         }
398 }
399
400 // [EOF]
401 ?>