Zend_Loader_AutoloaderFactory Class Reference

Static Public Member Functions
static	factory ($options=null)
static	getRegisteredAutoloaders ()
static	getRegisteredAutoloader ($class)
static	unregisterAutoloaders ()
static	unregisterAutoloader ($autoloaderClass)

Data Fields
const	STANDARD_AUTOLOADER = 'Zend_Loader_StandardAutoloader'
const	CLASS_MAP_AUTOLOADER = 'Zend_Loader_ClassMapAutoloader'

Static Protected Member Functions
static	getStandardAutoloader ()

Static Protected Attributes
static	$loaders = array()
static	$standardAutoloader

Detailed Description

Definition at line 30 of file AutoloaderFactory.php.

Member Function Documentation

factory()

array All autoloaders registered using the factory (   $options = null )

static

Factory for autoloaders

Options should be an array or Traversable object of the following structure: array( '<autoloader class="" name>="">' => $autoloaderOptions, )

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 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).

Parameters

array | Traversable

$options

(optional) options to use. Defaults to Zend_Loader_StandardAutoloader

Returns

void

Exceptions

Zend_Loader_Exception_InvalidArgumentException	for invalid options
Zend_Loader_Exception_InvalidArgumentException	for unloadable autoloader classes

Definition at line 71 of file AutoloaderFactory.php.

    {
        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])) {
                // Check class map autoloader
                if ($class == self::CLASS_MAP_AUTOLOADER) {
                    if (!class_exists(self::CLASS_MAP_AUTOLOADER)) {
                        // Extract the filename from the classname
                        $classMapLoader = substr(
                            strrchr(self::CLASS_MAP_AUTOLOADER, '_'), 1
                        );

                        require_once dirname(__FILE__) . "/$classMapLoader.php";
                    }
                }

                // Autoload with standard autoloader
                $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);
            }
        }
    }

getRegisteredAutoloader()

static getRegisteredAutoloader (   $class )

static

Retrieves an autoloader by class name

Parameters

string

$class

Returns

Zend_Loader_SplAutoloader

Exceptions

Zend_Loader_Exception_InvalidArgumentException

for non-registered class

Definition at line 159 of file AutoloaderFactory.php.

    {
        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];
    }

getRegisteredAutoloaders()

static getRegisteredAutoloaders ( )

static

Get an list of all autoloaders registered with the factory

Returns an array of autoloader instances.

Returns

array

Definition at line 147 of file AutoloaderFactory.php.

    {
        return self::$loaders;
    }

getStandardAutoloader()

static getStandardAutoloader ( )

staticprotected

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.

Returns

Zend_Loader_SplAutoloader

Definition at line 209 of file AutoloaderFactory.php.

    {
        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;
    }

unregisterAutoloader()

static unregisterAutoloader (   $autoloaderClass )

static

Unregister a single autoloader by class name

Parameters

string

$autoloaderClass

Returns

bool

Definition at line 188 of file AutoloaderFactory.php.

    {
        if (!isset(self::$loaders[$autoloaderClass])) {
            return false;
        }

        $autoloader = self::$loaders[$autoloaderClass];
        spl_autoload_unregister(array($autoloader, 'autoload'));
        unset(self::$loaders[$autoloaderClass]);
        return true;
    }

unregisterAutoloaders()

static unregisterAutoloaders ( )

static

Unregisters all autoloaders that have been registered via the factory. This will NOT unregister autoloaders registered outside of the fctory.

Returns

void

Definition at line 174 of file AutoloaderFactory.php.

    {
        foreach (self::getRegisteredAutoloaders() as $class => $autoloader) {
            spl_autoload_unregister(array($autoloader, 'autoload'));
            unset(self::$loaders[$class]);
        }
    }

Field Documentation

$loaders

$loaders = array()

staticprotected

Definition at line 38 of file AutoloaderFactory.php.

$standardAutoloader

$standardAutoloader

staticprotected

Definition at line 44 of file AutoloaderFactory.php.

CLASS_MAP_AUTOLOADER

const CLASS_MAP_AUTOLOADER = 'Zend_Loader_ClassMapAutoloader'

Definition at line 33 of file AutoloaderFactory.php.

STANDARD_AUTOLOADER

const STANDARD_AUTOLOADER = 'Zend_Loader_StandardAutoloader'

Definition at line 32 of file AutoloaderFactory.php.

---

The documentation for this class was generated from the following file:

• vendor/magento/zendframework1/library/Zend/Loader/AutoloaderFactory.php