interface/modules/zend_modules/library/Zend/Loader/AutoloaderFactory.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Loader;
  11
  12 use ReflectionClass;
  13 use Traversable;
  14
  15 if (class_exists('Zend\Loader\AutoloaderFactory')) {
  16     return;
  17 }
  18
  19 abstract class AutoloaderFactory
  20 {
  21     const STANDARD_AUTOLOADER = 'Zend\Loader\StandardAutoloader';
  22
  23     /**
  24      * @var array All autoloaders registered using the factory
  25      */
  26     protected static $loaders = array();
  27
  28     /**
  29      * @var StandardAutoloader StandardAutoloader instance for resolving
  30      * autoloader classes via the include_path
  31      */
  32     protected static $standardAutoloader;
  33
  34     /**
  35      * Factory for autoloaders
  36      *
  37      * Options should be an array or Traversable object of the following structure:
  38      * <code>
  39      * array(
  40      *     '<autoloader class name>' => $autoloaderOptions,
  41      * )
  42      * </code>
  43      *
  44      * The factory will then loop through and instantiate each autoloader with
  45      * the specified options, and register each with the spl_autoloader.
  46      *
  47      * You may retrieve the concrete autoloader instances later using
  48      * {@link getRegisteredAutoloaders()}.
  49      *
  50      * Note that the class names must be resolvable on the include_path or via
  51      * the Zend library, using PSR-0 rules (unless the class has already been
  52      * loaded).
  53      *
  54      * @param  array|Traversable $options (optional) options to use. Defaults to Zend\Loader\StandardAutoloader
  55      * @return void
  56      * @throws Exception\InvalidArgumentException for invalid options
  57      * @throws Exception\InvalidArgumentException for unloadable autoloader classes
  58      * @throws Exception\DomainException for autoloader classes not implementing SplAutoloader
  59      */
  60     public static function factory($options = null)
  61     {
  62         if (null === $options) {
  63             if (!isset(static::$loaders[static::STANDARD_AUTOLOADER])) {
  64                 $autoloader = static::getStandardAutoloader();
  65                 $autoloader->register();
  66                 static::$loaders[static::STANDARD_AUTOLOADER] = $autoloader;
  67             }
  68
  69             // Return so we don't hit the next check's exception (we're done here anyway)
  70             return;
  71         }
  72
  73         if (!is_array($options) && !($options instanceof Traversable)) {
  74             require_once __DIR__ . '/Exception/InvalidArgumentException.php';
  75             throw new Exception\InvalidArgumentException(
  76                 'Options provided must be an array or Traversable'
  77             );
  78         }
  79
  80         foreach ($options as $class => $autoloaderOptions) {
  81             if (!isset(static::$loaders[$class])) {
  82                 $autoloader = static::getStandardAutoloader();
  83                 if (!class_exists($class) && !$autoloader->autoload($class)) {
  84                     require_once 'Exception/InvalidArgumentException.php';
  85                     throw new Exception\InvalidArgumentException(
  86                         sprintf('Autoloader class "%s" not loaded', $class)
  87                     );
  88                 }
  89
  90                 if (!static::isSubclassOf($class, 'Zend\Loader\SplAutoloader')) {
  91                     require_once 'Exception/InvalidArgumentException.php';
  92                     throw new Exception\InvalidArgumentException(
  93                         sprintf('Autoloader class %s must implement Zend\\Loader\\SplAutoloader', $class)
  94                     );
  95                 }
  96
  97                 if ($class === static::STANDARD_AUTOLOADER) {
  98                     $autoloader->setOptions($autoloaderOptions);
  99                 } else {
 100                     $autoloader = new $class($autoloaderOptions);
 101                 }
 102                 $autoloader->register();
 103                 static::$loaders[$class] = $autoloader;
 104             } else {
 105                 static::$loaders[$class]->setOptions($autoloaderOptions);
 106             }
 107         }
 108     }
 109
 110     /**
 111      * Get an list of all autoloaders registered with the factory
 112      *
 113      * Returns an array of autoloader instances.
 114      *
 115      * @return array
 116      */
 117     public static function getRegisteredAutoloaders()
 118     {
 119         return static::$loaders;
 120     }
 121
 122     /**
 123      * Retrieves an autoloader by class name
 124      *
 125      * @param  string $class
 126      * @return SplAutoloader
 127      * @throws Exception\InvalidArgumentException for non-registered class
 128      */
 129     public static function getRegisteredAutoloader($class)
 130     {
 131         if (!isset(static::$loaders[$class])) {
 132             require_once 'Exception/InvalidArgumentException.php';
 133             throw new Exception\InvalidArgumentException(sprintf('Autoloader class "%s" not loaded', $class));
 134         }
 135         return static::$loaders[$class];
 136     }
 137
 138     /**
 139      * Unregisters all autoloaders that have been registered via the factory.
 140      * This will NOT unregister autoloaders registered outside of the fctory.
 141      *
 142      * @return void
 143      */
 144     public static function unregisterAutoloaders()
 145     {
 146         foreach (static::getRegisteredAutoloaders() as $class => $autoloader) {
 147             spl_autoload_unregister(array($autoloader, 'autoload'));
 148             unset(static::$loaders[$class]);
 149         }
 150     }
 151
 152     /**
 153      * Unregister a single autoloader by class name
 154      *
 155      * @param  string $autoloaderClass
 156      * @return bool
 157      */
 158     public static function unregisterAutoloader($autoloaderClass)
 159     {
 160         if (!isset(static::$loaders[$autoloaderClass])) {
 161             return false;
 162         }
 163
 164         $autoloader = static::$loaders[$autoloaderClass];
 165         spl_autoload_unregister(array($autoloader, 'autoload'));
 166         unset(static::$loaders[$autoloaderClass]);
 167         return true;
 168     }
 169
 170     /**
 171      * Get an instance of the standard autoloader
 172      *
 173      * Used to attempt to resolve autoloader classes, using the
 174      * StandardAutoloader. The instance is marked as a fallback autoloader, to
 175      * allow resolving autoloaders not under the "Zend" namespace.
 176      *
 177      * @return SplAutoloader
 178      */
 179     protected static function getStandardAutoloader()
 180     {
 181         if (null !== static::$standardAutoloader) {
 182             return static::$standardAutoloader;
 183         }
 184
 185
 186         if (!class_exists(static::STANDARD_AUTOLOADER)) {
 187             // Extract the filename from the classname
 188             $stdAutoloader = substr(strrchr(static::STANDARD_AUTOLOADER, '\\'), 1);
 189             require_once __DIR__ . "/$stdAutoloader.php";
 190         }
 191         $loader = new StandardAutoloader();
 192         static::$standardAutoloader = $loader;
 193         return static::$standardAutoloader;
 194     }
 195
 196     /**
 197      * Checks if the object has this class as one of its parents
 198      *
 199      * @see https://bugs.php.net/bug.php?id=53727
 200      * @see https://github.com/zendframework/zf2/pull/1807
 201      *
 202      * @param  string $className
 203      * @param  string $type
 204      * @return bool
 205      */
 206     protected static function isSubclassOf($className, $type)
 207     {
 208         if (is_subclass_of($className, $type)) {
 209             return true;
 210         }
 211         if (version_compare(PHP_VERSION, '5.3.7', '>=')) {
 212             return false;
 213         }
 214         if (!interface_exists($type)) {
 215             return false;
 216         }
 217         $r = new ReflectionClass($className);
 218         return $r->implementsInterface($type);
 219     }
 220 }