class_ClassLoader.php

Go to the documentation of this file.

<?php
class ClassLoader {
        private static $selfInstance = null;

        private $cfg = array();

        private $classes = array();

        private $loadedClasses = array();

        private $prefix = "class_";

        private $suffix = ".php";

        private $suffixLen = 0;

        private $prefixLen = 0;

        private $ignoreList = array();

        private $debug = false;

        private $listCached = false;

        private $classesCached = false;

        private $listCacheFQFN = "";

        private $classCacheFQFN = "";

        private $total = 0;

        public function __construct (FrameworkConfiguration $cfgInstance) {
                // Set configuration instance
                $this->cfgInstance = $cfgInstance;

                // Construct the FQFN for the cache
                if (!defined('DEVELOPER')) {
                        $this->listCacheFQFN  = $this->cfgInstance->readConfig('local_db_path') . "list-" . $this->cfgInstance->readConfig('app_name') . ".cache";
                        $this->classCacheFQFN = $this->cfgInstance->readConfig('local_db_path') . "class-" . $this->cfgInstance->readConfig('app_name') . ".cache";
                } // END - if

                // Set suffix and prefix from configuration
                $this->suffix = $cfgInstance->readConfig('class_suffix');
                $this->prefix = $cfgInstance->readConfig('class_prefix');

                // Estimate length of prefix and suffix for substr() function (cache)
                $this->suffixLen = strlen($this->suffix);
                $this->prefixLen = strlen($this->prefix);

                // Set own instance
                self::$selfInstance = $this;

                // Skip here if no dev-mode
                if (defined('DEVELOPER')) return;

                // IS the cache there?
                if (file_exists($this->listCacheFQFN)) {
                        // Get content
                        $cacheContent = file_get_contents($this->listCacheFQFN);

                        // And convert it
                        $this->classes = unserialize($cacheContent);

                        // List has been restored from cache!
                        $this->listCached = true;
                } // END - if

                // Does the class cache exist?
                if (file_exists($this->classCacheFQFN)) {
                        // Then include it
                        require($this->classCacheFQFN);

                        // Mark the class cache as loaded
                        $this->classesCached = true;
                } // END - if
        }

        public function __destruct () {
                // Skip here if dev-mode
                if (defined('DEVELOPER')) return;

                // Skip here if already cached
                if ($this->listCached === false) {
                        // Writes the cache file of our list away
                        $cacheContent = serialize($this->classes);
                        file_put_contents($this->listCacheFQFN, $cacheContent);
                } // END - if

                // Skip here if already cached
                if ($this->classesCached === false) {
                        // Generate a full-cache of all classes
                        $cacheContent = "";
                        foreach ($this->loadedClasses as $fqfn) {
                                // Load the file
                                $cacheContent .= file_get_contents($fqfn);
                        } // END - foreach

                        // And write it away
                        file_put_contents($this->classCacheFQFN, $cacheContent);
                } // END - if
        }

        public final static function getInstance () {
                // Is the instance there?
                if (is_null(self::$selfInstance)) {
                        // Get a new one
                        self::$selfInstance = new ClassLoader(FrameworkConfiguration::getInstance());
                } // END - if

                // Return the instance
                return self::$selfInstance;
        }

        public function loadClasses ($basePath, $ignoreList = array() ) {
                // Is a list has been restored from cache, don't read it again
                if ($this->listCached === true) {
                        // Abort here
                        return;
                }

                // Convert string to array
                if (!is_array($ignoreList)) $ignoreList = array($ignoreList);

                // Directories which our class loader ignores by default while
                // deep-scanning the directory structure. See scanLocalPath() for
                // details.
                $ignoreList[] = ".";
                $ignoreList[] = "..";
                $ignoreList[] = ".htaccess";
                $ignoreList[] = ".svn";

                // Keep it in class for later usage
                $this->ignoreList = $ignoreList;

                // Set base directory which holds all our classes, we should use an
                // absolute path here so is_dir(), is_file() and so on will always
                // find the correct files and dirs.
                $basePath2 = realpath($basePath);

                // If the basePath is false it is invalid
                if ($basePath2 === false) {
                        /* @todo: Do not die here. */
                        die("Cannot read {$basePath} !");
                } else {
                        // Set base path
                        $basePath = $basePath2;
                }

                // Get a new iterator
                //* DEBUG: */ echo "<strong>Base path: {$basePath}</strong><br />\n";
                $iterator = new RecursiveDirectoryIterator($basePath);
                $recursive = new RecursiveIteratorIterator($iterator);
                foreach ($recursive as $entry) {
                        // Get filename from iterator
                        $fileName = $entry->getFileName();

                        // Is this file wanted?
                        //* DEBUG: */ echo "FOUND:{$fileName}<br />\n";
                        if ((!in_array($fileName, $this->ignoreList)) && (substr($fileName, 0, $this->prefixLen) == $this->prefix) && (substr($fileName, -$this->suffixLen, $this->suffixLen) == $this->suffix)) {
                                // Get the FQFN and add it to our class list
                                $fqfn = $entry->getRealPath();
                                //* DEBUG: */ echo "ADD: {$fileName}<br />\n";
                                $this->classes[$fileName] = $fqfn;
                        } // END - if
                } // END - foreach
        }

        public function loadExtraConfigs () {
                // Backup old prefix
                $oldPrefix = $this->prefix;

                // Set new prefix (temporary!)
                $this->prefix = "config-";
                $this->prefixLen = strlen($this->prefix);

                // Set base directory
                $basePath = sprintf("%sinc/config/", $this->cfgInstance->readConfig('base_path'));

                // Load all classes from the config directory
                $this->loadClasses($basePath);

                // Include these extra configs now
                $this->includeExtraConfigs();

                // Set the prefix back
                $this->prefix = $oldPrefix;
                $this->prefixLen = strlen($this->prefix);

        }

        public function includeClass ($className) {
                // Create a name with prefix and suffix
                $fileName = $this->prefix . $className . $this->suffix;

                // Now look it up in our index
                if (isset($this->classes[$fileName])) {
                        // File is found so load it only once
                        //* DEBUG: */ echo "LOAD: ".$fileName." - Start<br />\n";
                        require($this->classes[$fileName]);
                        //* DEBUG: */ echo "LOAD: ".$fileName." - End<br />\n";

                        // Count this include
                        $this->total++;

                        // Mark this class as loaded
                        $this->loadedClasses[] = $this->classes[$fileName];

                        // Developer mode excludes caching (better debugging)
                        if (!defined('DEVELOPER')) {
                                // Reset cache
                                $this->classesCached = false;
                        } // END - if
                } // END - if
        }

        private function includeExtraConfigs () {
                // Run through all class names (should not be much)
                foreach ($this->classes as $fileName => $fqfn) {
                        // Is this a config?
                        if (substr($fileName, 0, $this->prefixLen) == $this->prefix) {
                                // Then include it
                                require($fqfn);

                                // Remove it from the list
                                unset($this->classes[$fileName]);
                        } // END - if
                } // END - foreach
        }

        public final function getTotal () {
                return $this->total;
        }

        public function getPrintableIncludeList () {
                // Prepare the list
                $includeList = "";
                foreach ($this->loadedClasses as $classFile) {
                        $includeList .= basename($classFile)."<br />\n";
                } // END - foreach

                // And return it
                return $includeList;
        }
}

// [EOF]
?>