<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE.txt.

 * It is also available through the world-wide-web at this URL:

 * http://framework.zend.com/license/new-bsd

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to license@zend.com so we can send you a copy immediately.

 *

 * @category   Zend

 * @package    Zend_Loader

 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

require_once dirname(__FILE__) . '/SplAutoloader.php';

if (class_exists('Zend_Loader_AutoloaderFactory')) return;

/**

 * @package    Zend_Loader

 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

abstract class Zend_Loader_AutoloaderFactory

{

    const STANDARD_AUTOLOADER = 'Zend_Loader_StandardAutoloader';

    /**

     * @var array All autoloaders registered using the factory

     */

    protected static $loaders = array();

    /**

     * @var Zend_Loader_StandardAutoloader StandardAutoloader instance for resolving 

     * autoloader classes via the include_path

     */

    protected static $standardAutoloader;

    /**

     * Factory for autoloaders

     *

     * Options should be an array or Traversable object of the following structure:

     * <code>

     * array(

     *     '<autoloader class name>' => $autoloaderOptions,

     * )

     * </code>

     *

     * The factory will then loop through and instantiate each autoloader with

     * the specified options, and register each with the spl_autoloader.

     *

     * You may retrieve the concrete autoloader instances later using

     * {@link getRegisteredAutoloaders()}.

     *

     * Note that the class names must be resolvable on the include_path or via

     * the Zend library, using PSR-0 rules (unless the class has already been

     * loaded).

     *

     * @param  array|Traversable $options (optional) options to use. Defaults to Zend_Loader_StandardAutoloader

     * @return void

     * @throws Zend_Loader_Exception_InvalidArgumentException for invalid options

     * @throws Zend_Loader_Exception_InvalidArgumentException for unloadable autoloader classes

     */

    public static function factory($options = null)

    {

        if (null === $options) {

            if (!isset(self::$loaders[self::STANDARD_AUTOLOADER])) {

                $autoloader = self::getStandardAutoloader();

                $autoloader->register();

                self::$loaders[self::STANDARD_AUTOLOADER] = $autoloader;

            }

            // Return so we don't hit the next check's exception (we're done here anyway)

            return;

        }

        if (!is_array($options) && !($options instanceof Traversable)) {

            require_once 'Exception/InvalidArgumentException.php';

            throw new Zend_Loader_Exception_InvalidArgumentException(

                'Options provided must be an array or Traversable'

            );

        }

        foreach ($options as $class => $options) {

            if (!isset(self::$loaders[$class])) {

                $autoloader = self::getStandardAutoloader();

                if (!class_exists($class) && !$autoloader->autoload($class)) {

                    require_once 'Exception/InvalidArgumentException.php';

                    throw new Zend_Loader_Exception_InvalidArgumentException(sprintf(

                        'Autoloader class "%s" not loaded', 

                        $class

                    ));

                }

                // unfortunately is_subclass_of is broken on some 5.3 versions

                // additionally instanceof is also broken for this use case

                if (version_compare(PHP_VERSION, '5.3.7', '>=')) {

                        if (!is_subclass_of($class, 'Zend_Loader_SplAutoloader')) {

                        require_once 'Exception/InvalidArgumentException.php';

                        throw new Zend_Loader_Exception_InvalidArgumentException(sprintf(

                            'Autoloader class %s must implement Zend\\Loader\\SplAutoloader', 

                            $class

                        ));

                    }

                }

                if ($class === self::STANDARD_AUTOLOADER) {

                    $autoloader->setOptions($options);

                } else {

                    $autoloader = new $class($options);

                }

                $autoloader->register();

                self::$loaders[$class] = $autoloader;

            } else {

                self::$loaders[$class]->setOptions($options);

            }

        }

    }

    /**

     * Get an list of all autoloaders registered with the factory

     *

     * Returns an array of autoloader instances.

     *

     * @return array

     */

    public static function getRegisteredAutoloaders()

    {

        return self::$loaders;

    }

    /**

     * Retrieves an autoloader by class name

     *

     * @param string $class

     * @return Zend_Loader_SplAutoloader

     * @throws Zend_Loader_Exception_InvalidArgumentException for non-registered class

     */

    public static function getRegisteredAutoloader($class)

    {

        if (!isset(self::$loaders[$class])) {

            require_once 'Exception/InvalidArgumentException.php';

            throw new Zend_Loader_Exception_InvalidArgumentException(sprintf('Autoloader class "%s" not loaded', $class));

        }

        return self::$loaders[$class];

    }

    /**

     * Unregisters all autoloaders that have been registered via the factory.

     * This will NOT unregister autoloaders registered outside of the fctory.

     *

     * @return void

     */

    public static function unregisterAutoloaders()

    {

        foreach (self::getRegisteredAutoloaders() as $class => $autoloader) {

            spl_autoload_unregister(array($autoloader, 'autoload'));

            unset(self::$loaders[$class]);

        }

    }

    /**

     * Unregister a single autoloader by class name

     *

     * @param  string $autoloaderClass

     * @return bool

     */

    public static function unregisterAutoloader($autoloaderClass)

    {

        if (!isset(self::$loaders[$autoloaderClass])) {

            return false;

        }

        $autoloader = self::$loaders[$autoloaderClass];

        spl_autoload_unregister(array($autoloader, 'autoload'));

        unset(self::$loaders[$autoloaderClass]);

        return true;

    }

    /**

     * Get an instance of the standard autoloader

     *

     * Used to attempt to resolve autoloader classes, using the 

     * StandardAutoloader. The instance is marked as a fallback autoloader, to 

     * allow resolving autoloaders not under the "Zend" or "Zend" namespaces.

     * 

     * @return Zend_Loader_SplAutoloader

     */

    protected static function getStandardAutoloader()

    {

        if (null !== self::$standardAutoloader) {

            return self::$standardAutoloader;

        }

        // Extract the filename from the classname

        $stdAutoloader = substr(strrchr(self::STANDARD_AUTOLOADER, '_'), 1);

        if (!class_exists(self::STANDARD_AUTOLOADER)) {

            require_once dirname(__FILE__) . "/$stdAutoloader.php";

        }

        $loader = new Zend_Loader_StandardAutoloader();

        self::$standardAutoloader = $loader;

        return self::$standardAutoloader;

    }

}