interface/modules/zend_modules/library/Zend/Loader/PluginClassLoader.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 ArrayIterator;
  13 use IteratorAggregate;
  14 use Traversable;
  15
  16 /**
  17  * Plugin class locator interface
  18  */
  19 class PluginClassLoader implements PluginClassLocator
  20 {
  21     /**
  22      * List of plugin name => class name pairs
  23      * @var array
  24      */
  25     protected $plugins = array();
  26
  27     /**
  28      * Static map allow global seeding of plugin loader
  29      * @var array
  30      */
  31     protected static $staticMap = array();
  32
  33     /**
  34      * Constructor
  35      *
  36      * @param  null|array|Traversable $map If provided, seeds the loader with a map
  37      */
  38     public function __construct($map = null)
  39     {
  40         // Merge in static overrides
  41         if (!empty(static::$staticMap)) {
  42             $this->registerPlugins(static::$staticMap);
  43         }
  44
  45         // Merge in constructor arguments
  46         if ($map !== null) {
  47             $this->registerPlugins($map);
  48         }
  49     }
  50
  51     /**
  52      * Add a static map of plugins
  53      *
  54      * A null value will clear the static map.
  55      *
  56      * @param  null|array|Traversable $map
  57      * @throws Exception\InvalidArgumentException
  58      * @return void
  59      */
  60     public static function addStaticMap($map)
  61     {
  62         if (null === $map) {
  63             static::$staticMap = array();
  64             return;
  65         }
  66
  67         if (!is_array($map) && !$map instanceof Traversable) {
  68             throw new Exception\InvalidArgumentException('Expects an array or Traversable object');
  69         }
  70         foreach ($map as $key => $value) {
  71             static::$staticMap[$key] = $value;
  72         }
  73     }
  74
  75     /**
  76      * Register a class to a given short name
  77      *
  78      * @param  string $shortName
  79      * @param  string $className
  80      * @return PluginClassLoader
  81      */
  82     public function registerPlugin($shortName, $className)
  83     {
  84         $this->plugins[strtolower($shortName)] = $className;
  85         return $this;
  86     }
  87
  88     /**
  89      * Register many plugins at once
  90      *
  91      * If $map is a string, assumes that the map is the class name of a
  92      * Traversable object (likely a ShortNameLocator); it will then instantiate
  93      * this class and use it to register plugins.
  94      *
  95      * If $map is an array or Traversable object, it will iterate it to
  96      * register plugin names/classes.
  97      *
  98      * For all other arguments, or if the string $map is not a class or not a
  99      * Traversable class, an exception will be raised.
 100      *
 101      * @param  string|array|Traversable $map
 102      * @return PluginClassLoader
 103      * @throws Exception\InvalidArgumentException
 104      */
 105     public function registerPlugins($map)
 106     {
 107         if (is_string($map)) {
 108             if (!class_exists($map)) {
 109                 throw new Exception\InvalidArgumentException('Map class provided is invalid');
 110             }
 111             $map = new $map;
 112         }
 113         if (is_array($map)) {
 114             $map = new ArrayIterator($map);
 115         }
 116         if (!$map instanceof Traversable) {
 117             throw new Exception\InvalidArgumentException('Map provided is invalid; must be traversable');
 118         }
 119
 120         // iterator_apply doesn't work as expected with IteratorAggregate
 121         if ($map instanceof IteratorAggregate) {
 122             $map = $map->getIterator();
 123         }
 124
 125         foreach ($map as $name => $class) {
 126             if (is_int($name) || is_numeric($name)) {
 127                 if (!is_object($class) && class_exists($class)) {
 128                     $class = new $class();
 129                 }
 130
 131                 if ($class instanceof Traversable) {
 132                     $this->registerPlugins($class);
 133                     continue;
 134                 }
 135             }
 136
 137             $this->registerPlugin($name, $class);
 138         }
 139
 140         return $this;
 141     }
 142
 143     /**
 144      * Unregister a short name lookup
 145      *
 146      * @param  mixed $shortName
 147      * @return PluginClassLoader
 148      */
 149     public function unregisterPlugin($shortName)
 150     {
 151         $lookup = strtolower($shortName);
 152         if (array_key_exists($lookup, $this->plugins)) {
 153             unset($this->plugins[$lookup]);
 154         }
 155         return $this;
 156     }
 157
 158     /**
 159      * Get a list of all registered plugins
 160      *
 161      * @return array|Traversable
 162      */
 163     public function getRegisteredPlugins()
 164     {
 165         return $this->plugins;
 166     }
 167
 168     /**
 169      * Whether or not a plugin by a specific name has been registered
 170      *
 171      * @param  string $name
 172      * @return bool
 173      */
 174     public function isLoaded($name)
 175     {
 176         $lookup = strtolower($name);
 177         return isset($this->plugins[$lookup]);
 178     }
 179
 180     /**
 181      * Return full class name for a named helper
 182      *
 183      * @param  string $name
 184      * @return string|false
 185      */
 186     public function getClassName($name)
 187     {
 188         return $this->load($name);
 189     }
 190
 191     /**
 192      * Load a helper via the name provided
 193      *
 194      * @param  string $name
 195      * @return string|false
 196      */
 197     public function load($name)
 198     {
 199         if (!$this->isLoaded($name)) {
 200             return false;
 201         }
 202         return $this->plugins[strtolower($name)];
 203     }
 204
 205     /**
 206      * Defined by IteratorAggregate
 207      *
 208      * Returns an instance of ArrayIterator, containing a map of
 209      * all plugins
 210      *
 211      * @return ArrayIterator
 212      */
 213     public function getIterator()
 214     {
 215         return new ArrayIterator($this->plugins);
 216     }
 217 }