vendor/zendframework/zend-cache/src/PatternPluginManager.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-2016 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 Zend\ServiceManager\AbstractPluginManager;
  13 use Zend\ServiceManager\Factory\InvokableFactory;
  14 use Zend\ServiceManager\Exception\InvalidServiceException;
  15
  16 /**
  17  * Plugin manager implementation for cache pattern adapters
  18  *
  19  * Enforces that retrieved adapters are instances of
  20  * Pattern\PatternInterface. Additionally, it registers a number of default
  21  * patterns available.
  22  */
  23 class PatternPluginManager extends AbstractPluginManager
  24 {
  25     protected $aliases = [
  26         'callback' => Pattern\CallbackCache::class,
  27         'Callback' => Pattern\CallbackCache::class,
  28         'capture'  => Pattern\CaptureCache::class,
  29         'Capture'  => Pattern\CaptureCache::class,
  30         'class'    => Pattern\ClassCache::class,
  31         'Class'    => Pattern\ClassCache::class,
  32         'object'   => Pattern\ObjectCache::class,
  33         'Object'   => Pattern\ObjectCache::class,
  34         'output'   => Pattern\OutputCache::class,
  35         'Output'   => Pattern\OutputCache::class,
  36     ];
  37
  38     protected $factories = [
  39         Pattern\CallbackCache::class    => InvokableFactory::class,
  40         Pattern\CaptureCache::class     => InvokableFactory::class,
  41         Pattern\ClassCache::class       => InvokableFactory::class,
  42         Pattern\ObjectCache::class      => InvokableFactory::class,
  43         Pattern\OutputCache::class      => InvokableFactory::class,
  44
  45         // v2 normalized FQCNs
  46         'zendcachepatterncallbackcache' => InvokableFactory::class,
  47         'zendcachepatterncapturecache'  => InvokableFactory::class,
  48         'zendcachepatternclasscache'    => InvokableFactory::class,
  49         'zendcachepatternobjectcache'   => InvokableFactory::class,
  50         'zendcachepatternoutputcache'   => InvokableFactory::class,
  51     ];
  52
  53     /**
  54      * Don't share by default
  55      *
  56      * @var boolean
  57      */
  58     protected $shareByDefault = false;
  59
  60     /**
  61      * Don't share by default
  62      *
  63      * @var boolean
  64      */
  65     protected $sharedByDefault = false;
  66
  67     /**
  68      * @var string
  69      */
  70     protected $instanceOf = Pattern\PatternInterface::class;
  71
  72     /**
  73      * Override get to inject options as PatternOptions instance.
  74      *
  75      * {@inheritDoc}
  76      */
  77     public function get($plugin, array $options = [], $usePeeringServiceManagers = true)
  78     {
  79         if (empty($options)) {
  80             return parent::get($plugin, [], $usePeeringServiceManagers);
  81         }
  82
  83         $plugin = parent::get($plugin, [], $usePeeringServiceManagers);
  84         $plugin->setOptions(new Pattern\PatternOptions($options));
  85         return $plugin;
  86     }
  87
  88     /**
  89      * Override build to inject options as PatternOptions instance.
  90      *
  91      * {@inheritDoc}
  92      */
  93     public function build($plugin, array $options = null)
  94     {
  95         if (empty($options)) {
  96             return parent::build($plugin);
  97         }
  98
  99         $plugin = parent::build($plugin);
 100         $plugin->setOptions(new Pattern\PatternOptions($options));
 101         return $plugin;
 102     }
 103
 104     /**
 105      * Validate the plugin is of the expected type (v3).
 106      *
 107      * Validates against `$instanceOf`.
 108      *
 109      * @param mixed $instance
 110      * @throws InvalidServiceException
 111      */
 112     public function validate($instance)
 113     {
 114         if (! $instance instanceof $this->instanceOf) {
 115             throw new InvalidServiceException(sprintf(
 116                 '%s can only create instances of %s; %s is invalid',
 117                 get_class($this),
 118                 $this->instanceOf,
 119                 (is_object($instance) ? get_class($instance) : gettype($instance))
 120             ));
 121         }
 122     }
 123
 124     /**
 125      * Validate the plugin is of the expected type (v2).
 126      *
 127      * Proxies to `validate()`.
 128      *
 129      * @param mixed $plugin
 130      * @throws Exception\RuntimeException if invalid
 131      */
 132     public function validatePlugin($plugin)
 133     {
 134         try {
 135             $this->validate($plugin);
 136         } catch (InvalidServiceException $e) {
 137             throw new Exception\RuntimeException($e->getMessage(), $e->getCode(), $e);
 138         }
 139     }
 140 }