1. sfAutoload.class.php
  2. /**
 * sfAutoload class.
 *
 * This class is a singleton as PHP seems to be unable to register 2 autoloaders that are instances
 * of the same class (why?).
 *
 * @package    symfony
 * @subpackage autoload
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfAutoload.class.php 23205 2009-10-20 13:20:17Z Kris.Wallsmith $
 */
  3. class sfAutoload
  4. {
  5.   static protected
  6.     $freshCache = false,
  7.     $instance   = null;
  9.   protected
  10.     $overriden = array(),
  11.     $classes   = array();
  13.   protected function __construct()
  14.   {
  15.   }
  17.   /**
  18.    * Retrieves the singleton instance of this class.
  19.    *
  20.    * @return sfCoreAutoload A sfCoreAutoload implementation instance.
  21.    */
  22.   static public function getInstance()
  23.   {
  24.     if (!isset(self::$instance))
  25.     {
  26.       self::$instance = new sfAutoload();
  27.     }
  29.     return self::$instance;
  30.   }
  32.   /**
  33.    * Register sfAutoload in spl autoloader.
  34.    *
  35.    * @return void
  36.    */
  37.   static public function register()
  38.   {
  39.     ini_set('unserialize_callback_func', 'spl_autoload_call');
  41.     if (false === spl_autoload_register(array(self::getInstance(), 'autoload')))
  42.     {
  43.       throw new sfException(sprintf('Unable to register %s::autoload as an autoloading method.', get_class(self::getInstance())));
  44.     }
  45.   }
  47.   /**
  48.    * Unregister sfAutoload from spl autoloader.
  49.    *
  50.    * @return void
  51.    */
  52.   static public function unregister()
  53.   {
  54.     spl_autoload_unregister(array(self::getInstance(), 'autoload'));
  55.   }
  57.   /**
  58.    * Sets the path for a particular class.
  59.    *
  60.    * @param string $class A PHP class name
  61.    * @param string $path  An absolute path
  62.    */
  63.   public function setClassPath($class, $path)
  64.   {
  65.     $class = strtolower($class);
  67.     $this->overriden[$class] = $path;
  69.     $this->classes[$class] = $path;
  70.   }
  72.   /**
  73.    * Returns the path where a particular class can be found.
  74.    *
  75.    * @param string $class A PHP class name
  76.    *
  77.    * @return string|null An absolute path
  78.    */
  79.   public function getClassPath($class)
  80.   {
  81.     $class = strtolower($class);
  83.     return isset($this->classes[$class]) ? $this->classes[$class] : null;
  84.   }
  86.   /**
  87.    * Reloads the autoloader.
  88.    *
  89.    * @param  boolean $force Whether to force a reload
  90.    *
  91.    * @return boolean True if the reload was successful, otherwise false
  92.    */
  93.   public function reloadClasses($force = false)
  94.   {
  95.     // only (re)load the autoloading cache once per request
  96.     if (self::$freshCache && !$force)
  97.     {
  98.       return false;
  99.     }
  101.     $configuration = sfProjectConfiguration::getActive();
  102.     if (!$configuration || !$configuration instanceof sfApplicationConfiguration)
  103.     {
  104.       return false;
  105.     }
  107.     self::$freshCache = true;
  108.     if (file_exists($configuration->getConfigCache()->getCacheName('config/autoload.yml')))
  109.     {
  110.       self::$freshCache = false;
  111.       if ($force)
  112.       {
  113.         unlink($configuration->getConfigCache()->getCacheName('config/autoload.yml'));
  114.       }
  115.     }
  117.     $file = $configuration->getConfigCache()->checkConfig('config/autoload.yml');
  119.     $this->classes = include($file);
  121.     foreach ($this->overriden as $class => $path)
  122.     {
  123.       $this->classes[$class] = $path;
  124.     }
  126.     return true;
  127.   }
  129.   /**
  130.    * Handles autoloading of classes that have been specified in autoload.yml.
  131.    *
  132.    * @param  string  $class  A class name.
  133.    *
  134.    * @return boolean Returns true if the class has been loaded
  135.    */
  136.   public function autoload($class)
  137.   {
  138.     // load the list of autoload classes
  139.     if (!$this->classes)
  140.     {
  141.       self::reloadClasses();
  142.     }
  144.     return self::loadClass($class);
  145.   }
  147.   /**
  148.    * Tries to load a class that has been specified in autoload.yml.
  149.    *
  150.    * @param  string  $class  A class name.
  151.    *
  152.    * @return boolean Returns true if the class has been loaded
  153.    */
  154.   public function loadClass($class)
  155.   {
  156.     $class = strtolower($class);
  158.     // class already exists
  159.     if (class_exists($class, false) || interface_exists($class, false))
  160.     {
  161.       return true;
  162.     }
  164.     // we have a class path, let's include it
  165.     if (isset($this->classes[$class]))
  166.     {
  167.       try
  168.       {
  169.         require $this->classes[$class];
  170.       }
  171.       catch (sfException $e)
  172.       {
  173.         $e->printStackTrace();
  174.       }
  175.       catch (Exception $e)
  176.       {
  177.         sfException::createFromException($e)->printStackTrace();
  178.       }
  180.       return true;
  181.     }
  183.     // see if the file exists in the current module lib directory
  184.     if (
  185.       sfContext::hasInstance()
  186.       &&
  187.       ($module = sfContext::getInstance()->getModuleName())
  188.       &&
  189.       isset($this->classes[$module.'/'.$class])
  190.     )
  191.     {
  192.       try
  193.       {
  194.         require $this->classes[$module.'/'.$class];
  195.       }
  196.       catch (sfException $e)
  197.       {
  198.         $e->printStackTrace();
  199.       }
  200.       catch (Exception $e)
  201.       {
  202.         sfException::createFromException($e)->printStackTrace();
  203.       }
  205.       return true;
  206.     }
  208.     return false;
  209.   }
  210. }
Debug toolbar