PHP DefinitionDecorator::setArguments方法代碼示例

 /**
  * @expectedException \OutOfBoundsException
  */
 public function testGetArgumentShouldCheckBounds()
 {
     $def = new DefinitionDecorator('foo');
     $def->setArguments(array(0 => 'foo'));
     $def->replaceArgument(0, 'foo');
     $def->getArgument(1);
 }

 public function process(ContainerBuilder $container)
 {
     if (!($container->hasDefinition('fragment.listener') && $container->hasDefinition('ezpublish.decorated_fragment_renderer'))) {
         return null;
     }
     $fragmentListenerDef = $container->findDefinition('fragment.listener');
     $fragmentListenerDef->setFactoryService('ezpublish.fragment_listener.factory')->setFactoryMethod('buildFragmentListener')->addArgument('%fragment.listener.class%');
     // Looping over all fragment renderers to decorate them
     // This is to make sure they are siteaccess aware (siteaccess is serialized in rendered path).
     foreach ($container->findTaggedServiceIds('kernel.fragment_renderer') as $id => $attributes) {
         $renamedId = "{$id}.inner";
         $definition = $container->getDefinition($id);
         $public = $definition->isPublic();
         $tags = $definition->getTags();
         $definition->setPublic(false);
         $container->setDefinition($renamedId, $definition);
         $decoratedDef = new DefinitionDecorator('ezpublish.decorated_fragment_renderer');
         $decoratedDef->setArguments(array(new Reference($renamedId)));
         $decoratedDef->setPublic($public);
         $decoratedDef->setTags($tags);
         // Special treatment for inline fragment renderer, to fit ESI renderer constructor type hinting (forced to InlineFragmentRenderer)
         if ($id === 'fragment.renderer.inline') {
             $decoratedDef->setClass($container->getParameter('ezpublish.decorated_fragment_renderer.inline.class'));
         }
         $container->setDefinition($id, $decoratedDef);
     }
 }

 /**
  * @param array            $config
  * @param ContainerBuilder $container
  */
 private function loadArrayFormType(ContainerBuilder $container, array $config)
 {
     $serviceId = 'jd_form.form_type.array';
     $types = ['hidden', 'text'];
     foreach ($types as $type) {
         $typeDef = new DefinitionDecorator($serviceId);
         $typeDef->setArguments([$type, $config['delimiter']])->addTag('form.type', ['alias' => 'array_' . $type]);
         $container->setDefinition($serviceId . '_' . $type, $typeDef);
     }
 }

 private function configureConnectionClient(ContainerBuilder $builder, $connectionName, array $connectionConfig, $profiling)
 {
     $connectionDef = new DefinitionDecorator('kassko_cassandra.connection.prototype');
     $connectionDef->addTag('kassko_cassandra.connection');
     //logger Cql creation.
     $loggerCqlServiceName = $this->computeLoggerCqlServiceName($connectionName);
     $loggerCqlServiceDef = new DefinitionDecorator('kassko_cassandra.logger_cql.prototype');
     if (isset($connectionConfig['logger_service'])) {
         $loggerCqlServiceDef->replaceArgument(0, new Reference($connectionConfig['logger_service']));
     }
     $builder->setDefinition($loggerCqlServiceName, $loggerCqlServiceDef);
     //loggerChain creation.
     $loggerChainServiceName = $this->computeLoggerChainServiceName($connectionName);
     $loggerChainDef = new DefinitionDecorator('kassko_cassandra.logger_chain.prototype');
     $builder->setDefinition($loggerChainServiceName, $loggerChainDef);
     $loggerChainDef->addMethodCall('addLogger', [new Reference($loggerCqlServiceName)]);
     if ($profiling) {
         $loggerProfilerServiceName = $this->computeLoggerProfilerServiceName($connectionName);
         $builder->setDefinition($loggerProfilerServiceName, new DefinitionDecorator('kassko_cassandra.logger_profiler.prototype'));
         $loggerChainDef->addMethodCall('addLogger', [new Reference($loggerProfilerServiceName)]);
         $queryStatsManagerDef = $builder->getDefinition('kassko_cassandra.query_stats.manager');
         $queryStatsManagerDef->addMethodCall('addLogger', [$connectionName, new Reference($loggerProfilerServiceName)]);
     }
     if (isset($connectionConfig['event_dispatcher_service'])) {
         $connectionDef->addMethodCall('setEventDispatcher', [new Reference($connectionConfig['event_dispatcher_service'])]);
     }
     $connectionDef->addMethodCall('setLogger', [new Reference($loggerChainServiceName)]);
     $connectionDef->addMethodCall('useKeyspace', [$connectionConfig['keyspace']]);
     list($dsn, $username, $password) = $this->resolveConnectionParam($connectionConfig);
     if (null === $username xor null === $password) {
         throw new \LogicException(sprintf('username and password should be provided both or neither for keyspace "%s".', $connectionConfig['keyspace']));
     }
     if (null !== $username) {
         $connectionDef->setArguments([$dsn, $username, $password]);
     } else {
         $connectionDef->setArguments([$dsn]);
     }
     $serviceName = $this->computeServiceName($connectionName);
     $builder->setDefinition($serviceName, $connectionDef);
     if (isset($connectionConfig['alias'])) {
         $builder->setAlias($connectionConfig['alias'], $serviceName);
     }
 }

 /**
  * Converts class hierarchy metadata to definition instances.
  *
  * @param ClassHierarchyMetadata $metadata
  * @return array an array of Definition instances
  */
 public function convert(ClassHierarchyMetadata $metadata)
 {
     static $count = 0;
     $definitions = array();
     $previous = null;
     foreach ($metadata->classMetadata as $classMetadata) {
         if (null === $previous && null === $classMetadata->parent) {
             $definition = new Definition();
         } else {
             $definition = new DefinitionDecorator($classMetadata->parent ?: $previous->id);
         }
         $definition->setClass($classMetadata->name);
         if (null !== $classMetadata->scope) {
             $definition->setScope($classMetadata->scope);
         }
         if (null !== $classMetadata->public) {
             $definition->setPublic($classMetadata->public);
         }
         if (null !== $classMetadata->abstract) {
             $definition->setAbstract($classMetadata->abstract);
         }
         if (null !== $classMetadata->lazy) {
             $definition->setLazy($classMetadata->lazy);
         }
         if (null !== $classMetadata->arguments) {
             $definition->setArguments($classMetadata->arguments);
         }
         $definition->setMethodCalls($classMetadata->methodCalls);
         $definition->setTags($classMetadata->tags);
         $definition->setProperties($classMetadata->properties);
         if (null !== $classMetadata->decorates) {
             if (!method_exists($definition, 'setDecoratedService')) {
                 throw new InvalidAnnotationException(sprintf("decorations require symfony >=2.8 on class %s", $classMetadata->name));
             }
             $definition->setDecoratedService($classMetadata->decorates, $classMetadata->decoration_inner_name);
         }
         if (null !== $classMetadata->deprecated && method_exists($definition, 'setDeprecated')) {
             $definition->setDeprecated(true, $classMetadata->deprecated);
         }
         if (null === $classMetadata->id) {
             $classMetadata->id = '_jms_di_extra.unnamed.service_' . $count++;
         }
         if (0 !== count($classMetadata->initMethods)) {
             foreach ($classMetadata->initMethods as $initMethod) {
                 $definition->addMethodCall($initMethod);
             }
         } elseif (null !== $classMetadata->initMethod) {
             @trigger_error('ClassMetadata::$initMethod is deprecated since version 1.7 and will be removed in 2.0. Use ClassMetadata::$initMethods instead.', E_USER_DEPRECATED);
             $definition->addMethodCall($classMetadata->initMethod);
         }
         $definitions[$classMetadata->id] = $definition;
         $previous = $classMetadata;
     }
     return $definitions;
 }

 public function definitionProvider()
 {
     $definitionWithNoArguments = new Definition();
     $definitionWithArguments = new Definition();
     $rightValue = 'the right value';
     $wrongValue = 'the wrong value';
     $arguments = array(0 => 'first argument', 1 => $rightValue);
     $definitionWithArguments->setArguments($arguments);
     $decoratedDefinitionWithArguments = new DefinitionDecorator('parent_service_id');
     $decoratedDefinitionWithArguments->setArguments(array(0 => 'first argument', 1 => $wrongValue));
     $decoratedDefinitionWithArguments->replaceArgument(1, $rightValue);
     return array(array($definitionWithNoArguments, 1, $rightValue, false), array($definitionWithNoArguments, 1, $wrongValue, false), array($definitionWithArguments, 1, $rightValue, true), array($decoratedDefinitionWithArguments, 1, $rightValue, true));
 }

 public function load(array $configs, ContainerBuilder $container)
 {
     $configuration = new Configuration();
     $config = $this->processConfiguration($configuration, $configs);
     $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
     $loader->load('services.yml');
     if (empty($config['default_connection'])) {
         $keys = array_keys($config['connections']);
         $config['default_connection'] = reset($keys);
     }
     $connections = [];
     foreach ($config['connections'] as $name => $connectionOptions) {
         $connections[$name] = sprintf('sirian.sphinx.%s_connection', $name);
         $connectionDefinition = new DefinitionDecorator('sirian.sphinx.connection');
         $connectionDefinition->setArguments([$connectionOptions]);
         $container->setDefinition($connections[$name], $connectionDefinition);
     }
     $container->setParameter('sirian.sphinx.default_connection', $config['default_connection']);
     $container->setParameter('sirian.sphinx.connections', $connections);
 }

 /**
  * Converts class hierarchy metadata to definition instances.
  *
  * @param ClassHierarchyMetadata $metadata
  * @return array an array of Definition instances
  */
 public function convert(ClassHierarchyMetadata $metadata)
 {
     static $count = 0;
     $definitions = array();
     $previous = null;
     foreach ($metadata->classMetadata as $classMetadata) {
         if (null === $previous && null === $classMetadata->parent) {
             $definition = new Definition();
         } else {
             $definition = new DefinitionDecorator($classMetadata->parent ?: $previous->id);
         }
         $definition->setClass($classMetadata->name);
         if (null !== $classMetadata->scope) {
             $definition->setScope($classMetadata->scope);
         }
         if (null !== $classMetadata->public) {
             $definition->setPublic($classMetadata->public);
         }
         if (null !== $classMetadata->abstract) {
             $definition->setAbstract($classMetadata->abstract);
         }
         if (null !== $classMetadata->arguments) {
             $definition->setArguments($classMetadata->arguments);
         }
         $definition->setMethodCalls($classMetadata->methodCalls);
         $definition->setTags($classMetadata->tags);
         $definition->setProperties($classMetadata->properties);
         if (null === $classMetadata->id) {
             $classMetadata->id = '_jms_di_extra.unnamed.service_' . $count++;
         }
         if ($classMetadata->initMethod) {
             if (!method_exists($definition, 'setInitMethod')) {
                 throw new \RuntimeException(sprintf('@AfterSetup is not available on your Symfony version.'));
             }
             $definition->setInitMethod($classMetadata->initMethod);
         }
         $definitions[$classMetadata->id] = $definition;
         $previous = $classMetadata;
     }
     return $definitions;
 }

 /**
  * @throws \LogicException
  */
 public function generate()
 {
     $definition = new DefinitionDecorator('phpmentors_pageflower.reflection_conversational_controller');
     $definition->setArguments(array($this->controllerClass->getName()));
     foreach ($this->controllerClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
         /* @var $method \ReflectionMethod */
         if ($method->getDeclaringClass()->getName() == $this->controllerClass->getName()) {
             foreach ($this->reader->getMethodAnnotations($method) as $annotation) {
                 if ($annotation instanceof Init) {
                     $definition->addMethodCall('addInitMethod', array($method->getName()));
                 } elseif ($annotation instanceof Accept) {
                     if ($annotation->value === null || is_string($annotation->value) && strlen($annotation->value) == 0) {
                         throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($annotation)));
                     }
                     foreach ((array) $annotation->value as $accept) {
                         if ($accept === null || strlen($accept) == 0) {
                             throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($annotation)));
                         }
                         if (!in_array($accept, $this->states)) {
                             throw new \LogicException(sprintf('The value for annotation "%s" must be a one of [ %s ], "%s" is specified.', 'PHPMentors\\PageflowerBundle\\Annotation\\Accept', implode(', ', $this->states), $accept));
                         }
                         $definition->addMethodCall('addAcceptableState', array($method->getName(), $accept));
                     }
                 }
             }
         }
     }
     foreach ($this->controllerClass->getProperties() as $property) {
         /* @var $property \ReflectionProperty */
         if ($property->getDeclaringClass()->getName() == $this->controllerClass->getName() && !$property->isStatic()) {
             foreach ($this->reader->getPropertyAnnotations($property) as $annotation) {
                 $definition->addMethodCall('addStatefulProperty', array($property->getName()));
             }
         }
     }
     $reflectionConversationalControllerServiceId = 'phpmentors_pageflower.reflection_conversational_controller.' . $this->controllerServiceId;
     $this->container->setDefinition($reflectionConversationalControllerServiceId, $definition);
     $this->container->getDefinition('phpmentors_pageflower.reflection_conversational_controller_repository')->addMethodCall('add', array(new Reference($reflectionConversationalControllerServiceId)));
 }

 /**
  * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
  * @param string $providerKey
  * @param array config
  * @param string $facebookAdapterId
  * @return string
  */
 public function createListener(ContainerBuilder $container, $providerKey, array $config, $facebookAdapterId)
 {
     $listenerId = FacebookAuthenticationExtension::CONTAINER_SERVICE_ID_SECURITY_FIREWALL_LISTENER;
     $listener = new DefinitionDecorator($listenerId);
     $listener->setArguments([new Reference('security.context'), new Reference('security.authentication.manager'), new Reference('security.authentication.session_strategy'), new Reference('security.http_utils'), $providerKey, new Reference($config[self::CONFIG_NODE_NAME_AUTHENTICATION_SUCCESS_HANDLER]), new Reference($config[self::CONFIG_NODE_NAME_AUTHENTICATION_FAILURE_HANDLER]), $config, $container->has('logger') ? new Reference('logger') : null, new Reference('event_dispatcher')]);
     $listener->addMethodCall('setFacebookAdapter', [new Reference($facebookAdapterId)]);
     $listenerId = $this->namespaceServiceId($listenerId, $providerKey);
     $container->setDefinition($listenerId, $listener);
     return $listenerId;
 }

 /**
  * Configures the basic auth subscriber definition.
  *
  * @param \Symfony\Component\DependencyInjection\Definition       $subscriber  The subscriber.
  * @param array                                                   $basicAuth   The basic auth.
  * @param string                                                  $adapterName The adapter name.
  * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container   The container.
  */
 private function configureBasicAuthSubscriberDefinition(Definition $subscriber, array $basicAuth, $adapterName, ContainerBuilder $container)
 {
     $model = new DefinitionDecorator(self::createServiceName('subscriber.basic_auth.model'));
     $model->setArguments(array($basicAuth['username'], $basicAuth['password']));
     if (isset($basicAuth['matcher'])) {
         $model->addArgument($basicAuth['matcher']);
     }
     $container->setDefinition($service = self::createServiceName($adapterName . '.basic_auth.model'), $model);
     $subscriber->setArguments(array(new Reference($service)));
 }

 /**
  * @throws \LogicException
  */
 public function generate()
 {
     $pageflowAnnotation = $this->reader->getClassAnnotation($this->controllerClass, 'PHPMentors\\PageflowerBundle\\Annotation\\Pageflow');
     if ($pageflowAnnotation === null) {
         throw new \LogicException(sprintf('Annotation "%s" is not found in class "%s".', 'PHPMentors\\PageflowerBundle\\Annotation\\Pageflow', $this->controllerClass->getName()));
     }
     $pageflowBuilderDefinition = new DefinitionDecorator('phpmentors_pageflower.pageflow_builder');
     $pageflowBuilderDefinition->setArguments(array($this->controllerServiceId));
     $statesFound = false;
     $transitionsFound = false;
     foreach ($pageflowAnnotation->value as $annotation) {
         if ($annotation instanceof States) {
             if ($statesFound) {
                 throw new \LogicException(sprintf('Annotation "%s" must be specified only once.', get_class($annotation)));
             }
             $statesFound = true;
             foreach ($annotation->value as $state) {
                 if ($state instanceof AnnotationInterface) {
                     if ($state->value === null || strlen($state->value) == 0) {
                         throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($state)));
                     }
                     if ($state instanceof Start) {
                         $pageflowBuilderDefinition->addMethodCall('addState', array($state->value));
                         $pageflowBuilderDefinition->addMethodCall('setStartState', array($state->value));
                         $this->states[] = $state->value;
                     } elseif ($state instanceof End) {
                         $pageflowBuilderDefinition->addMethodCall('addState', array($state->value));
                         $pageflowBuilderDefinition->addMethodCall('setEndState', array($state->value, StateInterface::STATE_FINAL));
                         $this->states[] = $state->value;
                     } else {
                         throw new \LogicException(sprintf('State "%s" must be encapsulated with one of [ %s ], "%s" is specified.', $state->value, implode(', ', array('PHPMentors\\PageflowerBundle\\Annotation\\Start', 'PHPMentors\\PageflowerBundle\\Annotation\\End')), get_class($state)));
                     }
                 } else {
                     if ($state === null || strlen($state) == 0) {
                         throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($annotation)));
                     }
                     $pageflowBuilderDefinition->addMethodCall('addState', array($state));
                     $this->states[] = $state;
                 }
             }
         } elseif ($annotation instanceof Transitions) {
             if ($transitionsFound) {
                 throw new \LogicException(sprintf('Annotation "%s" must be specified only once.', get_class($annotation)));
             }
             $transitionsFound = true;
             foreach ($annotation->value as $transition) {
                 if (is_array($transition) && count($transition) == 2 && is_string($transition[0]) && is_string($transition[1])) {
                     foreach (array($transition[0], $transition[1]) as $state) {
                         if ($state === null || strlen($state) == 0) {
                             throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($annotation)));
                         }
                         if (!in_array($state, $this->states)) {
                             throw new \LogicException(sprintf('The value for annotation "%s" must be one of [ %s ], "%s" is specified.', get_class($annotation), implode(', ', $this->states), $state));
                         }
                     }
                     $pageflowBuilderDefinition->addMethodCall('addTransition', array($transition[0], $transition[1], $transition[1]));
                 } else {
                     throw new \LogicException(sprintf('The value for annotation "%s" must be string array, "%s" is specified.', get_class($annotation), var_export($transition, true)));
                 }
             }
         } else {
             throw new \LogicException(sprintf('The value for annotation "%s" must be one of [ %s ], "%s" is specified.', get_class($pageflowAnnotation), implode(', ', array('"PHPMentors\\PageflowerBundle\\Annotation\\States"', '"PHPMentors\\PageflowerBundle\\Annotation\\Transitions"')), is_object($annotation) ? get_class($annotation) : $annotation));
         }
     }
     $pageflowBuilderServiceId = 'phpmentors_pageflower.pageflow_builder.' . $this->controllerServiceId;
     $this->container->setDefinition($pageflowBuilderServiceId, $pageflowBuilderDefinition);
     $pageflowDefinition = new DefinitionDecorator('phpmentors_pageflower.pageflow');
     $pageflowDefinition->setFactoryService($pageflowBuilderServiceId);
     $pageflowServiceId = 'phpmentors_pageflower.pageflow.' . $this->controllerServiceId;
     $this->container->setDefinition($pageflowServiceId, $pageflowDefinition);
     $this->container->getDefinition('phpmentors_pageflower.pageflow_repository')->addMethodCall('add', array(new Reference($pageflowServiceId)));
     $this->container->addClassResource($this->controllerClass);
 }

 private function createCollectionDefinition($model, $type, $options, ContainerBuilder $container)
 {
     $collection = new DefinitionDecorator('lyra_admin.action_collection');
     $collection->setArguments(array($options))->setPublic(false);
     $container->setDefinition(sprintf('lyra_admin.%s.%s.collection', $model, $type), $collection);
 }

 /**
  * Configure a mapping from a filesystem path to a RequireJS namespace.
  * @param string $location
  * @param string $path
  * @param ContainerBuilder $container
  * @param boolean $generateAssets
  */
 protected function addNamespaceMapping($location, $path, ContainerBuilder $container, $generateAssets = true)
 {
     $location = $this->getRealPath($location, $container);
     // Register the namespace with the configuration
     $mapping = $container->getDefinition('hearsay_require_js.namespace_mapping');
     $mapping->addMethodCall('registerNamespace', array($path, $location));
     $config = $container->getDefinition('hearsay_require_js.configuration_builder');
     $config->addMethodCall('setPath', array($path, $location));
     if ($path && $container->hasDefinition('hearsay_require_js.optimizer_filter')) {
         $filter = $container->getDefinition('hearsay_require_js.optimizer_filter');
         $filter->addMethodCall('addPath', array($path, preg_replace('~\\.js$~', '', $location)));
     }
     if ($generateAssets) {
         $resource = new DefinitionDecorator('hearsay_require_js.filenames_resource');
         $resource->setArguments(array($location));
         $resource->addTag('assetic.formula_resource', array('loader' => 'require_js'));
         $container->addDefinitions(array('hearsay_require_js.filenames_resource.' . md5($location) => $resource));
     }
 }