Cargador de clases en PHP4

<?php
 
include_once('ClassLoader.class.php');
 
$classLoader =& new ClassLoader();
$classLoader->addPath(dirname(__FILE__).'/includes', 1);
$classLoader->addPath(dirname(__FILE__).'/admin', 1);
$classLoader->start();
 
$classLoader->includeClass('MyClass.class.php');
 
 
print_r($classLoader->_classes);
 
 
?>

<?php
/**
* Class Loader for PHP applications
*  
* Provides an easy way for make the PHP code independent from the physical 
* location where are located the php files containing the classes 
* definitions of your app.
*
* It uses an internal structure with the real location of every class available. This
* structure is build searching in configurable locations for files with name ".class.php",
* both configurable, and saving it to file, to avoid the search in any execution.
*
* The main advantage that offers is that it allows us to free the application from 
* the specific location of the classes, so we can move the classes between different 
* folders or rearrange them without modify the code of the application
*
*  LICENCE
*  ========
*    copyright (c) 2000 Patxi Echarte [patxi@eslomas.com]
*
*    This program is free software; you can redistribute it and/or
*    modify it under the terms of the GNU Lesser General Public License
*    version 2.1 as published by the Free Software Foundation.
*
*    This library is distributed in the hope that it will be useful,
*    but WITHOUT ANY WARRANTY; without even the implied warranty of
*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*    GNU Lesser General Public License for more details at 
*    http://www.gnu.org/copyleft/lgpl.html
* 
*    You should have received a copy of the GNU General Public License
*    along with this program; if not, write to the Free Software
*    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*
* @package ClassLoader
* @version $Id: ClassLoader.class.php,v 1.4 2006/02/23 $
* @author Patxi Echarte <patxi@eslomas.com>
*
*/
 
class ClassLoader{
 
 
    /**
     * Almacena cada ruta sobre la que hay que buscar clases indicando
     * si la búsqueda debe ser recursiva (1) o no (0)
     * [[path,recursive{0,1}]]
     */
    var $_paths  = null;
 
    /**
     * Patrón que deben cumplir los archivos para considerarse como clases
     */
    var $_patternClassName = "";
 
    /**
     * Matriz con las clases encontradas, se guarda como clave el nombre
     * del archivo (NO el de la clase almacenada en el archivo) y como 
     * valor el del path donde está ubicada
     */
    var $_classes = null;
 
    /**
     * Tiempo en segundos de validez de la información obtenida
     */
    var $_expirationTime = 3600;
 
    /**
     * Nombre del archivo donde guardar la información de caché
     */
    var $_cacheFileName = "";
 
 
    /**
     * Constructor de la clase
     * 
     * @param $paths
     * @param $pattern
     * @param $cache_name
     * @param $cache_folder
     */
    function ClassLoader($exp=3600, $cache_name='classLoader.dat', $cache_folder='/tmp', $pattern='\.class\.php$')
    {
        $this->_expirationTime   = $exp;
        $this->_cacheFileName    = realpath($cache_folder).'/'.$cache_name;
        $this->_patternClassName = $pattern;
    }
 
    /**
    * Añade un path
    * @param string $path ruta completa desde la raíz del sistema
    * @param bool $recursive (1|0) que indica si hay que buscar clases 
    *        de manera recursiva en el path
    */
    function addPath($path, $recursive=1)
    {
        if(ereg('\/$',$path)) $path = substr($path,0,-1);
 
        if(!file_exists($path))
            trigger_error("No existe el path indicado: [$path]", E_USER_ERROR);
        else
            $this->_paths[] = array(realpath($path), $recursive);
    }
 
    /**
    * Pone en marcha el cargador de clases, para lo cual se buscan las clases 
    * disponibles o se recuperan de caché
    */
    function start()
    {
        if(!$this->_getCachedData()){
            $this->_rebuildClassesInfo();
            $this->_setCachedData();
        }
    }
 
    /**
    * Busca clases en las ubicaciones que se han indicado
    */
    function _rebuildClassesInfo()
    {
        $this->_classes = array();
 
        foreach($this->_paths as $path_info){
            $this->_searchDir($path_info[0], $path_info[1]);
        }
    }
 
    /**
    * Función recursiva, que dado un directorio busca en él y en todos sus hijos (si así se indica) 
    * archivos que cumplan con el patrón indicado, almacenando cada coincidencia en la matriz de clases
    */
    function _searchDir($directory, $recursive=1){
 
        if ($id_dir = @opendir($directory)){
            while (false !== ($file = readdir($id_dir))){
               if ($file != "." && $file != ".."){
                   if($recursive && is_dir($directory.'/'.$file)){
                       $this->_searchDir($directory.'/'.$file, $recursive);
                   }
                   else{
                        if(ereg($this->_patternClassName, $file)) {
                            if(isset($this->_classes[$file]) && $this->_classes[$file] != ''){
                                trigger_error("Se ha encontrado un archivo de clase "
                                                ."duplicada [$directory/$file]: ".$this->_data[$file], 
                                                E_USER_ERROR);
                            }    
                            else
                                $this->_classes[$file] = realpath($directory.'/'.$file);
                        }
                   }
               }
            }
            closedir($id_dir);
        }
    }
 
    /**
    * Devuelve el path del archivo de clase indicada
    */
    function getPathForClass($cln){
        return $this->_data[$cln];
    }
 
    /**
    * Incluye el archivo necesario para tener disponibles la clase/s que contiene
    */
    function includeClass($cln){
        if(!isset($this->_classes[$cln]) || $this->_classes[$cln]==''){
            trigger_error("La clase indicada no está definida: ".$cln);
        }
        else{
            include_once($this->_classes[$cln]);
        }
    }
 
    /**
    * se realiza la inclusión de todas las clases encontradas
    */
    function includeAllClasses(){
        foreach($this->_classes as $name => $path)
            include_once($path);
    }
 
    /**
    * Comprueba si hay información en caché y si es válida, en cuyo caso la carga
    * y devuelve true, eoc devuelve false
    */
    function _getCachedData()
    {
        if( ! file_exists($this->_cacheFileName)
             || (filemtime($this->_cacheFileName) < time()-$this->_expirationTime) ){
                return false;
        }
 
        $fp = fopen($this->_cacheFileName, 'r');
        $this->_classes = unserialize(fread($fp, filesize($this->_cacheFileName)));
        fclose($fp);
 
        return true;
    }
 
    /**
    * Almacena la información de clases en caché para no tener que realizar
    * la búsqueda de clases en cada petición de páginas
    */
    function _setCachedData()
    {
        if($fp = fopen($this->_cacheFileName, 'w')){
            flock($fp, LOCK_EX);
            fwrite($fp,serialize($this->_classes));
            flock($fp, LOCK_UN);
            fclose($fp);
        }
    }
 
}
 
?>