PHP ContainerBuilder::getInterfaceInjectors方法代码示例

 public function process(ContainerBuilder $container)
 {
     $this->parameterBag = $container->getParameterBag();
     foreach ($container->getDefinitions() as $definition) {
         $definition->setClass($this->resolveValue($definition->getClass()));
         $definition->setFile($this->resolveValue($definition->getFile()));
         $definition->setArguments($this->resolveValue($definition->getArguments()));
         $calls = array();
         foreach ($definition->getMethodCalls() as $name => $arguments) {
             $calls[$this->resolveValue($name)] = $this->resolveValue($arguments);
         }
         $definition->setMethodCalls($calls);
     }
     $aliases = array();
     foreach ($container->getAliases() as $name => $target) {
         $aliases[$this->resolveValue($name)] = $this->resolveValue($target);
     }
     $container->setAliases($aliases);
     $injectors = array();
     foreach ($container->getInterfaceInjectors() as $class => $injector) {
         $injector->setClass($this->resolveValue($injector->getClass()));
         $injectors[$this->resolveValue($class)] = $injector;
     }
     $container->setInterfaceInjectors($injectors);
     $parameterBag = $container->getParameterBag();
     foreach ($parameterBag->all() as $key => $value) {
         $parameterBag->set($key, $this->resolveValue($value));
     }
 }

 /**
  * {@inheritDoc}
  */
 public function process(ContainerBuilder $container)
 {
     foreach ($container->getDefinitions() as $definition) {
         foreach ($container->getInterfaceInjectors() as $injector) {
             if (null !== $definition->getFactoryService()) {
                 continue;
             }
             $defClass = $container->getParameterBag()->resolveValue($definition->getClass());
             $definition->setClass($defClass);
             if ($injector->supports($defClass)) {
                 $injector->processDefinition($definition);
             }
         }
     }
 }

 /**
  * {@inheritDoc}
  */
 public function process(ContainerBuilder $container)
 {
     foreach ($container->getDefinitions() as $definition) {
         $loaded = false;
         foreach ($container->getInterfaceInjectors() as $injector) {
             if (null !== $definition->getFactoryService()) {
                 continue;
             }
             if (false === $loaded && null !== $definition->getFile()) {
                 $loaded = true;
                 require_once $definition->getFile();
             }
             if ($injector->supports($definition->getClass())) {
                 $injector->processDefinition($definition);
             }
         }
     }
 }

 public function testLoadInterfaceInjectors()
 {
     $container = new ContainerBuilder();
     $loader = new ProjectLoader3($container, self::$fixturesPath . '/yaml');
     $loader->load('interfaces1.yml');
     $interfaces = $container->getInterfaceInjectors('FooClass');
     $this->assertEquals(1, count($interfaces), '->load() parses interfaces');
     $interface = $interfaces['FooClass'];
     $this->assertTrue($interface->hasMethodCall('setBar'), '->load() parses interfaces elements');
 }

 /**
  * @covers Symfony\Component\DependencyInjection\ContainerBuilder::addInterfaceInjector
  * @covers Symfony\Component\DependencyInjection\ContainerBuilder::addInterfaceInjectors
  * @covers Symfony\Component\DependencyInjection\ContainerBuilder::getInterfaceInjectors
  * @covers Symfony\Component\DependencyInjection\ContainerBuilder::hasInterfaceInjectorForClass
  * @covers Symfony\Component\DependencyInjection\ContainerBuilder::setDefinition
  */
 public function testInterfaceInjection()
 {
     $definition = new Definition('Symfony\\Tests\\Component\\DependencyInjection\\FooClass');
     $injectors[] = $this->getMockInterfaceInjector('Symfony\\Tests\\Component\\DependencyInjection\\FooClass', 1);
     $injectors[] = $this->getMockInterfaceInjector('Symfony\\Tests\\Component\\DependencyInjection\\FooClass', 0);
     $container = new ContainerBuilder();
     $container->addInterfaceInjectors($injectors);
     $this->assertEquals(1, count($container->getInterfaceInjectors('Symfony\\Tests\\Component\\DependencyInjection\\FooClass')));
     $this->assertTrue($container->hasInterfaceInjectorForClass('Symfony\\Tests\\Component\\DependencyInjection\\FooClass'));
     $this->assertFalse($container->hasInterfaceInjectorForClass('\\Foo'));
     $container->setDefinition('test', $definition);
     $test = $container->get('test');
 }

 /**
  * Merges a ContainerBuilder with the current ContainerBuilder configuration.
  *
  * Service definitions overrides the current defined ones.
  *
  * But for parameters, they are overridden by the current ones. It allows
  * the parameters passed to the container constructor to have precedence
  * over the loaded ones.
  *
  * $container = new ContainerBuilder(array('foo' => 'bar'));
  * $loader = new LoaderXXX($container);
  * $loader->load('resource_name');
  * $container->register('foo', new stdClass());
  *
  * In the above example, even if the loaded resource defines a foo
  * parameter, the value will still be 'bar' as defined in the ContainerBuilder
  * constructor.
  */
 public function merge(ContainerBuilder $container)
 {
     if (true === $this->isFrozen()) {
         throw new \LogicException('Cannot merge on a frozen container.');
     }
     $this->addDefinitions($container->getDefinitions());
     $this->addAliases($container->getAliases());
     $this->addInterfaceInjectors($container->getInterfaceInjectors());
     $this->parameterBag->add($container->getParameterBag()->all());
     foreach ($container->getResources() as $resource) {
         $this->addResource($resource);
     }
     foreach ($container->getExtensionConfigs() as $name => $configs) {
         if (isset($this->extensionConfigs[$name])) {
             $this->extensionConfigs[$name] = array_merge($this->extensionConfigs[$name], $configs);
         } else {
             $this->extensionConfigs[$name] = $configs;
         }
     }
 }

 public function testLoadInterfaceInjectors()
 {
     $container = new ContainerBuilder();
     $loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath . '/xml'));
     $loader->load('interfaces1.xml');
     $interfaces = $container->getInterfaceInjectors('FooClass');
     $this->assertEquals(1, count($interfaces), '->load() parses <interface> elements');
     $interface = $interfaces['FooClass'];
     $this->assertTrue($interface->hasMethodCall('setBar'), '->load() applies method calls correctly');
 }