/**
* @return ServiceManager
*/
public function getServiceManager()
{
if (!$this->serviceManager) {
$this->serviceManager = $this->serviceLocator->getServiceLocator();
}
return $this->serviceManager;
}
/**
* 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;
}
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
//);
}
/**
* Override setInvokableClass().
*
* Performs normal operation, but also auto-aliases the class name to the
* service name. This ensures that providing the FQCN does not trigger an
* abstract factory later.
*
* @param string $name
* @param string $invokableClass
* @param null|bool $shared
* @return RoutePluginManager
*/
public function setInvokableClass($name, $invokableClass, $shared = null)
{
parent::setInvokableClass($name, $invokableClass, $shared);
if ($name != $invokableClass) {
$this->setAlias($invokableClass, $name);
}
return $this;
}
public function has($name, $checkAbstractFactories = true, $usePeeringServiceManagers = true)
{
if (is_string($name)) {
// internally called with an array [normalizedName, requestedName].
$this->incrementCallCount('has', $name);
}
return parent::has($name, $checkAbstractFactories, $usePeeringServiceManagers);
}
/**
* Converts the given value so that it can be hydrated by the hydrator.
*
* @param mixed $value The original value.
* @param array $data (optional) The original data for context.
* @return mixed Returns the value that should be hydrated.
*/
public function hydrate($value)
{
if ($value instanceof StateInterface) {
return $value;
}
if (is_string($value)) {
if ($this->checkPlugin() && $this->plugins->has($value)) {
return $this->plugins->get($value);
}
throw new \RuntimeException(sprintf('No service registered in %s with name %s', is_object($this->plugins) ? get_class($this->plugins) : gettype($this->plugins), $value));
}
if (empty($value) && $this->checkPlugin() && $this->plugins->has($this->firstStateName)) {
return $this->plugins->has($this->firstStateName);
}
// FIXME is correct? or exception
return $value;
}
/**
* 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');
}
}
/**
* @param string $sName
* @param mixed $oAssetFileFilter
* @param boolean $bShared
* @return \AssetsBundle\AssetFile\AssetFileFiltersManager
*/
public function setService($sName, $oAssetFileFilter, $bShared = true)
{
if ($oAssetFileFilter) {
$this->validatePlugin($oAssetFileFilter);
$oAssetFileFilter->setOptions($this->getOptions());
}
parent::setService($sName, $oAssetFileFilter, $bShared);
return $this;
}
/**
* 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']);
}
/**
* Override build to inject options as PatternOptions instance.
*
* {@inheritDoc}
*/
public function build($plugin, array $options = null)
{
if (empty($options)) {
return parent::build($plugin);
}
$plugin = parent::build($plugin);
$plugin->setOptions(new Pattern\PatternOptions($options));
return $plugin;
}
/**
* Attempt to create an instance via a factory
*
* @param string $canonicalName
* @param string $requestedName
* @return mixed
* @throws \Zend\ServiceManager\Exception\ServiceNotCreatedException If factory is not callable
*/
protected function createFromFactory($canonicalName, $requestedName)
{
$factory = $this->factories[$canonicalName];
if (is_string($factory) && class_exists($factory, true)) {
$factory = new $factory($this->creationOptions);
$this->factories[$canonicalName] = $factory;
}
return parent::createFromFactory($canonicalName, $requestedName);
}
/**
* {@inheritDoc}
*/
public function get($name, $options = [], $usePeeringServiceManagers = true)
{
try {
$instance = parent::get($name, $options, $usePeeringServiceManagers);
} catch (ServiceNotFoundException $e) {
$instance = new Fallback();
$instance->setServiceLocator($this->getServiceLocator());
}
return $instance;
}
/**
* {@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();
}
/**
* {@inheritDoc}
*/
public function get($name, $options = array(), $usePeeringServiceManagers = true)
{
$formElementManager = $this->getServiceLocator()->get('FormElementManager');
if ($formElementManager->has($name)) {
$form = $formElementManager->get($name);
if ($form instanceof FormInterface) {
return $form;
}
}
return parent::get($name, $options, $usePeeringServiceManagers);
}
/**
* 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);
}
/**
* Retrieve a service from the manager by name
*
* Allows passing an array of options to use when creating the instance.
* createFromInvokable() will use these and pass them to the instance
* constructor if not null and a non-empty array.
*
* @param string $name
* @param array $options
* @param bool $usePeeringServiceManagers
* @return object
* @throws InvalidPluginException
*/
public function get($name, $options = [], $usePeeringServiceManagers = true)
{
// If service not registered check the the Service Locator.
if (!$this->has($name)) {
return $this->getServiceLocator()->get($name);
}
if (isset($options['initialize'])) {
$this->initialize = $options['initialize'];
unset($options['initialize']);
}
$instance = parent::get($name, $options, $usePeeringServiceManagers);
$this->validatePlugin($instance);
return $instance;
}
/**
* 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->setFactory('identity', function ($helpers) {
$services = $helpers->getServiceLocator();
$helper = new Helper\Identity();
if (!$services->has('Zend\\Authentication\\AuthenticationService')) {
return $helper;
}
$helper->setAuthenticationService($services->get('Zend\\Authentication\\AuthenticationService'));
return $helper;
});
$this->addInitializer(array($this, 'injectRenderer'))->addInitializer(array($this, 'injectTranslator'));
}
public function __construct(ConfigInterface $configuration = null)
{
parent::__construct($configuration);
$this->addInitializer(function ($instance) {
if ($instance instanceof ServiceManagerAwareInterface) {
$instance->setServiceManager($this->getServiceLocator());
}
if (method_exists($instance, 'setRequest')) {
$instance->setRequest($this->getServiceLocator()->get('Request'));
}
if ($instance instanceof InitializableInterface) {
$instance->init();
}
});
}
