PHP AbstractPluginManager::__construct方法代码示例

 /**
  * Constructor
  *
  * Overrides parent constructor in order to add the initializer methods injectFactory()
  * and callElementInit().
  *
  * @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($configInstanceOrParentLocator = null, array $v3config = [])
 {
     // Provide default initializers, ensuring correct order
     array_unshift($this->initializers, [$this, 'injectFactory']);
     array_push($this->initializers, [$this, 'callElementInit']);
     parent::__construct($configInstanceOrParentLocator, $v3config);
 }

 /**
  * 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'));
 }

 /**
  * @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']);
 }

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

 /**
  * 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);
 }

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

 /**
  * 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);
 }

 /**
  * 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);
 }

 /**
  * 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
     //);
 }

 /**
  * Constructor
  *
  * After invoking parent constructor, add an initializer to inject the
  * attached renderer and translator, if any, to the currently requested helper.
  *
  * @param  null|ConfigInterface $configuration
  */
 public function __construct(ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     $this->addInitializer(array($this, 'injectView'));
     if ($this->has('Navigation')) {
         $this->setInvokableClass('navigation', 'HumusMvc\\View\\Helper\\Navigation');
     }
 }

 /**
  * __construct
  *
  * @param ConfigInterface $configuration
  * @param Renderer\RendererInterface $renderer
  */
 public function __construct(ConfigInterface $configuration = null, Renderer\RendererInterface $renderer = null)
 {
     parent::__construct($configuration);
     if ($renderer) {
         $this->setRenderer($renderer);
     }
     $this->addInitializer([$this, 'injectRenderer'])->addInitializer([$this, 'injectTranslator'])->addInitializer([$this, 'callInit'], false);
 }

 /**
  * Ctor
  * @param ConfigInterface $configuration
  */
 public function __construct(ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     // FIXME: set its from config (not in the ctor)
     foreach ($this->invokableClasses as $key => $value) {
         $this->setInvokableClass($key, $value);
     }
     $this->addInitializer([$this, 'injectAdapter']);
 }

 /**
  * {@inheritdoc}
  */
 public function __construct(ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     if (!$configuration) {
         return;
     }
     Assertion::isInstanceOf($configuration, DataMapperManagerConfig::class);
     /* @var $configuration DataMapperManagerConfig */
     $this->entityDataMapperMap = $configuration->getEntityDataMapperMap();
 }

 /**
  * Constructor
  *
  * Add a default initializer to ensure the plugin is valid after instance
  * creation.
  *
  * Additionally, the constructor provides forwards compatibility with v3 by
  * overloading the initial argument. v2 usage expects either null or a
  * ConfigInterface instance, and will ignore any other arguments. v3 expects
  * a ContainerInterface instance, and will use an array of configuration to
  * seed the current instance with services. In most cases, you can ignore the
  * constructor unless you are writing a specialized factory for your plugin
  * manager or overriding it.
  *
  * @param null|ConfigInterface|ContainerInterface $configOrContainerInstance
  * @param array $v3config If $configOrContainerInstance is a container, this
  *     value will be passed to the parent constructor.
  * @throws Exception\InvalidArgumentException if $configOrContainerInstance
  *     is neither null, nor a ConfigInterface, nor a ContainerInterface.
  */
 public function __construct($configOrContainerInstance = null, array $v3config = [])
 {
     if (empty($v3config) && $configOrContainerInstance instanceof ContainerInterface) {
         $config = $configOrContainerInstance->get('Config');
         if (isset($config['migration_manager'])) {
             $v3config = $config['migration_manager'];
         }
     }
     parent::__construct($configOrContainerInstance, $v3config);
     $this->addInitializer([$this, 'dbAdapterInitializer'], false);
     $this->addInitializer([$this, 'consoleAdapterInitializer'], false);
 }