interface/modules/zend_modules/library/Zend/Cache/StorageFactory.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\Cache;
  11
  12 use Traversable;
  13 use Zend\Stdlib\ArrayUtils;
  14
  15 abstract class StorageFactory
  16 {
  17     /**
  18      * Plugin manager for loading adapters
  19      *
  20      * @var null|Storage\AdapterPluginManager
  21      */
  22     protected static $adapters = null;
  23
  24     /**
  25      * Plugin manager for loading plugins
  26      *
  27      * @var null|Storage\PluginManager
  28      */
  29     protected static $plugins = null;
  30
  31     /**
  32      * The storage factory
  33      * This can instantiate storage adapters and plugins.
  34      *
  35      * @param array|Traversable $cfg
  36      * @return Storage\StorageInterface
  37      * @throws Exception\InvalidArgumentException
  38      */
  39     public static function factory($cfg)
  40     {
  41         if ($cfg instanceof Traversable) {
  42             $cfg = ArrayUtils::iteratorToArray($cfg);
  43         }
  44
  45         if (!is_array($cfg)) {
  46             throw new Exception\InvalidArgumentException(
  47                 'The factory needs an associative array '
  48                 . 'or a Traversable object as an argument'
  49             );
  50         }
  51
  52         // instantiate the adapter
  53         if (!isset($cfg['adapter'])) {
  54             throw new Exception\InvalidArgumentException('Missing "adapter"');
  55         }
  56         $adapterName    = $cfg['adapter'];
  57         $adapterOptions = array();
  58         if (is_array($cfg['adapter'])) {
  59             if (!isset($cfg['adapter']['name'])) {
  60                 throw new Exception\InvalidArgumentException('Missing "adapter.name"');
  61             }
  62
  63             $adapterName    = $cfg['adapter']['name'];
  64             $adapterOptions = isset($cfg['adapter']['options']) ? $cfg['adapter']['options'] : array();
  65         }
  66         if (isset($cfg['options'])) {
  67             $adapterOptions = array_merge($adapterOptions, $cfg['options']);
  68         }
  69
  70         $adapter = static::adapterFactory((string) $adapterName, $adapterOptions);
  71
  72         // add plugins
  73         if (isset($cfg['plugins'])) {
  74             if (!is_array($cfg['plugins'])) {
  75                 throw new Exception\InvalidArgumentException(
  76                     'Plugins needs to be an array'
  77                 );
  78             }
  79
  80             foreach ($cfg['plugins'] as $k => $v) {
  81                 $pluginPrio = 1; // default priority
  82
  83                 if (is_string($k)) {
  84                     if (!is_array($v)) {
  85                         throw new Exception\InvalidArgumentException(
  86                             "'plugins.{$k}' needs to be an array"
  87                         );
  88                     }
  89                     $pluginName    = $k;
  90                     $pluginOptions = $v;
  91                 } elseif (is_array($v)) {
  92                     if (!isset($v['name'])) {
  93                         throw new Exception\InvalidArgumentException("Invalid plugins[{$k}] or missing plugins[{$k}].name");
  94                     }
  95                     $pluginName = (string) $v['name'];
  96
  97                     if (isset($v['options'])) {
  98                         $pluginOptions = $v['options'];
  99                     } else {
 100                         $pluginOptions = array();
 101                     }
 102
 103                     if (isset($v['priority'])) {
 104                         $pluginPrio = $v['priority'];
 105                     }
 106                 } else {
 107                     $pluginName    = $v;
 108                     $pluginOptions = array();
 109                 }
 110
 111                 $plugin = static::pluginFactory($pluginName, $pluginOptions);
 112                 $adapter->addPlugin($plugin, $pluginPrio);
 113             }
 114         }
 115
 116         return $adapter;
 117     }
 118
 119     /**
 120      * Instantiate a storage adapter
 121      *
 122      * @param  string|Storage\StorageInterface                  $adapterName
 123      * @param  array|Traversable|Storage\Adapter\AdapterOptions $options
 124      * @return Storage\StorageInterface
 125      * @throws Exception\RuntimeException
 126      */
 127     public static function adapterFactory($adapterName, $options = array())
 128     {
 129         if ($adapterName instanceof Storage\StorageInterface) {
 130             // $adapterName is already an adapter object
 131             $adapter = $adapterName;
 132         } else {
 133             $adapter = static::getAdapterPluginManager()->get($adapterName);
 134         }
 135
 136         if ($options) {
 137             $adapter->setOptions($options);
 138         }
 139
 140         return $adapter;
 141     }
 142
 143     /**
 144      * Get the adapter plugin manager
 145      *
 146      * @return Storage\AdapterPluginManager
 147      */
 148     public static function getAdapterPluginManager()
 149     {
 150         if (static::$adapters === null) {
 151             static::$adapters = new Storage\AdapterPluginManager();
 152         }
 153         return static::$adapters;
 154     }
 155
 156     /**
 157      * Change the adapter plugin manager
 158      *
 159      * @param  Storage\AdapterPluginManager $adapters
 160      * @return void
 161      */
 162     public static function setAdapterPluginManager(Storage\AdapterPluginManager $adapters)
 163     {
 164         static::$adapters = $adapters;
 165     }
 166
 167     /**
 168      * Resets the internal adapter plugin manager
 169      *
 170      * @return void
 171      */
 172     public static function resetAdapterPluginManager()
 173     {
 174         static::$adapters = null;
 175     }
 176
 177     /**
 178      * Instantiate a storage plugin
 179      *
 180      * @param string|Storage\Plugin\PluginInterface     $pluginName
 181      * @param array|Traversable|Storage\Plugin\PluginOptions $options
 182      * @return Storage\Plugin\PluginInterface
 183      * @throws Exception\RuntimeException
 184      */
 185     public static function pluginFactory($pluginName, $options = array())
 186     {
 187         if ($pluginName instanceof Storage\Plugin\PluginInterface) {
 188             // $pluginName is already an plugin object
 189             $plugin = $pluginName;
 190         } else {
 191             $plugin = static::getPluginManager()->get($pluginName);
 192         }
 193
 194         if (!$options instanceof Storage\Plugin\PluginOptions) {
 195             $options = new Storage\Plugin\PluginOptions($options);
 196         }
 197
 198         if ($options) {
 199             $plugin->setOptions($options);
 200         }
 201
 202         return $plugin;
 203     }
 204
 205     /**
 206      * Get the plugin manager
 207      *
 208      * @return Storage\PluginManager
 209      */
 210     public static function getPluginManager()
 211     {
 212         if (static::$plugins === null) {
 213             static::$plugins = new Storage\PluginManager();
 214         }
 215         return static::$plugins;
 216     }
 217
 218     /**
 219      * Change the plugin manager
 220      *
 221      * @param  Storage\PluginManager $plugins
 222      * @return void
 223      */
 224     public static function setPluginManager(Storage\PluginManager $plugins)
 225     {
 226         static::$plugins = $plugins;
 227     }
 228
 229     /**
 230      * Resets the internal plugin manager
 231      *
 232      * @return void
 233      */
 234     public static function resetPluginManager()
 235     {
 236         static::$plugins = null;
 237     }
 238 }