PHP ServiceManager\AbstractPluginManager类代码示例

 /**
  * Given a Zend Framework Plugin Manager, initialize the instance.
  *
  * @param object                                     $instance Instance to
  * initialize
  * @param \Zend\ServiceManager\AbstractPluginManager $manager  Plugin manager
  *
  * @return object
  */
 public static function initZendPlugin($instance, \Zend\ServiceManager\AbstractPluginManager $manager)
 {
     $sm = $manager->getServiceLocator();
     if (null !== $sm) {
         static::initInstance($instance, $sm);
     }
     return $instance;
 }

 /**
  * @return ServiceManager
  */
 public function getServiceManager()
 {
     if (!$this->serviceManager) {
         $this->serviceManager = $this->serviceLocator->getServiceLocator();
     }
     return $this->serviceManager;
 }

 public function __construct(\Zend\ServiceManager\ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     $this->setInvokableClass(self::GENERATOR_HUMAN, self::GENERATOR_HUMAN);
     $this->setInvokableClass(self::GENERATOR_HYBRID, self::GENERATOR_HYBRID);
     $this->setInvokableClass(self::GENERATOR_COMPUTER, self::GENERATOR_COMPUTER);
     $this->addInitializer(function (PasswordGeneratorInterface $instance, PluginManager $pm) {
         /* @var $options \XelaxPasswordGeneratorModule\Options\GeneratorOptions */
         $generatorOptions = $pm->getServiceLocator()->get('XelaxPasswordGeneratorModule\\Options\\Generator');
         $options = array();
         if (isset($generatorOptions->getGeneratorOptions()[get_class($instance)])) {
             $options = $generatorOptions->getGeneratorOptions()[get_class($instance)];
         }
         if (!empty($options['options'])) {
             foreach ($options['options'] as $key => $value) {
                 $instance->setOptionValue($key, $value);
             }
         }
         if (!empty($options['parameters'])) {
             foreach ($options['parameters'] as $key => $value) {
                 $instance->setParameter($key, $value);
             }
         }
     });
 }

 public function __construct(ConfigInterface $config = null)
 {
     parent::__construct($config);
     foreach ($this->filters as $filterName => $filterClass) {
         $this->setInvokableClass($filterName, $filterClass);
     }
 }

 /**
  * Override: do not use peering service managers
  *
  * @param  string $name
  * @param  array $options
  * @param  bool $usePeeringServiceManagers
  * @return mixed
  */
 public function get($name, $options = [], $usePeeringServiceManagers = false)
 {
     if (is_string($options)) {
         $options = ['class_name' => $options];
     }
     return parent::get($name, $options, $usePeeringServiceManagers);
 }

 /**
  * {@inheritDoc}
  */
 public function __construct(ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     $this->addInitializer(function ($instance, $serviceLocator) {
         $instance->setServiceLocator($serviceLocator->getServiceLocator());
     }, false);
 }

 public function get($name, $options = array(), $usePeeringServiceManagers = true)
 {
     $plugin = parent::get($name, $options, $usePeeringServiceManagers);
     $plugin->setConfig($this->getConfig()->{$name});
     $plugin->setObjectManager($this->getObjectManager());
     return $plugin;
 }

 /**
  * Creates an instance.
  *
  * Adds two default initializers:
  * - Inject the translator to mails implementing TranslatorAwareInterface
  * - Call init() method on Mails if such method exists.
  *
  * @param ConfigInterface $configuration
  */
 public function __construct(ServiceLocatorInterface $serviceLocator, ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     $this->serviceLocator = $serviceLocator;
     $self = $this;
     $this->addInitializer(function ($instance) use($self) {
         if ($instance instanceof TranslatorAwareInterface) {
             $translator = $self->getServiceLocator()->get('translator');
             $instance->setTranslator($translator);
             if (null === $instance->getTranslatorTextDomain()) {
                 $instance->setTranslatorTextDomain();
             }
             $instance->setTranslatorEnabled(true);
         }
     }, false);
     $this->addInitializer(function ($instance) {
         if (method_exists($instance, 'setServiceLocator')) {
             $instance->setServiceLocator($this);
         }
     }, false);
     $this->addInitializer(function ($instance) {
         if (method_exists($instance, 'init')) {
             $instance->init();
         }
     }, false);
 }

    /**
     * Retrieve a registered instance
     *
     * After the plugin is retrieved from the service locator, inject the
     * controller in the plugin every time it is requested. This is required
     * because a controller can use a plugin and another controller can be
     * dispatched afterwards. If this second controller uses the same plugin
     * as the first controller, the reference to the controller inside the
     * plugin is lost.
     *
     * @param  string $name
     * @param  mixed  $options
     * @param  bool   $usePeeringServiceManagers
     * @return mixed
     */
    public function get($name, $options = array(), $usePeeringServiceManagers = true)
    {
        $plugin = parent::get($name, $options, $usePeeringServiceManagers);
        $this->injectController($plugin);

        return $plugin;
    }

 /**
  * Constructor
  *
  * Merges provided configuration with default configuration.
  *
  * Adds initializers to inject the attached renderer and translator, if
  * any, to the currently requested helper.
  *
  * @param null|ConfigInterface|ContainerInterface $configOrContainerInstance
  * @param array $v3config If $configOrContainerInstance is a container, this
  *     value will be passed to the parent constructor.
  */
 public function __construct($configOrContainerInstance = null, array $v3config = [])
 {
     $this->initializers[] = [$this, 'injectRenderer'];
     $this->initializers[] = [$this, 'injectTranslator'];
     $this->initializers[] = [$this, 'injectEventManager'];
     parent::__construct($configOrContainerInstance, $v3config);
 }

 /**
  * Creates an instance.
  *
  * {@inheritDoc}
  *
  * Adds an additional initializer to inject an event manager to assertions
  * implementing {@link EventManagerAwareInterface}.
  *
  */
 public function __construct(ServiceLocatorInterface $serviceLocator, ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     $this->serviceLocator = $serviceLocator;
     // Pushing to bottom of stack to ensure this is done last
     $this->addInitializer(array($this, 'injectEventManager'), false);
 }

 /**
  * @param null $configOrContainerInstance
  * @param array $v3config
  */
 public function __construct($configOrContainerInstance = null, array $v3config = [])
 {
     parent::__construct($configOrContainerInstance, $v3config);
     $this->addInitializer([$this, 'injectDbAdapter']);
     $this->addInitializer([$this, 'injectHydrator']);
     $this->addInitializer([$this, 'injectModel']);
 }

 /**
  * Constructor
  *
  * After invoking parent constructor, add an initializer to inject the
  * attached renderer and translator, if any, to the currently requested helper.
  *
  * @param null $configuration
  */
 public function __construct($configuration = null)
 {
     parent::__construct(null);
     Config::has('jquery', $configuration);
     $this->config = new Config($configuration['jquery'], $this->invokableClasses);
     $this->addInitializer(array($this, 'injectConfig'));
 }

 /**
  * @inheritdoc
  *
  * @param string $name
  * @param array $options
  * @param bool $usePeeringServiceManagers
  * @return JobInterface
  */
 public function get($name, $options = [], $usePeeringServiceManagers = true)
 {
     // parent::get calls validatePlugin() so we're sure $instance is a JobInterface
     $instance = parent::get($name, $options, $usePeeringServiceManagers);
     $instance->setMetadata('__name__', $name);
     return $instance;
 }

 /**
  * Constructor
  *
  * Make sure table gateways are properly initialized.
  *
  * @param ConfigInterface $configuration Configuration settings (optional)
  */
 public function __construct(ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     //todo: do we need an Initializer
     //$this->addInitializer(
     //    ['VuFind\ServiceManager\Initializer', 'initPlugin'], false
     //);
 }