vendor/symfony/symfony/src/Symfony/Component/DependencyInjection/ContainerBuilder.php line 1512

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\DependencyInjection;
  14. use Psr\Container\ContainerInterface as PsrContainerInterface;
  15. use Symfony\Component\Config\Resource\ClassExistenceResource;
  16. use Symfony\Component\Config\Resource\ComposerResource;
  17. use Symfony\Component\Config\Resource\DirectoryResource;
  18. use Symfony\Component\Config\Resource\FileExistenceResource;
  19. use Symfony\Component\Config\Resource\FileResource;
  20. use Symfony\Component\Config\Resource\GlobResource;
  21. use Symfony\Component\Config\Resource\ReflectionClassResource;
  22. use Symfony\Component\Config\Resource\ResourceInterface;
  23. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  24. use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
  25. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
  26. use Symfony\Component\DependencyInjection\Compiler\Compiler;
  27. use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
  28. use Symfony\Component\DependencyInjection\Compiler\PassConfig;
  29. use Symfony\Component\DependencyInjection\Compiler\ResolveEnvPlaceholdersPass;
  30. use Symfony\Component\DependencyInjection\Exception\BadMethodCallException;
  31. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  32. use Symfony\Component\DependencyInjection\Exception\LogicException;
  33. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  34. use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  35. use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
  36. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  37. use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\InstantiatorInterface;
  38. use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\RealServiceInstantiator;
  39. use Symfony\Component\DependencyInjection\ParameterBag\EnvPlaceholderParameterBag;
  40. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
  41. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  42. use Symfony\Component\EventDispatcher\ContainerAwareEventDispatcher;
  43. use Symfony\Component\ExpressionLanguage\Expression;
  44. use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
  46. /**
  47.  * ContainerBuilder is a DI container that provides an API to easily describe services.
  48.  *
  49.  * @author Fabien Potencier <fabien@symfony.com>
  50.  */
  51. class ContainerBuilder extends Container implements TaggedContainerInterface
  52. {
  53.     /**
  54.      * @var ExtensionInterface[]
  55.      */
  56.     private $extensions = [];
  58.     /**
  59.      * @var ExtensionInterface[]
  60.      */
  61.     private $extensionsByNs = [];
  63.     /**
  64.      * @var Definition[]
  65.      */
  66.     private $definitions = [];
  68.     /**
  69.      * @var Alias[]
  70.      */
  71.     private $aliasDefinitions = [];
  73.     /**
  74.      * @var ResourceInterface[]
  75.      */
  76.     private $resources = [];
  78.     private $extensionConfigs = [];
  80.     /**
  81.      * @var Compiler
  82.      */
  83.     private $compiler;
  85.     private $trackResources;
  87.     /**
  88.      * @var InstantiatorInterface|null
  89.      */
  90.     private $proxyInstantiator;
  92.     /**
  93.      * @var ExpressionLanguage|null
  94.      */
  95.     private $expressionLanguage;
  97.     /**
  98.      * @var ExpressionFunctionProviderInterface[]
  99.      */
  100.     private $expressionLanguageProviders = [];
  102.     /**
  103.      * @var string[] with tag names used by findTaggedServiceIds
  104.      */
  105.     private $usedTags = [];
  107.     /**
  108.      * @var string[][] a map of env var names to their placeholders
  109.      */
  110.     private $envPlaceholders = [];
  112.     /**
  113.      * @var int[] a map of env vars to their resolution counter
  114.      */
  115.     private $envCounters = [];
  117.     /**
  118.      * @var string[] the list of vendor directories
  119.      */
  120.     private $vendors;
  122.     private $autoconfiguredInstanceof = [];
  124.     private $removedIds = [];
  126.     private $removedBindingIds = [];
  128.     private static $internalTypes = [
  129.         'int' => true,
  130.         'float' => true,
  131.         'string' => true,
  132.         'bool' => true,
  133.         'resource' => true,
  134.         'object' => true,
  135.         'array' => true,
  136.         'null' => true,
  137.         'callable' => true,
  138.         'iterable' => true,
  139.         'mixed' => true,
  140.     ];
  142.     public function __construct(ParameterBagInterface $parameterBag = null)
  143.     {
  144.         parent::__construct($parameterBag);
  146.         $this->trackResources = interface_exists('Symfony\Component\Config\Resource\ResourceInterface');
  147.         $this->setDefinition('service_container', (new Definition(ContainerInterface::class))->setSynthetic(true)->setPublic(true));
  148.         $this->setAlias(PsrContainerInterface::class, new Alias('service_container', false));
  149.         $this->setAlias(ContainerInterface::class, new Alias('service_container', false));
  150.     }
  152.     /**
  153.      * @var \ReflectionClass[] a list of class reflectors
  154.      */
  155.     private $classReflectors;
  157.     /**
  158.      * Sets the track resources flag.
  159.      *
  160.      * If you are not using the loaders and therefore don't want
  161.      * to depend on the Config component, set this flag to false.
  162.      *
  163.      * @param bool $track True if you want to track resources, false otherwise
  164.      */
  165.     public function setResourceTracking($track)
  166.     {
  167.         $this->trackResources = (bool) $track;
  168.     }
  170.     /**
  171.      * Checks if resources are tracked.
  172.      *
  173.      * @return bool true If resources are tracked, false otherwise
  174.      */
  175.     public function isTrackingResources()
  176.     {
  177.         return $this->trackResources;
  178.     }
  180.     /**
  181.      * Sets the instantiator to be used when fetching proxies.
  182.      */
  183.     public function setProxyInstantiator(InstantiatorInterface $proxyInstantiator)
  184.     {
  185.         $this->proxyInstantiator = $proxyInstantiator;
  186.     }
  188.     public function registerExtension(ExtensionInterface $extension)
  189.     {
  190.         $this->extensions[$extension->getAlias()] = $extension;
  192.         if (false !== $extension->getNamespace()) {
  193.             $this->extensionsByNs[$extension->getNamespace()] = $extension;
  194.         }
  195.     }
  197.     /**
  198.      * Returns an extension by alias or namespace.
  199.      *
  200.      * @param string $name An alias or a namespace
  201.      *
  202.      * @return ExtensionInterface An extension instance
  203.      *
  204.      * @throws LogicException if the extension is not registered
  205.      */
  206.     public function getExtension($name)
  207.     {
  208.         if (isset($this->extensions[$name])) {
  209.             return $this->extensions[$name];
  210.         }
  212.         if (isset($this->extensionsByNs[$name])) {
  213.             return $this->extensionsByNs[$name];
  214.         }
  216.         throw new LogicException(sprintf('Container extension "%s" is not registered', $name));
  217.     }
  219.     /**
  220.      * Returns all registered extensions.
  221.      *
  222.      * @return ExtensionInterface[] An array of ExtensionInterface
  223.      */
  224.     public function getExtensions()
  225.     {
  226.         return $this->extensions;
  227.     }
  229.     /**
  230.      * Checks if we have an extension.
  231.      *
  232.      * @param string $name The name of the extension
  233.      *
  234.      * @return bool If the extension exists
  235.      */
  236.     public function hasExtension($name)
  237.     {
  238.         return isset($this->extensions[$name]) || isset($this->extensionsByNs[$name]);
  239.     }
  241.     /**
  242.      * Returns an array of resources loaded to build this configuration.
  243.      *
  244.      * @return ResourceInterface[] An array of resources
  245.      */
  246.     public function getResources()
  247.     {
  248.         return array_values($this->resources);
  249.     }
  251.     /**
  252.      * @return $this
  253.      */
  254.     public function addResource(ResourceInterface $resource)
  255.     {
  256.         if (!$this->trackResources) {
  257.             return $this;
  258.         }
  260.         if ($resource instanceof GlobResource && $this->inVendors($resource->getPrefix())) {
  261.             return $this;
  262.         }
  264.         $this->resources[(string) $resource] = $resource;
  266.         return $this;
  267.     }
  269.     /**
  270.      * Sets the resources for this configuration.
  271.      *
  272.      * @param ResourceInterface[] $resources An array of resources
  273.      *
  274.      * @return $this
  275.      */
  276.     public function setResources(array $resources)
  277.     {
  278.         if (!$this->trackResources) {
  279.             return $this;
  280.         }
  282.         $this->resources = $resources;
  284.         return $this;
  285.     }
  287.     /**
  288.      * Adds the object class hierarchy as resources.
  289.      *
  290.      * @param object|string $object An object instance or class name
  291.      *
  292.      * @return $this
  293.      */
  294.     public function addObjectResource($object)
  295.     {
  296.         if ($this->trackResources) {
  297.             if (\is_object($object)) {
  298.                 $object = \get_class($object);
  299.             }
  300.             if (!isset($this->classReflectors[$object])) {
  301.                 $this->classReflectors[$object] = new \ReflectionClass($object);
  302.             }
  303.             $class = $this->classReflectors[$object];
  305.             foreach ($class->getInterfaceNames() as $name) {
  306.                 if (null === $interface = &$this->classReflectors[$name]) {
  307.                     $interface = new \ReflectionClass($name);
  308.                 }
  309.                 $file = $interface->getFileName();
  310.                 if (false !== $file && file_exists($file)) {
  311.                     $this->fileExists($file);
  312.                 }
  313.             }
  314.             do {
  315.                 $file = $class->getFileName();
  316.                 if (false !== $file && file_exists($file)) {
  317.                     $this->fileExists($file);
  318.                 }
  319.                 foreach ($class->getTraitNames() as $name) {
  320.                     $this->addObjectResource($name);
  321.                 }
  322.             } while ($class = $class->getParentClass());
  323.         }
  325.         return $this;
  326.     }
  328.     /**
  329.      * Adds the given class hierarchy as resources.
  330.      *
  331.      * @return $this
  332.      *
  333.      * @deprecated since version 3.3, to be removed in 4.0. Use addObjectResource() or getReflectionClass() instead.
  334.      */
  335.     public function addClassResource(\ReflectionClass $class)
  336.     {
  337.         @trigger_error('The '.__METHOD__.'() method is deprecated since Symfony 3.3 and will be removed in 4.0. Use the addObjectResource() or the getReflectionClass() method instead.', E_USER_DEPRECATED);
  339.         return $this->addObjectResource($class->name);
  340.     }
  342.     /**
  343.      * Retrieves the requested reflection class and registers it for resource tracking.
  344.      *
  345.      * @param string $class
  346.      * @param bool   $throw
  347.      *
  348.      * @return \ReflectionClass|null
  349.      *
  350.      * @throws \ReflectionException when a parent class/interface/trait is not found and $throw is true
  351.      *
  352.      * @final
  353.      */
  354.     public function getReflectionClass($class, $throw = true)
  355.     {
  356.         if (!$class = $this->getParameterBag()->resolveValue($class)) {
  357.             return null;
  358.         }
  360.         if (isset(self::$internalTypes[$class])) {
  361.             return null;
  362.         }
  364.         $resource = null;
  366.         try {
  367.             if (isset($this->classReflectors[$class])) {
  368.                 $classReflector = $this->classReflectors[$class];
  369.             } elseif (class_exists(ClassExistenceResource::class)) {
  370.                 $resource = new ClassExistenceResource($class, false);
  371.                 $classReflector = $resource->isFresh(0) ? false : new \ReflectionClass($class);
  372.             } else {
  373.                 $classReflector = class_exists($class) ? new \ReflectionClass($class) : false;
  374.             }
  375.         } catch (\ReflectionException $e) {
  376.             if ($throw) {
  377.                 throw $e;
  378.             }
  379.             $classReflector = false;
  380.         }
  382.         if ($this->trackResources) {
  383.             if (!$classReflector) {
  384.                 $this->addResource($resource ?: new ClassExistenceResource($class, false));
  385.             } elseif (!$classReflector->isInternal()) {
  386.                 $path = $classReflector->getFileName();
  388.                 if (!$this->inVendors($path)) {
  389.                     $this->addResource(new ReflectionClassResource($classReflector, $this->vendors));
  390.                 }
  391.             }
  392.             $this->classReflectors[$class] = $classReflector;
  393.         }
  395.         return $classReflector ?: null;
  396.     }
  398.     /**
  399.      * Checks whether the requested file or directory exists and registers the result for resource tracking.
  400.      *
  401.      * @param string      $path          The file or directory path for which to check the existence
  402.      * @param bool|string $trackContents Whether to track contents of the given resource. If a string is passed,
  403.      *                                   it will be used as pattern for tracking contents of the requested directory
  404.      *
  405.      * @return bool
  406.      *
  407.      * @final
  408.      */
  409.     public function fileExists($path, $trackContents = true)
  410.     {
  411.         $exists = file_exists($path);
  413.         if (!$this->trackResources || $this->inVendors($path)) {
  414.             return $exists;
  415.         }
  417.         if (!$exists) {
  418.             $this->addResource(new FileExistenceResource($path));
  420.             return $exists;
  421.         }
  423.         if (is_dir($path)) {
  424.             if ($trackContents) {
  425.                 $this->addResource(new DirectoryResource($path, \is_string($trackContents) ? $trackContents : null));
  426.             } else {
  427.                 $this->addResource(new GlobResource($path, '/*', false));
  428.             }
  429.         } elseif ($trackContents) {
  430.             $this->addResource(new FileResource($path));
  431.         }
  433.         return $exists;
  434.     }
  436.     /**
  437.      * Loads the configuration for an extension.
  438.      *
  439.      * @param string $extension The extension alias or namespace
  440.      * @param array  $values    An array of values that customizes the extension
  441.      *
  442.      * @return $this
  443.      *
  444.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  445.      * @throws \LogicException        if the extension is not registered
  446.      */
  447.     public function loadFromExtension($extension, array $values = null)
  448.     {
  449.         if ($this->isCompiled()) {
  450.             throw new BadMethodCallException('Cannot load from an extension on a compiled container.');
  451.         }
  453.         if (\func_num_args() < 2) {
  454.             $values = [];
  455.         }
  457.         $namespace = $this->getExtension($extension)->getAlias();
  459.         $this->extensionConfigs[$namespace][] = $values;
  461.         return $this;
  462.     }
  464.     /**
  465.      * Adds a compiler pass.
  466.      *
  467.      * @param CompilerPassInterface $pass     A compiler pass
  468.      * @param string                $type     The type of compiler pass
  469.      * @param int                   $priority Used to sort the passes
  470.      *
  471.      * @return $this
  472.      */
  473.     public function addCompilerPass(CompilerPassInterface $pass, $type = PassConfig::TYPE_BEFORE_OPTIMIZATION/*, int $priority = 0*/)
  474.     {
  475.         if (\func_num_args() >= 3) {
  476.             $priority = func_get_arg(2);
  477.         } else {
  478.             if (__CLASS__ !== \get_class($this)) {
  479.                 $r = new \ReflectionMethod($this, __FUNCTION__);
  480.                 if (__CLASS__ !== $r->getDeclaringClass()->getName()) {
  481.                     @trigger_error(sprintf('Method %s() will have a third `int $priority = 0` argument in version 4.0. Not defining it is deprecated since Symfony 3.2.', __METHOD__), E_USER_DEPRECATED);
  482.                 }
  483.             }
  485.             $priority = 0;
  486.         }
  488.         $this->getCompiler()->addPass($pass, $type, $priority);
  490.         $this->addObjectResource($pass);
  492.         return $this;
  493.     }
  495.     /**
  496.      * Returns the compiler pass config which can then be modified.
  497.      *
  498.      * @return PassConfig The compiler pass config
  499.      */
  500.     public function getCompilerPassConfig()
  501.     {
  502.         return $this->getCompiler()->getPassConfig();
  503.     }
  505.     /**
  506.      * Returns the compiler.
  507.      *
  508.      * @return Compiler The compiler
  509.      */
  510.     public function getCompiler()
  511.     {
  512.         if (null === $this->compiler) {
  513.             $this->compiler = new Compiler();
  514.         }
  516.         return $this->compiler;
  517.     }
  519.     /**
  520.      * Sets a service.
  521.      *
  522.      * @param string      $id      The service identifier
  523.      * @param object|null $service The service instance
  524.      *
  525.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  526.      */
  527.     public function set($id, $service)
  528.     {
  529.         $id = $this->normalizeId($id);
  531.         if ($this->isCompiled() && (isset($this->definitions[$id]) && !$this->definitions[$id]->isSynthetic())) {
  532.             // setting a synthetic service on a compiled container is alright
  533.             throw new BadMethodCallException(sprintf('Setting service "%s" for an unknown or non-synthetic service definition on a compiled container is not allowed.', $id));
  534.         }
  536.         unset($this->definitions[$id], $this->aliasDefinitions[$id], $this->removedIds[$id]);
  538.         parent::set($id, $service);
  539.     }
  541.     /**
  542.      * Removes a service definition.
  543.      *
  544.      * @param string $id The service identifier
  545.      */
  546.     public function removeDefinition($id)
  547.     {
  548.         if (isset($this->definitions[$id = $this->normalizeId($id)])) {
  549.             unset($this->definitions[$id]);
  550.             $this->removedIds[$id] = true;
  551.         }
  552.     }
  554.     /**
  555.      * Returns true if the given service is defined.
  556.      *
  557.      * @param string $id The service identifier
  558.      *
  559.      * @return bool true if the service is defined, false otherwise
  560.      */
  561.     public function has($id)
  562.     {
  563.         $id = $this->normalizeId($id);
  565.         return isset($this->definitions[$id]) || isset($this->aliasDefinitions[$id]) || parent::has($id);
  566.     }
  568.     /**
  569.      * Gets a service.
  570.      *
  571.      * @param string $id              The service identifier
  572.      * @param int    $invalidBehavior The behavior when the service does not exist
  573.      *
  574.      * @return object|null The associated service
  575.      *
  576.      * @throws InvalidArgumentException          when no definitions are available
  577.      * @throws ServiceCircularReferenceException When a circular reference is detected
  578.      * @throws ServiceNotFoundException          When the service is not defined
  579.      * @throws \Exception
  580.      *
  581.      * @see Reference
  582.      */
  583.     public function get($id, $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE)
  584.     {
  585.         if ($this->isCompiled() && isset($this->removedIds[$id = $this->normalizeId($id)])) {
  586.             @trigger_error(sprintf('Fetching the "%s" private service or alias is deprecated since Symfony 3.4 and will fail in 4.0. Make it public instead.', $id), E_USER_DEPRECATED);
  587.         }
  589.         return $this->doGet($id, $invalidBehavior);
  590.     }
  592.     private function doGet($id, $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, array &$inlineServices = null, $isConstructorArgument = false)
  593.     {
  594.         $id = $this->normalizeId($id);
  596.         if (isset($inlineServices[$id])) {
  597.             return $inlineServices[$id];
  598.         }
  599.         if (null === $inlineServices) {
  600.             $isConstructorArgument = true;
  601.             $inlineServices = [];
  602.         }
  603.         try {
  604.             if (ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $invalidBehavior) {
  605.                 return parent::get($id, $invalidBehavior);
  606.             }
  607.             if ($service = parent::get($id, ContainerInterface::NULL_ON_INVALID_REFERENCE)) {
  608.                 return $service;
  609.             }
  610.         } catch (ServiceCircularReferenceException $e) {
  611.             if ($isConstructorArgument) {
  612.                 throw $e;
  613.             }
  614.         }
  616.         if (!isset($this->definitions[$id]) && isset($this->aliasDefinitions[$id])) {
  617.             return $this->doGet((string) $this->aliasDefinitions[$id], $invalidBehavior, $inlineServices, $isConstructorArgument);
  618.         }
  620.         try {
  621.             $definition = $this->getDefinition($id);
  622.         } catch (ServiceNotFoundException $e) {
  623.             if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE !== $invalidBehavior) {
  624.                 return null;
  625.             }
  627.             throw $e;
  628.         }
  630.         if ($isConstructorArgument) {
  631.             $this->loading[$id] = true;
  632.         }
  634.         try {
  635.             return $this->createService($definition, $inlineServices, $isConstructorArgument, $id);
  636.         } finally {
  637.             if ($isConstructorArgument) {
  638.                 unset($this->loading[$id]);
  639.             }
  640.         }
  641.     }
  643.     /**
  644.      * Merges a ContainerBuilder with the current ContainerBuilder configuration.
  645.      *
  646.      * Service definitions overrides the current defined ones.
  647.      *
  648.      * But for parameters, they are overridden by the current ones. It allows
  649.      * the parameters passed to the container constructor to have precedence
  650.      * over the loaded ones.
  651.      *
  652.      *     $container = new ContainerBuilder(new ParameterBag(['foo' => 'bar']));
  653.      *     $loader = new LoaderXXX($container);
  654.      *     $loader->load('resource_name');
  655.      *     $container->register('foo', 'stdClass');
  656.      *
  657.      * In the above example, even if the loaded resource defines a foo
  658.      * parameter, the value will still be 'bar' as defined in the ContainerBuilder
  659.      * constructor.
  660.      *
  661.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  662.      */
  663.     public function merge(self $container)
  664.     {
  665.         if ($this->isCompiled()) {
  666.             throw new BadMethodCallException('Cannot merge on a compiled container.');
  667.         }
  669.         $this->addDefinitions($container->getDefinitions());
  670.         $this->addAliases($container->getAliases());
  671.         $this->getParameterBag()->add($container->getParameterBag()->all());
  673.         if ($this->trackResources) {
  674.             foreach ($container->getResources() as $resource) {
  675.                 $this->addResource($resource);
  676.             }
  677.         }
  679.         foreach ($this->extensions as $name => $extension) {
  680.             if (!isset($this->extensionConfigs[$name])) {
  681.                 $this->extensionConfigs[$name] = [];
  682.             }
  684.             $this->extensionConfigs[$name] = array_merge($this->extensionConfigs[$name], $container->getExtensionConfig($name));
  685.         }
  687.         if ($this->getParameterBag() instanceof EnvPlaceholderParameterBag && $container->getParameterBag() instanceof EnvPlaceholderParameterBag) {
  688.             $envPlaceholders = $container->getParameterBag()->getEnvPlaceholders();
  689.             $this->getParameterBag()->mergeEnvPlaceholders($container->getParameterBag());
  690.         } else {
  691.             $envPlaceholders = [];
  692.         }
  694.         foreach ($container->envCounters as $env => $count) {
  695.             if (!$count && !isset($envPlaceholders[$env])) {
  696.                 continue;
  697.             }
  698.             if (!isset($this->envCounters[$env])) {
  699.                 $this->envCounters[$env] = $count;
  700.             } else {
  701.                 $this->envCounters[$env] += $count;
  702.             }
  703.         }
  705.         foreach ($container->getAutoconfiguredInstanceof() as $interface => $childDefinition) {
  706.             if (isset($this->autoconfiguredInstanceof[$interface])) {
  707.                 throw new InvalidArgumentException(sprintf('"%s" has already been autoconfigured and merge() does not support merging autoconfiguration for the same class/interface.', $interface));
  708.             }
  710.             $this->autoconfiguredInstanceof[$interface] = $childDefinition;
  711.         }
  712.     }
  714.     /**
  715.      * Returns the configuration array for the given extension.
  716.      *
  717.      * @param string $name The name of the extension
  718.      *
  719.      * @return array An array of configuration
  720.      */
  721.     public function getExtensionConfig($name)
  722.     {
  723.         if (!isset($this->extensionConfigs[$name])) {
  724.             $this->extensionConfigs[$name] = [];
  725.         }
  727.         return $this->extensionConfigs[$name];
  728.     }
  730.     /**
  731.      * Prepends a config array to the configs of the given extension.
  732.      *
  733.      * @param string $name   The name of the extension
  734.      * @param array  $config The config to set
  735.      */
  736.     public function prependExtensionConfig($name, array $config)
  737.     {
  738.         if (!isset($this->extensionConfigs[$name])) {
  739.             $this->extensionConfigs[$name] = [];
  740.         }
  742.         array_unshift($this->extensionConfigs[$name], $config);
  743.     }
  745.     /**
  746.      * Compiles the container.
  747.      *
  748.      * This method passes the container to compiler
  749.      * passes whose job is to manipulate and optimize
  750.      * the container.
  751.      *
  752.      * The main compiler passes roughly do four things:
  753.      *
  754.      *  * The extension configurations are merged;
  755.      *  * Parameter values are resolved;
  756.      *  * The parameter bag is frozen;
  757.      *  * Extension loading is disabled.
  758.      *
  759.      * @param bool $resolveEnvPlaceholders Whether %env()% parameters should be resolved using the current
  760.      *                                     env vars or be replaced by uniquely identifiable placeholders.
  761.      *                                     Set to "true" when you want to use the current ContainerBuilder
  762.      *                                     directly, keep to "false" when the container is dumped instead.
  763.      */
  764.     public function compile(/*$resolveEnvPlaceholders = false*/)
  765.     {
  766.         if (1 <= \func_num_args()) {
  767.             $resolveEnvPlaceholders = func_get_arg(0);
  768.         } else {
  769.             if (__CLASS__ !== static::class) {
  770.                 $r = new \ReflectionMethod($this, __FUNCTION__);
  771.                 if (__CLASS__ !== $r->getDeclaringClass()->getName() && (1 > $r->getNumberOfParameters() || 'resolveEnvPlaceholders' !== $r->getParameters()[0]->name)) {
  772.                     @trigger_error(sprintf('The %s::compile() method expects a first "$resolveEnvPlaceholders" argument since Symfony 3.3. It will be made mandatory in 4.0.', static::class), E_USER_DEPRECATED);
  773.                 }
  774.             }
  775.             $resolveEnvPlaceholders = false;
  776.         }
  777.         $compiler = $this->getCompiler();
  779.         if ($this->trackResources) {
  780.             foreach ($compiler->getPassConfig()->getPasses() as $pass) {
  781.                 $this->addObjectResource($pass);
  782.             }
  783.         }
  784.         $bag = $this->getParameterBag();
  786.         if ($resolveEnvPlaceholders && $bag instanceof EnvPlaceholderParameterBag) {
  787.             $compiler->addPass(new ResolveEnvPlaceholdersPass(), PassConfig::TYPE_AFTER_REMOVING, -1000);
  788.         }
  790.         $compiler->compile($this);
  792.         foreach ($this->definitions as $id => $definition) {
  793.             if ($this->trackResources && $definition->isLazy()) {
  794.                 $this->getReflectionClass($definition->getClass());
  795.             }
  796.         }
  798.         $this->extensionConfigs = [];
  800.         if ($bag instanceof EnvPlaceholderParameterBag) {
  801.             if ($resolveEnvPlaceholders) {
  802.                 $this->parameterBag = new ParameterBag($this->resolveEnvPlaceholders($bag->all(), true));
  803.             }
  805.             $this->envPlaceholders = $bag->getEnvPlaceholders();
  806.         }
  808.         parent::compile();
  810.         foreach ($this->definitions + $this->aliasDefinitions as $id => $definition) {
  811.             if (!$definition->isPublic() || $definition->isPrivate()) {
  812.                 $this->removedIds[$id] = true;
  813.             }
  814.         }
  815.     }
  817.     /**
  818.      * {@inheritdoc}
  819.      */
  820.     public function getServiceIds()
  821.     {
  822.         return array_map('strval', array_unique(array_merge(array_keys($this->getDefinitions()), array_keys($this->aliasDefinitions), parent::getServiceIds())));
  823.     }
  825.     /**
  826.      * Gets removed service or alias ids.
  827.      *
  828.      * @return array
  829.      */
  830.     public function getRemovedIds()
  831.     {
  832.         return $this->removedIds;
  833.     }
  835.     /**
  836.      * Adds the service aliases.
  837.      */
  838.     public function addAliases(array $aliases)
  839.     {
  840.         foreach ($aliases as $alias => $id) {
  841.             $this->setAlias($alias, $id);
  842.         }
  843.     }
  845.     /**
  846.      * Sets the service aliases.
  847.      */
  848.     public function setAliases(array $aliases)
  849.     {
  850.         $this->aliasDefinitions = [];
  851.         $this->addAliases($aliases);
  852.     }
  854.     /**
  855.      * Sets an alias for an existing service.
  856.      *
  857.      * @param string       $alias The alias to create
  858.      * @param string|Alias $id    The service to alias
  859.      *
  860.      * @return Alias
  861.      *
  862.      * @throws InvalidArgumentException if the id is not a string or an Alias
  863.      * @throws InvalidArgumentException if the alias is for itself
  864.      */
  865.     public function setAlias($alias, $id)
  866.     {
  867.         $alias = $this->normalizeId($alias);
  869.         if ('' === $alias || '\\' === substr($alias, -1) || \strlen($alias) !== strcspn($alias, "\0\r\n'")) {
  870.             throw new InvalidArgumentException(sprintf('Invalid alias id: "%s"', $alias));
  871.         }
  873.         if (\is_string($id)) {
  874.             $id = new Alias($this->normalizeId($id));
  875.         } elseif (!$id instanceof Alias) {
  876.             throw new InvalidArgumentException('$id must be a string, or an Alias object.');
  877.         }
  879.         if ($alias === (string) $id) {
  880.             throw new InvalidArgumentException(sprintf('An alias can not reference itself, got a circular reference on "%s".', $alias));
  881.         }
  883.         unset($this->definitions[$alias], $this->removedIds[$alias]);
  885.         return $this->aliasDefinitions[$alias] = $id;
  886.     }
  888.     /**
  889.      * Removes an alias.
  890.      *
  891.      * @param string $alias The alias to remove
  892.      */
  893.     public function removeAlias($alias)
  894.     {
  895.         if (isset($this->aliasDefinitions[$alias = $this->normalizeId($alias)])) {
  896.             unset($this->aliasDefinitions[$alias]);
  897.             $this->removedIds[$alias] = true;
  898.         }
  899.     }
  901.     /**
  902.      * Returns true if an alias exists under the given identifier.
  903.      *
  904.      * @param string $id The service identifier
  905.      *
  906.      * @return bool true if the alias exists, false otherwise
  907.      */
  908.     public function hasAlias($id)
  909.     {
  910.         return isset($this->aliasDefinitions[$this->normalizeId($id)]);
  911.     }
  913.     /**
  914.      * Gets all defined aliases.
  915.      *
  916.      * @return Alias[] An array of aliases
  917.      */
  918.     public function getAliases()
  919.     {
  920.         return $this->aliasDefinitions;
  921.     }
  923.     /**
  924.      * Gets an alias.
  925.      *
  926.      * @param string $id The service identifier
  927.      *
  928.      * @return Alias An Alias instance
  929.      *
  930.      * @throws InvalidArgumentException if the alias does not exist
  931.      */
  932.     public function getAlias($id)
  933.     {
  934.         $id = $this->normalizeId($id);
  936.         if (!isset($this->aliasDefinitions[$id])) {
  937.             throw new InvalidArgumentException(sprintf('The service alias "%s" does not exist.', $id));
  938.         }
  940.         return $this->aliasDefinitions[$id];
  941.     }
  943.     /**
  944.      * Registers a service definition.
  945.      *
  946.      * This methods allows for simple registration of service definition
  947.      * with a fluid interface.
  948.      *
  949.      * @param string      $id    The service identifier
  950.      * @param string|null $class The service class
  951.      *
  952.      * @return Definition A Definition instance
  953.      */
  954.     public function register($id, $class = null)
  955.     {
  956.         return $this->setDefinition($id, new Definition($class));
  957.     }
  959.     /**
  960.      * Registers an autowired service definition.
  961.      *
  962.      * This method implements a shortcut for using setDefinition() with
  963.      * an autowired definition.
  964.      *
  965.      * @param string      $id    The service identifier
  966.      * @param string|null $class The service class
  967.      *
  968.      * @return Definition The created definition
  969.      */
  970.     public function autowire($id, $class = null)
  971.     {
  972.         return $this->setDefinition($id, (new Definition($class))->setAutowired(true));
  973.     }
  975.     /**
  976.      * Adds the service definitions.
  977.      *
  978.      * @param Definition[] $definitions An array of service definitions
  979.      */
  980.     public function addDefinitions(array $definitions)
  981.     {
  982.         foreach ($definitions as $id => $definition) {
  983.             $this->setDefinition($id, $definition);
  984.         }
  985.     }
  987.     /**
  988.      * Sets the service definitions.
  989.      *
  990.      * @param Definition[] $definitions An array of service definitions
  991.      */
  992.     public function setDefinitions(array $definitions)
  993.     {
  994.         $this->definitions = [];
  995.         $this->addDefinitions($definitions);
  996.     }
  998.     /**
  999.      * Gets all service definitions.
  1000.      *
  1001.      * @return Definition[] An array of Definition instances
  1002.      */
  1003.     public function getDefinitions()
  1004.     {
  1005.         return $this->definitions;
  1006.     }
  1008.     /**
  1009.      * Sets a service definition.
  1010.      *
  1011.      * @param string     $id         The service identifier
  1012.      * @param Definition $definition A Definition instance
  1013.      *
  1014.      * @return Definition the service definition
  1015.      *
  1016.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  1017.      */
  1018.     public function setDefinition($id, Definition $definition)
  1019.     {
  1020.         if ($this->isCompiled()) {
  1021.             throw new BadMethodCallException('Adding definition to a compiled container is not allowed');
  1022.         }
  1024.         $id = $this->normalizeId($id);
  1026.         if ('' === $id || '\\' === substr($id, -1) || \strlen($id) !== strcspn($id, "\0\r\n'")) {
  1027.             throw new InvalidArgumentException(sprintf('Invalid service id: "%s"', $id));
  1028.         }
  1030.         unset($this->aliasDefinitions[$id], $this->removedIds[$id]);
  1032.         return $this->definitions[$id] = $definition;
  1033.     }
  1035.     /**
  1036.      * Returns true if a service definition exists under the given identifier.
  1037.      *
  1038.      * @param string $id The service identifier
  1039.      *
  1040.      * @return bool true if the service definition exists, false otherwise
  1041.      */
  1042.     public function hasDefinition($id)
  1043.     {
  1044.         return isset($this->definitions[$this->normalizeId($id)]);
  1045.     }
  1047.     /**
  1048.      * Gets a service definition.
  1049.      *
  1050.      * @param string $id The service identifier
  1051.      *
  1052.      * @return Definition A Definition instance
  1053.      *
  1054.      * @throws ServiceNotFoundException if the service definition does not exist
  1055.      */
  1056.     public function getDefinition($id)
  1057.     {
  1058.         $id = $this->normalizeId($id);
  1060.         if (!isset($this->definitions[$id])) {
  1061.             throw new ServiceNotFoundException($id);
  1062.         }
  1064.         return $this->definitions[$id];
  1065.     }
  1067.     /**
  1068.      * Gets a service definition by id or alias.
  1069.      *
  1070.      * The method "unaliases" recursively to return a Definition instance.
  1071.      *
  1072.      * @param string $id The service identifier or alias
  1073.      *
  1074.      * @return Definition A Definition instance
  1075.      *
  1076.      * @throws ServiceNotFoundException if the service definition does not exist
  1077.      */
  1078.     public function findDefinition($id)
  1079.     {
  1080.         $id = $this->normalizeId($id);
  1082.         $seen = [];
  1083.         while (isset($this->aliasDefinitions[$id])) {
  1084.             $id = (string) $this->aliasDefinitions[$id];
  1086.             if (isset($seen[$id])) {
  1087.                 $seen = array_values($seen);
  1088.                 $seen = \array_slice($seen, array_search($id, $seen));
  1089.                 $seen[] = $id;
  1091.                 throw new ServiceCircularReferenceException($id, $seen);
  1092.             }
  1094.             $seen[$id] = $id;
  1095.         }
  1097.         return $this->getDefinition($id);
  1098.     }
  1100.     /**
  1101.      * Creates a service for a service definition.
  1102.      *
  1103.      * @param Definition $definition A service definition instance
  1104.      * @param string     $id         The service identifier
  1105.      * @param bool       $tryProxy   Whether to try proxying the service with a lazy proxy
  1106.      *
  1107.      * @return mixed The service described by the service definition
  1108.      *
  1109.      * @throws RuntimeException         When the factory definition is incomplete
  1110.      * @throws RuntimeException         When the service is a synthetic service
  1111.      * @throws InvalidArgumentException When configure callable is not callable
  1112.      */
  1113.     private function createService(Definition $definition, array &$inlineServices, $isConstructorArgument = false, $id = null, $tryProxy = true)
  1114.     {
  1115.         if (null === $id && isset($inlineServices[$h = spl_object_hash($definition)])) {
  1116.             return $inlineServices[$h];
  1117.         }
  1119.         if ($definition instanceof ChildDefinition) {
  1120.             throw new RuntimeException(sprintf('Constructing service "%s" from a parent definition is not supported at build time.', $id));
  1121.         }
  1123.         if ($definition->isSynthetic()) {
  1124.             throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The DIC does not know how to construct this service.', $id));
  1125.         }
  1127.         if ($definition->isDeprecated()) {
  1128.             @trigger_error($definition->getDeprecationMessage($id), E_USER_DEPRECATED);
  1129.         }
  1131.         if ($tryProxy && $definition->isLazy() && !$tryProxy = !($proxy = $this->proxyInstantiator) || $proxy instanceof RealServiceInstantiator) {
  1132.             $proxy = $proxy->instantiateProxy(
  1133.                 $this,
  1134.                 $definition,
  1135.                 $id, function () use ($definition, &$inlineServices, $id) {
  1136.                     return $this->createService($definition, $inlineServices, true, $id, false);
  1137.                 }
  1138.             );
  1139.             $this->shareService($definition, $proxy, $id, $inlineServices);
  1141.             return $proxy;
  1142.         }
  1144.         $parameterBag = $this->getParameterBag();
  1146.         if (null !== $definition->getFile()) {
  1147.             require_once $parameterBag->resolveValue($definition->getFile());
  1148.         }
  1150.         $arguments = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getArguments())), $inlineServices, $isConstructorArgument);
  1152.         if (null !== $factory = $definition->getFactory()) {
  1153.             if (\is_array($factory)) {
  1154.                 $factory = [$this->doResolveServices($parameterBag->resolveValue($factory[0]), $inlineServices, $isConstructorArgument), $factory[1]];
  1155.             } elseif (!\is_string($factory)) {
  1156.                 throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory', $id));
  1157.             }
  1158.         }
  1160.         if (null !== $id && $definition->isShared() && isset($this->services[$id]) && ($tryProxy || !$definition->isLazy())) {
  1161.             return $this->services[$id];
  1162.         }
  1164.         if (null !== $factory) {
  1165.             $service = \call_user_func_array($factory, $arguments);
  1167.             if (!$definition->isDeprecated() && \is_array($factory) && \is_string($factory[0])) {
  1168.                 $r = new \ReflectionClass($factory[0]);
  1170.                 if (0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
  1171.                     @trigger_error(sprintf('The "%s" service relies on the deprecated "%s" factory class. It should either be deprecated or its factory upgraded.', $id, $r->name), E_USER_DEPRECATED);
  1172.                 }
  1173.             }
  1174.         } else {
  1175.             $r = new \ReflectionClass($class = $parameterBag->resolveValue($definition->getClass()));
  1177.             $service = null === $r->getConstructor() ? $r->newInstance() : $r->newInstanceArgs($arguments);
  1178.             // don't trigger deprecations for internal uses
  1179.             // @deprecated since version 3.3, to be removed in 4.0 along with the deprecated class
  1180.             $deprecationWhitelist = ['event_dispatcher' => ContainerAwareEventDispatcher::class];
  1182.             if (!$definition->isDeprecated() && 0 < strpos($r->getDocComment(), "\n * @deprecated ") && (!isset($deprecationWhitelist[$id]) || $deprecationWhitelist[$id] !== $class)) {
  1183.                 @trigger_error(sprintf('The "%s" service relies on the deprecated "%s" class. It should either be deprecated or its implementation upgraded.', $id, $r->name), E_USER_DEPRECATED);
  1184.             }
  1185.         }
  1187.         if ($tryProxy || !$definition->isLazy()) {
  1188.             // share only if proxying failed, or if not a proxy
  1189.             $this->shareService($definition, $service, $id, $inlineServices);
  1190.         }
  1192.         $properties = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getProperties())), $inlineServices);
  1193.         foreach ($properties as $name => $value) {
  1194.             $service->$name = $value;
  1195.         }
  1197.         foreach ($definition->getMethodCalls() as $call) {
  1198.             $this->callMethod($service, $call, $inlineServices);
  1199.         }
  1201.         if ($callable = $definition->getConfigurator()) {
  1202.             if (\is_array($callable)) {
  1203.                 $callable[0] = $parameterBag->resolveValue($callable[0]);
  1205.                 if ($callable[0] instanceof Reference) {
  1206.                     $callable[0] = $this->doGet((string) $callable[0], $callable[0]->getInvalidBehavior(), $inlineServices);
  1207.                 } elseif ($callable[0] instanceof Definition) {
  1208.                     $callable[0] = $this->createService($callable[0], $inlineServices);
  1209.                 }
  1210.             }
  1212.             if (!\is_callable($callable)) {
  1213.                 throw new InvalidArgumentException(sprintf('The configure callable for class "%s" is not a callable.', \get_class($service)));
  1214.             }
  1216.             \call_user_func($callable, $service);
  1217.         }
  1219.         return $service;
  1220.     }
  1222.     /**
  1223.      * Replaces service references by the real service instance and evaluates expressions.
  1224.      *
  1225.      * @param mixed $value A value
  1226.      *
  1227.      * @return mixed The same value with all service references replaced by
  1228.      *               the real service instances and all expressions evaluated
  1229.      */
  1230.     public function resolveServices($value)
  1231.     {
  1232.         return $this->doResolveServices($value);
  1233.     }
  1235.     private function doResolveServices($value, array &$inlineServices = [], $isConstructorArgument = false)
  1236.     {
  1237.         if (\is_array($value)) {
  1238.             foreach ($value as $k => $v) {
  1239.                 $value[$k] = $this->doResolveServices($v, $inlineServices, $isConstructorArgument);
  1240.             }
  1241.         } elseif ($value instanceof ServiceClosureArgument) {
  1242.             $reference = $value->getValues()[0];
  1243.             $value = function () use ($reference) {
  1244.                 return $this->resolveServices($reference);
  1245.             };
  1246.         } elseif ($value instanceof IteratorArgument) {
  1247.             $value = new RewindableGenerator(function () use ($value) {
  1248.                 foreach ($value->getValues() as $k => $v) {
  1249.                     foreach (self::getServiceConditionals($v) as $s) {
  1250.                         if (!$this->has($s)) {
  1251.                             continue 2;
  1252.                         }
  1253.                     }
  1254.                     foreach (self::getInitializedConditionals($v) as $s) {
  1255.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE)) {
  1256.                             continue 2;
  1257.                         }
  1258.                     }
  1260.                     yield $k => $this->resolveServices($v);
  1261.                 }
  1262.             }, function () use ($value) {
  1263.                 $count = 0;
  1264.                 foreach ($value->getValues() as $v) {
  1265.                     foreach (self::getServiceConditionals($v) as $s) {
  1266.                         if (!$this->has($s)) {
  1267.                             continue 2;
  1268.                         }
  1269.                     }
  1270.                     foreach (self::getInitializedConditionals($v) as $s) {
  1271.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE)) {
  1272.                             continue 2;
  1273.                         }
  1274.                     }
  1276.                     ++$count;
  1277.                 }
  1279.                 return $count;
  1280.             });
  1281.         } elseif ($value instanceof Reference) {
  1282.             $value = $this->doGet((string) $value, $value->getInvalidBehavior(), $inlineServices, $isConstructorArgument);
  1283.         } elseif ($value instanceof Definition) {
  1284.             $value = $this->createService($value, $inlineServices, $isConstructorArgument);
  1285.         } elseif ($value instanceof Parameter) {
  1286.             $value = $this->getParameter((string) $value);
  1287.         } elseif ($value instanceof Expression) {
  1288.             $value = $this->getExpressionLanguage()->evaluate($value, ['container' => $this]);
  1289.         }
  1291.         return $value;
  1292.     }
  1294.     /**
  1295.      * Returns service ids for a given tag.
  1296.      *
  1297.      * Example:
  1298.      *
  1299.      *     $container->register('foo')->addTag('my.tag', ['hello' => 'world']);
  1300.      *
  1301.      *     $serviceIds = $container->findTaggedServiceIds('my.tag');
  1302.      *     foreach ($serviceIds as $serviceId => $tags) {
  1303.      *         foreach ($tags as $tag) {
  1304.      *             echo $tag['hello'];
  1305.      *         }
  1306.      *     }
  1307.      *
  1308.      * @param string $name
  1309.      * @param bool   $throwOnAbstract
  1310.      *
  1311.      * @return array An array of tags with the tagged service as key, holding a list of attribute arrays
  1312.      */
  1313.     public function findTaggedServiceIds($name, $throwOnAbstract = false)
  1314.     {
  1315.         $this->usedTags[] = $name;
  1316.         $tags = [];
  1317.         foreach ($this->getDefinitions() as $id => $definition) {
  1318.             if ($definition->hasTag($name)) {
  1319.                 if ($throwOnAbstract && $definition->isAbstract()) {
  1320.                     throw new InvalidArgumentException(sprintf('The service "%s" tagged "%s" must not be abstract.', $id, $name));
  1321.                 }
  1322.                 $tags[$id] = $definition->getTag($name);
  1323.             }
  1324.         }
  1326.         return $tags;
  1327.     }
  1329.     /**
  1330.      * Returns all tags the defined services use.
  1331.      *
  1332.      * @return array An array of tags
  1333.      */
  1334.     public function findTags()
  1335.     {
  1336.         $tags = [];
  1337.         foreach ($this->getDefinitions() as $id => $definition) {
  1338.             $tags = array_merge(array_keys($definition->getTags()), $tags);
  1339.         }
  1341.         return array_unique($tags);
  1342.     }
  1344.     /**
  1345.      * Returns all tags not queried by findTaggedServiceIds.
  1346.      *
  1347.      * @return string[] An array of tags
  1348.      */
  1349.     public function findUnusedTags()
  1350.     {
  1351.         return array_values(array_diff($this->findTags(), $this->usedTags));
  1352.     }
  1354.     public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
  1355.     {
  1356.         $this->expressionLanguageProviders[] = $provider;
  1357.     }
  1359.     /**
  1360.      * @return ExpressionFunctionProviderInterface[]
  1361.      */
  1362.     public function getExpressionLanguageProviders()
  1363.     {
  1364.         return $this->expressionLanguageProviders;
  1365.     }
  1367.     /**
  1368.      * Returns a ChildDefinition that will be used for autoconfiguring the interface/class.
  1369.      *
  1370.      * @param string $interface The class or interface to match
  1371.      *
  1372.      * @return ChildDefinition
  1373.      */
  1374.     public function registerForAutoconfiguration($interface)
  1375.     {
  1376.         if (!isset($this->autoconfiguredInstanceof[$interface])) {
  1377.             $this->autoconfiguredInstanceof[$interface] = new ChildDefinition('');
  1378.         }
  1380.         return $this->autoconfiguredInstanceof[$interface];
  1381.     }
  1383.     /**
  1384.      * Returns an array of ChildDefinition[] keyed by interface.
  1385.      *
  1386.      * @return ChildDefinition[]
  1387.      */
  1388.     public function getAutoconfiguredInstanceof()
  1389.     {
  1390.         return $this->autoconfiguredInstanceof;
  1391.     }
  1393.     /**
  1394.      * Resolves env parameter placeholders in a string or an array.
  1395.      *
  1396.      * @param mixed            $value     The value to resolve
  1397.      * @param string|true|null $format    A sprintf() format returning the replacement for each env var name or
  1398.      *                                    null to resolve back to the original "%env(VAR)%" format or
  1399.      *                                    true to resolve to the actual values of the referenced env vars
  1400.      * @param array            &$usedEnvs Env vars found while resolving are added to this array
  1401.      *
  1402.      * @return mixed The value with env parameters resolved if a string or an array is passed
  1403.      */
  1404.     public function resolveEnvPlaceholders($value, $format = null, array &$usedEnvs = null)
  1405.     {
  1406.         if (null === $format) {
  1407.             $format = '%%env(%s)%%';
  1408.         }
  1410.         $bag = $this->getParameterBag();
  1411.         if (true === $format) {
  1412.             $value = $bag->resolveValue($value);
  1413.         }
  1415.         if (\is_array($value)) {
  1416.             $result = [];
  1417.             foreach ($value as $k => $v) {
  1418.                 $result[\is_string($k) ? $this->resolveEnvPlaceholders($k, $format, $usedEnvs) : $k] = $this->resolveEnvPlaceholders($v, $format, $usedEnvs);
  1419.             }
  1421.             return $result;
  1422.         }
  1424.         if (!\is_string($value) || 38 > \strlen($value)) {
  1425.             return $value;
  1426.         }
  1427.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1429.         $completed = false;
  1430.         foreach ($envPlaceholders as $env => $placeholders) {
  1431.             foreach ($placeholders as $placeholder) {
  1432.                 if (false !== stripos($value, $placeholder)) {
  1433.                     if (true === $format) {
  1434.                         $resolved = $bag->escapeValue($this->getEnv($env));
  1435.                     } else {
  1436.                         $resolved = sprintf($format, $env);
  1437.                     }
  1438.                     if ($placeholder === $value) {
  1439.                         $value = $resolved;
  1440.                         $completed = true;
  1441.                     } else {
  1442.                         if (!\is_string($resolved) && !is_numeric($resolved)) {
  1443.                             throw new RuntimeException(sprintf('A string value must be composed of strings and/or numbers, but found parameter "env(%s)" of type %s inside string value "%s".', $env, \gettype($resolved), $this->resolveEnvPlaceholders($value)));
  1444.                         }
  1445.                         $value = str_ireplace($placeholder, $resolved, $value);
  1446.                     }
  1447.                     $usedEnvs[$env] = $env;
  1448.                     $this->envCounters[$env] = isset($this->envCounters[$env]) ? 1 + $this->envCounters[$env] : 1;
  1450.                     if ($completed) {
  1451.                         break 2;
  1452.                     }
  1453.                 }
  1454.             }
  1455.         }
  1457.         return $value;
  1458.     }
  1460.     /**
  1461.      * Get statistics about env usage.
  1462.      *
  1463.      * @return int[] The number of time each env vars has been resolved
  1464.      */
  1465.     public function getEnvCounters()
  1466.     {
  1467.         $bag = $this->getParameterBag();
  1468.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1470.         foreach ($envPlaceholders as $env => $placeholders) {
  1471.             if (!isset($this->envCounters[$env])) {
  1472.                 $this->envCounters[$env] = 0;
  1473.             }
  1474.         }
  1476.         return $this->envCounters;
  1477.     }
  1479.     /**
  1480.      * @internal
  1481.      */
  1482.     public function getNormalizedIds()
  1483.     {
  1484.         $normalizedIds = [];
  1486.         foreach ($this->normalizedIds as $k => $v) {
  1487.             if ($v !== (string) $k) {
  1488.                 $normalizedIds[$k] = $v;
  1489.             }
  1490.         }
  1492.         return $normalizedIds;
  1493.     }
  1495.     /**
  1496.      * @final
  1497.      */
  1498.     public function log(CompilerPassInterface $pass, $message)
  1499.     {
  1500.         $this->getCompiler()->log($pass, $this->resolveEnvPlaceholders($message));
  1501.     }
  1503.     /**
  1504.      * {@inheritdoc}
  1505.      */
  1506.     public function normalizeId($id)
  1507.     {
  1508.         if (!\is_string($id)) {
  1509.             $id = (string) $id;
  1510.         }
  1512.         return isset($this->definitions[$id]) || isset($this->aliasDefinitions[$id]) || isset($this->removedIds[$id]) ? $id : parent::normalizeId($id);
  1513.     }
  1515.     /**
  1516.      * Gets removed binding ids.
  1517.      *
  1518.      * @return array
  1519.      *
  1520.      * @internal
  1521.      */
  1522.     public function getRemovedBindingIds()
  1523.     {
  1524.         return $this->removedBindingIds;
  1525.     }
  1527.     /**
  1528.      * Removes bindings for a service.
  1529.      *
  1530.      * @param string $id The service identifier
  1531.      *
  1532.      * @internal
  1533.      */
  1534.     public function removeBindings($id)
  1535.     {
  1536.         if ($this->hasDefinition($id)) {
  1537.             foreach ($this->getDefinition($id)->getBindings() as $key => $binding) {
  1538.                 list(, $bindingId) = $binding->getValues();
  1539.                 $this->removedBindingIds[(int) $bindingId] = true;
  1540.             }
  1541.         }
  1542.     }
  1544.     /**
  1545.      * Returns the Service Conditionals.
  1546.      *
  1547.      * @param mixed $value An array of conditionals to return
  1548.      *
  1549.      * @return array An array of Service conditionals
  1550.      *
  1551.      * @internal since version 3.4
  1552.      */
  1553.     public static function getServiceConditionals($value)
  1554.     {
  1555.         $services = [];
  1557.         if (\is_array($value)) {
  1558.             foreach ($value as $v) {
  1559.                 $services = array_unique(array_merge($services, self::getServiceConditionals($v)));
  1560.             }
  1561.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
  1562.             $services[] = (string) $value;
  1563.         }
  1565.         return $services;
  1566.     }
  1568.     /**
  1569.      * Returns the initialized conditionals.
  1570.      *
  1571.      * @param mixed $value An array of conditionals to return
  1572.      *
  1573.      * @return array An array of uninitialized conditionals
  1574.      *
  1575.      * @internal
  1576.      */
  1577.     public static function getInitializedConditionals($value)
  1578.     {
  1579.         $services = [];
  1581.         if (\is_array($value)) {
  1582.             foreach ($value as $v) {
  1583.                 $services = array_unique(array_merge($services, self::getInitializedConditionals($v)));
  1584.             }
  1585.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $value->getInvalidBehavior()) {
  1586.             $services[] = (string) $value;
  1587.         }
  1589.         return $services;
  1590.     }
  1592.     /**
  1593.      * Computes a reasonably unique hash of a value.
  1594.      *
  1595.      * @param mixed $value A serializable value
  1596.      *
  1597.      * @return string
  1598.      */
  1599.     public static function hash($value)
  1600.     {
  1601.         $hash = substr(base64_encode(hash('sha256', serialize($value), true)), 0, 7);
  1603.         return str_replace(['/', '+'], ['.', '_'], strtolower($hash));
  1604.     }
  1606.     /**
  1607.      * {@inheritdoc}
  1608.      */
  1609.     protected function getEnv($name)
  1610.     {
  1611.         $value = parent::getEnv($name);
  1612.         $bag = $this->getParameterBag();
  1614.         if (!\is_string($value) || !$bag instanceof EnvPlaceholderParameterBag) {
  1615.             return $value;
  1616.         }
  1618.         foreach ($bag->getEnvPlaceholders() as $env => $placeholders) {
  1619.             if (isset($placeholders[$value])) {
  1620.                 $bag = new ParameterBag($bag->all());
  1622.                 return $bag->unescapeValue($bag->get("env($name)"));
  1623.             }
  1624.         }
  1626.         $this->resolving["env($name)"] = true;
  1627.         try {
  1628.             return $bag->unescapeValue($this->resolveEnvPlaceholders($bag->escapeValue($value), true));
  1629.         } finally {
  1630.             unset($this->resolving["env($name)"]);
  1631.         }
  1632.     }
  1634.     private function callMethod($service, $call, array &$inlineServices)
  1635.     {
  1636.         foreach (self::getServiceConditionals($call[1]) as $s) {
  1637.             if (!$this->has($s)) {
  1638.                 return;
  1639.             }
  1640.         }
  1641.         foreach (self::getInitializedConditionals($call[1]) as $s) {
  1642.             if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {
  1643.                 return;
  1644.             }
  1645.         }
  1647.         \call_user_func_array([$service, $call[0]], $this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));
  1648.     }
  1650.     /**
  1651.      * Shares a given service in the container.
  1652.      *
  1653.      * @param mixed       $service
  1654.      * @param string|null $id
  1655.      */
  1656.     private function shareService(Definition $definition, $service, $id, array &$inlineServices)
  1657.     {
  1658.         $inlineServices[null !== $id ? $id : spl_object_hash($definition)] = $service;
  1660.         if (null !== $id && $definition->isShared()) {
  1661.             $this->services[$id] = $service;
  1662.             unset($this->loading[$id]);
  1663.         }
  1664.     }
  1666.     private function getExpressionLanguage()
  1667.     {
  1668.         if (null === $this->expressionLanguage) {
  1669.             if (!class_exists('Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
  1670.                 throw new RuntimeException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
  1671.             }
  1672.             $this->expressionLanguage = new ExpressionLanguage(null, $this->expressionLanguageProviders);
  1673.         }
  1675.         return $this->expressionLanguage;
  1676.     }
  1678.     private function inVendors($path)
  1679.     {
  1680.         if (null === $this->vendors) {
  1681.             $resource = new ComposerResource();
  1682.             $this->vendors = $resource->getVendors();
  1683.             $this->addResource($resource);
  1684.         }
  1685.         $path = realpath($path) ?: $path;
  1687.         foreach ($this->vendors as $vendor) {
  1688.             if (0 === strpos($path, $vendor) && false !== strpbrk(substr($path, \strlen($vendor), 1), '/'.\DIRECTORY_SEPARATOR)) {
  1689.                 return true;
  1690.             }
  1691.         }
  1693.         return false;
  1694.     }
  1695. }