PHP ContainerBuilder::setResourceTracking方法代码示例

 /**
  * @return SymfonyContainerBuilder
  */
 public function compile()
 {
     $this->registerServices($this->parameters['services']);
     $this->builder->setResourceTracking(false);
     $this->builder->compile();
     return $this->builder;
 }

 public function __construct()
 {
     $this->_delegateContainerBuilder = new \Symfony\Component\DependencyInjection\ContainerBuilder();
     parent::__construct($this->_delegateContainerBuilder);
     /**
      * Turn off resource tracking.
      */
     $this->_delegateContainerBuilder->setResourceTracking(false);
     /**
      * Add ourself as the first compiler pass.
      */
     $this->_tubePressCompilerPasses[] = $this;
 }

 /**
  * {@inheritdoc}
  */
 public function process(ContainerBuilder $container)
 {
     $parameters = $container->getParameterBag()->all();
     $definitions = $container->getDefinitions();
     $aliases = $container->getAliases();
     $exprLangProviders = $container->getExpressionLanguageProviders();
     foreach ($container->getExtensions() as $extension) {
         if ($extension instanceof PrependExtensionInterface) {
             $extension->prepend($container);
         }
     }
     foreach ($container->getExtensions() as $name => $extension) {
         if (!($config = $container->getExtensionConfig($name))) {
             // this extension was not called
             continue;
         }
         $config = $container->getParameterBag()->resolveValue($config);
         $tmpContainer = new ContainerBuilder($container->getParameterBag());
         $tmpContainer->setResourceTracking($container->isTrackingResources());
         $tmpContainer->addObjectResource($extension);
         foreach ($exprLangProviders as $provider) {
             $tmpContainer->addExpressionLanguageProvider($provider);
         }
         $extension->load($config, $tmpContainer);
         $container->merge($tmpContainer);
         $container->getParameterBag()->add($parameters);
     }
     $container->addDefinitions($definitions);
     $container->addAliases($aliases);
 }

    public function testDumpOptimizationString()
    {
        $definition = new Definition();
        $definition->setClass('stdClass');
        $definition->addArgument(array(
            'only dot' => '.',
            'concatenation as value' => '.\'\'.',
            'concatenation from the start value' => '\'\'.',
            '.' => 'dot as a key',
            '.\'\'.' => 'concatenation as a key',
            '\'\'.' => 'concatenation from the start key',
            'optimize concatenation' => 'string1%some_string%string2',
            'optimize concatenation with empty string' => 'string1%empty_value%string2',
            'optimize concatenation from the start' => '%empty_value%start',
            'optimize concatenation at the end' => 'end%empty_value%',
        ));

        $container = new ContainerBuilder();
        $container->setResourceTracking(false);
        $container->setDefinition('test', $definition);
        $container->setParameter('empty_value', '');
        $container->setParameter('some_string', '-');
        $container->compile();

        $dumper = new PhpDumper($container);
        $this->assertStringEqualsFile(self::$fixturesPath.'/php/services10.php', $dumper->dump(), '->dump() dumps an empty container as an empty PHP class');
    }

 public function testProcessInlinesWhenThereAreMultipleReferencesButFromTheSameDefinition()
 {
     $container = new ContainerBuilder();
     $container->setResourceTracking(false);
     $container->register('a', '\\stdClass')->addArgument(new Reference('b'))->addMethodCall('setC', array(new Reference('c')));
     $container->register('b', '\\stdClass')->addArgument(new Reference('c'))->setPublic(false);
     $container->register('c', '\\stdClass')->setPublic(false);
     $container->compile();
     $this->assertTrue($container->hasDefinition('a'));
     $this->assertFalse($container->hasDefinition('b'));
     $this->assertFalse($container->hasDefinition('c'), 'Service C was not inlined.');
 }

 public function testLazyLoadedService()
 {
     $loader = new ClosureLoader($container = new ContainerBuilder());
     $loader->load(function (ContainerBuilder $container) {
         $container->set('a', new \BazClass());
         $definition = new Definition('BazClass');
         $definition->setLazy(true);
         $container->setDefinition('a', $definition);
     });
     $container->setResourceTracking(true);
     $container->compile();
     $class = new \BazClass();
     $reflectionClass = new \ReflectionClass($class);
     $r = new \ReflectionProperty($container, 'resources');
     $r->setAccessible(true);
     $resources = $r->getValue($container);
     $classInList = false;
     foreach ($resources as $resource) {
         if ($resource->getResource() === $reflectionClass->getFileName()) {
             $classInList = true;
             break;
         }
     }
     $this->assertTrue($classInList);
 }

 /**
  * @expectedException BadMethodCallException
  */
 public function testThrowsExceptionWhenSetDefinitionOnAFrozenContainer()
 {
     $container = new ContainerBuilder();
     $container->setResourceTracking(false);
     $container->compile();
     $container->setDefinition('a', new Definition());
 }

 /**
  * Allow an extension to prepend the extension configurations.
  *
  * @param ContainerBuilder $container
  */
 public function prepend(ContainerBuilder $container)
 {
     if (!$this instanceof EntitiesOverridableExtensionInterface) {
         return;
     }
     $mappingConfiguration = $this->getConfigurationInstance();
     if ($mappingConfiguration instanceof ConfigurationInterface) {
         $config = $container->getExtensionConfig($this::getExtensionName());
         $config = $container->getParameterBag()->resolveValue($config);
         $tmpContainer = new ContainerBuilder($container->getParameterBag());
         $tmpContainer->setResourceTracking($container->isTrackingResources());
         $tmpContainer->addObjectResource($this);
         $this->loadMappingConfiguration($tmpContainer, $mappingConfiguration, $config);
         $container->merge($tmpContainer);
     }
     /**
      * Perform overrides for Doctrine ORM mapping resolves
      */
     $overrides = $this->getEntitiesOverrides();
     foreach ($overrides as $interface => $override) {
         $overrides[$interface] = $container->getParameter($override);
     }
     $container->prependExtensionConfig('doctrine', ['orm' => ['resolve_target_entities' => $overrides]]);
 }