2010-01-04 14:26:20 +00:00
|
|
|
<?php
|
|
|
|
|
2011-01-15 13:29:43 +00:00
|
|
|
/*
|
|
|
|
* This file is part of the Symfony package.
|
|
|
|
*
|
2011-03-06 11:40:06 +00:00
|
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
2011-01-15 13:29:43 +00:00
|
|
|
*
|
|
|
|
* For the full copyright and license information, please view the LICENSE
|
|
|
|
* file that was distributed with this source code.
|
|
|
|
*/
|
|
|
|
|
2010-08-20 22:09:55 +01:00
|
|
|
namespace Symfony\Component\DependencyInjection;
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2011-01-09 09:53:46 +00:00
|
|
|
use Symfony\Component\DependencyInjection\Compiler\Compiler;
|
2010-12-14 23:25:33 +00:00
|
|
|
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
|
2011-01-16 07:53:28 +00:00
|
|
|
use Symfony\Component\DependencyInjection\Compiler\PassConfig;
|
2011-12-04 23:51:22 +00:00
|
|
|
use Symfony\Component\DependencyInjection\Exception\BadMethodCallException;
|
2013-04-17 12:23:58 +01:00
|
|
|
use Symfony\Component\DependencyInjection\Exception\InactiveScopeException;
|
2011-12-04 23:51:22 +00:00
|
|
|
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
|
|
|
|
use Symfony\Component\DependencyInjection\Exception\LogicException;
|
|
|
|
use Symfony\Component\DependencyInjection\Exception\RuntimeException;
|
2016-02-07 18:10:24 +00:00
|
|
|
use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
|
|
|
|
use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
|
2010-08-20 22:09:55 +01:00
|
|
|
use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
|
2011-02-10 15:15:51 +00:00
|
|
|
use Symfony\Component\Config\Resource\FileResource;
|
|
|
|
use Symfony\Component\Config\Resource\ResourceInterface;
|
2013-03-29 23:21:12 +00:00
|
|
|
use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\InstantiatorInterface;
|
|
|
|
use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\RealServiceInstantiator;
|
2017-04-02 14:23:09 +01:00
|
|
|
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
|
2013-09-02 11:46:47 +01:00
|
|
|
use Symfony\Component\ExpressionLanguage\Expression;
|
2014-09-23 16:21:57 +01:00
|
|
|
use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
|
2010-07-15 14:11:33 +01:00
|
|
|
|
2010-01-04 14:26:20 +00:00
|
|
|
/**
|
2010-07-15 14:11:33 +01:00
|
|
|
* ContainerBuilder is a DI container that provides an API to easily describe services.
|
2010-01-04 14:26:20 +00:00
|
|
|
*
|
2011-03-06 11:40:06 +00:00
|
|
|
* @author Fabien Potencier <fabien@symfony.com>
|
2010-01-04 14:26:20 +00:00
|
|
|
*/
|
2010-08-05 06:34:53 +01:00
|
|
|
class ContainerBuilder extends Container implements TaggedContainerInterface
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2012-11-01 15:08:59 +00:00
|
|
|
/**
|
|
|
|
* @var ExtensionInterface[]
|
|
|
|
*/
|
|
|
|
private $extensions = array();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var ExtensionInterface[]
|
|
|
|
*/
|
|
|
|
private $extensionsByNs = array();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var Definition[]
|
|
|
|
*/
|
|
|
|
private $definitions = array();
|
|
|
|
|
2013-02-06 20:42:01 +00:00
|
|
|
/**
|
|
|
|
* @var Definition[]
|
|
|
|
*/
|
|
|
|
private $obsoleteDefinitions = array();
|
|
|
|
|
2012-11-01 15:08:59 +00:00
|
|
|
/**
|
|
|
|
* @var Alias[]
|
|
|
|
*/
|
2013-06-04 14:12:01 +01:00
|
|
|
private $aliasDefinitions = array();
|
2012-11-01 15:08:59 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var ResourceInterface[]
|
|
|
|
*/
|
|
|
|
private $resources = array();
|
|
|
|
|
2011-03-11 13:50:46 +00:00
|
|
|
private $extensionConfigs = array();
|
2012-11-01 15:08:59 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var Compiler
|
|
|
|
*/
|
2011-03-11 13:50:46 +00:00
|
|
|
private $compiler;
|
2010-12-14 23:25:33 +00:00
|
|
|
|
2017-04-02 14:23:09 +01:00
|
|
|
private $trackResources;
|
2012-12-28 09:40:13 +00:00
|
|
|
|
2013-03-29 23:21:12 +00:00
|
|
|
/**
|
|
|
|
* @var InstantiatorInterface|null
|
|
|
|
*/
|
|
|
|
private $proxyInstantiator;
|
|
|
|
|
2013-09-02 11:46:47 +01:00
|
|
|
/**
|
|
|
|
* @var ExpressionLanguage|null
|
|
|
|
*/
|
|
|
|
private $expressionLanguage;
|
|
|
|
|
2014-09-23 16:21:57 +01:00
|
|
|
/**
|
|
|
|
* @var ExpressionFunctionProviderInterface[]
|
|
|
|
*/
|
|
|
|
private $expressionLanguageProviders = array();
|
|
|
|
|
2017-04-02 14:23:09 +01:00
|
|
|
public function __construct(ParameterBagInterface $parameterBag = null)
|
|
|
|
{
|
|
|
|
parent::__construct($parameterBag);
|
|
|
|
|
|
|
|
$this->trackResources = interface_exists('Symfony\Component\Config\Resource\ResourceInterface');
|
|
|
|
}
|
|
|
|
|
2012-12-28 09:40:13 +00:00
|
|
|
/**
|
|
|
|
* Sets the track resources flag.
|
|
|
|
*
|
|
|
|
* If you are not using the loaders and therefore don't want
|
|
|
|
* to depend on the Config component, set this flag to false.
|
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @param bool $track true if you want to track resources, false otherwise
|
2012-12-28 09:40:13 +00:00
|
|
|
*/
|
|
|
|
public function setResourceTracking($track)
|
|
|
|
{
|
2014-04-12 18:44:00 +01:00
|
|
|
$this->trackResources = (bool) $track;
|
2012-12-28 09:40:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if resources are tracked.
|
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @return bool true if resources are tracked, false otherwise
|
2012-12-28 09:40:13 +00:00
|
|
|
*/
|
|
|
|
public function isTrackingResources()
|
|
|
|
{
|
|
|
|
return $this->trackResources;
|
|
|
|
}
|
|
|
|
|
2013-03-29 23:21:12 +00:00
|
|
|
/**
|
|
|
|
* Sets the instantiator to be used when fetching proxies.
|
|
|
|
*/
|
|
|
|
public function setProxyInstantiator(InstantiatorInterface $proxyInstantiator)
|
|
|
|
{
|
|
|
|
$this->proxyInstantiator = $proxyInstantiator;
|
|
|
|
}
|
|
|
|
|
2011-02-15 06:52:11 +00:00
|
|
|
public function registerExtension(ExtensionInterface $extension)
|
2010-07-16 08:12:58 +01:00
|
|
|
{
|
2011-02-15 06:52:11 +00:00
|
|
|
$this->extensions[$extension->getAlias()] = $extension;
|
2011-02-15 03:14:08 +00:00
|
|
|
|
|
|
|
if (false !== $extension->getNamespace()) {
|
2011-02-15 06:52:11 +00:00
|
|
|
$this->extensionsByNs[$extension->getNamespace()] = $extension;
|
2011-02-15 03:14:08 +00:00
|
|
|
}
|
2010-07-16 08:12:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns an extension by alias or namespace.
|
|
|
|
*
|
|
|
|
* @param string $name An alias or a namespace
|
|
|
|
*
|
|
|
|
* @return ExtensionInterface An extension instance
|
2011-07-20 09:50:27 +01:00
|
|
|
*
|
2012-12-16 12:02:54 +00:00
|
|
|
* @throws LogicException if the extension is not registered
|
2010-07-16 08:12:58 +01:00
|
|
|
*/
|
2011-02-15 06:52:11 +00:00
|
|
|
public function getExtension($name)
|
2010-07-16 08:12:58 +01:00
|
|
|
{
|
2011-02-15 06:52:11 +00:00
|
|
|
if (isset($this->extensions[$name])) {
|
|
|
|
return $this->extensions[$name];
|
2011-02-15 04:58:18 +00:00
|
|
|
}
|
2011-02-05 18:42:07 +00:00
|
|
|
|
2011-02-15 06:52:11 +00:00
|
|
|
if (isset($this->extensionsByNs[$name])) {
|
|
|
|
return $this->extensionsByNs[$name];
|
2010-07-16 08:12:58 +01:00
|
|
|
}
|
|
|
|
|
2011-12-04 23:51:22 +00:00
|
|
|
throw new LogicException(sprintf('Container extension "%s" is not registered', $name));
|
2010-07-16 08:12:58 +01:00
|
|
|
}
|
|
|
|
|
2011-02-05 18:42:07 +00:00
|
|
|
/**
|
2011-02-15 04:58:18 +00:00
|
|
|
* Returns all registered extensions.
|
2011-02-05 18:42:07 +00:00
|
|
|
*
|
2012-11-01 15:08:59 +00:00
|
|
|
* @return ExtensionInterface[] An array of ExtensionInterface
|
2011-02-05 18:42:07 +00:00
|
|
|
*/
|
2011-02-15 06:52:11 +00:00
|
|
|
public function getExtensions()
|
2011-02-05 18:42:07 +00:00
|
|
|
{
|
2011-02-15 06:52:11 +00:00
|
|
|
return $this->extensions;
|
2011-02-05 18:42:07 +00:00
|
|
|
}
|
|
|
|
|
2011-02-13 18:06:41 +00:00
|
|
|
/**
|
|
|
|
* Checks if we have an extension.
|
|
|
|
*
|
|
|
|
* @param string $name The name of the extension
|
2011-12-13 07:50:54 +00:00
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @return bool If the extension exists
|
2011-02-13 18:06:41 +00:00
|
|
|
*/
|
2011-02-15 06:52:11 +00:00
|
|
|
public function hasExtension($name)
|
2010-07-16 08:12:58 +01:00
|
|
|
{
|
2011-02-15 06:52:11 +00:00
|
|
|
return isset($this->extensions[$name]) || isset($this->extensionsByNs[$name]);
|
2011-02-15 04:58:18 +00:00
|
|
|
}
|
|
|
|
|
2010-07-15 14:11:33 +01:00
|
|
|
/**
|
|
|
|
* Returns an array of resources loaded to build this configuration.
|
|
|
|
*
|
|
|
|
* @return ResourceInterface[] An array of resources
|
|
|
|
*/
|
|
|
|
public function getResources()
|
|
|
|
{
|
|
|
|
return array_unique($this->resources);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-12-26 07:50:27 +00:00
|
|
|
* @return $this
|
2010-07-15 14:11:33 +01:00
|
|
|
*/
|
|
|
|
public function addResource(ResourceInterface $resource)
|
|
|
|
{
|
2012-12-28 09:40:13 +00:00
|
|
|
if (!$this->trackResources) {
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2010-07-15 14:11:33 +01:00
|
|
|
$this->resources[] = $resource;
|
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2012-11-01 15:08:59 +00:00
|
|
|
/**
|
|
|
|
* Sets the resources for this configuration.
|
2012-12-11 10:49:22 +00:00
|
|
|
*
|
2012-11-01 15:08:59 +00:00
|
|
|
* @param ResourceInterface[] $resources An array of resources
|
2012-12-11 10:49:22 +00:00
|
|
|
*
|
2016-12-26 07:50:27 +00:00
|
|
|
* @return $this
|
2012-11-01 15:08:59 +00:00
|
|
|
*/
|
2011-09-16 12:43:09 +01:00
|
|
|
public function setResources(array $resources)
|
|
|
|
{
|
2012-12-28 09:40:13 +00:00
|
|
|
if (!$this->trackResources) {
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2011-09-16 12:43:09 +01:00
|
|
|
$this->resources = $resources;
|
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2010-07-15 14:11:33 +01:00
|
|
|
/**
|
|
|
|
* Adds the object class hierarchy as resources.
|
|
|
|
*
|
|
|
|
* @param object $object An object instance
|
2011-07-20 09:50:27 +01:00
|
|
|
*
|
2016-12-26 07:50:27 +00:00
|
|
|
* @return $this
|
2010-07-15 14:11:33 +01:00
|
|
|
*/
|
|
|
|
public function addObjectResource($object)
|
2013-03-29 23:21:12 +00:00
|
|
|
{
|
|
|
|
if ($this->trackResources) {
|
|
|
|
$this->addClassResource(new \ReflectionClass($object));
|
|
|
|
}
|
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds the given class hierarchy as resources.
|
|
|
|
*
|
2016-12-26 07:50:27 +00:00
|
|
|
* @return $this
|
2013-03-29 23:21:12 +00:00
|
|
|
*/
|
|
|
|
public function addClassResource(\ReflectionClass $class)
|
2010-07-15 14:11:33 +01:00
|
|
|
{
|
2012-12-28 09:40:13 +00:00
|
|
|
if (!$this->trackResources) {
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2010-12-23 08:46:49 +00:00
|
|
|
do {
|
2016-02-03 17:21:36 +00:00
|
|
|
if (is_file($class->getFileName())) {
|
|
|
|
$this->addResource(new FileResource($class->getFileName()));
|
|
|
|
}
|
2013-03-29 23:21:12 +00:00
|
|
|
} while ($class = $class->getParentClass());
|
2012-11-16 13:04:00 +00:00
|
|
|
|
|
|
|
return $this;
|
2010-07-15 14:11:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Loads the configuration for an extension.
|
|
|
|
*
|
2010-07-20 15:40:57 +01:00
|
|
|
* @param string $extension The extension alias or namespace
|
|
|
|
* @param array $values An array of values that customizes the extension
|
2010-07-15 14:11:33 +01:00
|
|
|
*
|
2016-12-26 07:50:27 +00:00
|
|
|
* @return $this
|
2011-07-20 09:50:27 +01:00
|
|
|
*
|
2014-12-21 17:00:50 +00:00
|
|
|
* @throws BadMethodCallException When this ContainerBuilder is frozen
|
|
|
|
* @throws \LogicException if the container is frozen
|
2010-07-15 14:11:33 +01:00
|
|
|
*/
|
2011-02-05 18:42:07 +00:00
|
|
|
public function loadFromExtension($extension, array $values = array())
|
2010-07-15 14:11:33 +01:00
|
|
|
{
|
2011-12-05 00:09:11 +00:00
|
|
|
if ($this->isFrozen()) {
|
|
|
|
throw new BadMethodCallException('Cannot load from an extension on a frozen container.');
|
2010-07-16 08:15:22 +01:00
|
|
|
}
|
|
|
|
|
2010-08-24 15:25:08 +01:00
|
|
|
$namespace = $this->getExtension($extension)->getAlias();
|
2010-07-15 14:11:33 +01:00
|
|
|
|
2011-07-09 17:03:05 +01:00
|
|
|
$this->extensionConfigs[$namespace][] = $values;
|
2010-07-15 14:11:33 +01:00
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
2010-12-14 23:25:33 +00:00
|
|
|
/**
|
2011-03-03 12:53:29 +00:00
|
|
|
* Adds a compiler pass.
|
2010-12-14 23:25:33 +00:00
|
|
|
*
|
2011-03-03 12:53:29 +00:00
|
|
|
* @param CompilerPassInterface $pass A compiler pass
|
|
|
|
* @param string $type The type of compiler pass
|
2011-07-20 09:50:27 +01:00
|
|
|
*
|
2016-12-26 07:50:27 +00:00
|
|
|
* @return $this
|
2010-12-14 23:25:33 +00:00
|
|
|
*/
|
2011-01-16 07:53:28 +00:00
|
|
|
public function addCompilerPass(CompilerPassInterface $pass, $type = PassConfig::TYPE_BEFORE_OPTIMIZATION)
|
2010-12-14 23:25:33 +00:00
|
|
|
{
|
2013-09-06 16:04:46 +01:00
|
|
|
$this->getCompiler()->addPass($pass, $type);
|
2011-01-16 07:38:41 +00:00
|
|
|
|
|
|
|
$this->addObjectResource($pass);
|
2012-11-16 13:04:00 +00:00
|
|
|
|
|
|
|
return $this;
|
2010-12-14 23:25:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-03-03 12:53:29 +00:00
|
|
|
* Returns the compiler pass config which can then be modified.
|
2010-12-14 23:25:33 +00:00
|
|
|
*
|
2011-03-03 12:53:29 +00:00
|
|
|
* @return PassConfig The compiler pass config
|
2010-12-14 23:25:33 +00:00
|
|
|
*/
|
2010-12-29 19:12:24 +00:00
|
|
|
public function getCompilerPassConfig()
|
2010-12-14 23:25:33 +00:00
|
|
|
{
|
2013-09-06 16:04:46 +01:00
|
|
|
return $this->getCompiler()->getPassConfig();
|
2011-01-09 09:53:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-03-03 12:53:29 +00:00
|
|
|
* Returns the compiler.
|
2011-01-09 09:53:46 +00:00
|
|
|
*
|
2011-03-03 12:53:29 +00:00
|
|
|
* @return Compiler The compiler
|
2011-01-09 09:53:46 +00:00
|
|
|
*/
|
|
|
|
public function getCompiler()
|
|
|
|
{
|
2011-03-08 13:34:07 +00:00
|
|
|
if (null === $this->compiler) {
|
|
|
|
$this->compiler = new Compiler();
|
|
|
|
}
|
|
|
|
|
2011-01-09 09:53:46 +00:00
|
|
|
return $this->compiler;
|
2010-12-14 23:25:33 +00:00
|
|
|
}
|
|
|
|
|
2011-02-13 18:06:41 +00:00
|
|
|
/**
|
|
|
|
* Returns all Scopes.
|
|
|
|
*
|
|
|
|
* @return array An array of scopes
|
|
|
|
*/
|
2011-01-17 22:28:59 +00:00
|
|
|
public function getScopes()
|
|
|
|
{
|
|
|
|
return $this->scopes;
|
|
|
|
}
|
|
|
|
|
2011-02-13 18:06:41 +00:00
|
|
|
/**
|
2011-05-29 15:19:02 +01:00
|
|
|
* Returns all Scope children.
|
2011-02-13 18:06:41 +00:00
|
|
|
*
|
2016-06-28 06:50:50 +01:00
|
|
|
* @return array An array of scope children
|
2011-02-13 18:06:41 +00:00
|
|
|
*/
|
2011-01-17 22:28:59 +00:00
|
|
|
public function getScopeChildren()
|
|
|
|
{
|
|
|
|
return $this->scopeChildren;
|
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Sets a service.
|
|
|
|
*
|
|
|
|
* @param string $id The service identifier
|
|
|
|
* @param object $service The service instance
|
2011-02-13 18:06:41 +00:00
|
|
|
* @param string $scope The scope
|
2010-10-02 15:47:35 +01:00
|
|
|
*
|
2011-12-04 23:51:22 +00:00
|
|
|
* @throws BadMethodCallException When this ContainerBuilder is frozen
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
2011-01-17 22:28:59 +00:00
|
|
|
public function set($id, $service, $scope = self::SCOPE_CONTAINER)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2013-03-11 21:43:32 +00:00
|
|
|
$id = strtolower($id);
|
2016-09-06 14:11:47 +01:00
|
|
|
$set = isset($this->definitions[$id]);
|
2013-03-11 21:43:32 +00:00
|
|
|
|
2016-09-06 14:11:47 +01:00
|
|
|
if ($this->isFrozen() && ($set || isset($this->obsoleteDefinitions[$id])) && !$this->{$set ? 'definitions' : 'obsoleteDefinitions'}[$id]->isSynthetic()) {
|
2012-12-28 08:42:17 +00:00
|
|
|
// setting a synthetic service on a frozen container is alright
|
2016-09-06 14:11:47 +01:00
|
|
|
throw new BadMethodCallException(sprintf('Setting service "%s" on a frozen container is not allowed.', $id));
|
2010-10-02 15:47:35 +01:00
|
|
|
}
|
|
|
|
|
2016-09-06 14:11:47 +01:00
|
|
|
if ($set) {
|
2013-02-06 20:42:01 +00:00
|
|
|
$this->obsoleteDefinitions[$id] = $this->definitions[$id];
|
|
|
|
}
|
|
|
|
|
2013-06-04 14:12:01 +01:00
|
|
|
unset($this->definitions[$id], $this->aliasDefinitions[$id]);
|
2010-05-06 12:25:53 +01:00
|
|
|
|
2011-01-17 22:28:59 +00:00
|
|
|
parent::set($id, $service, $scope);
|
2013-02-06 20:42:01 +00:00
|
|
|
|
2015-01-06 16:17:37 +00:00
|
|
|
if (isset($this->obsoleteDefinitions[$id]) && $this->obsoleteDefinitions[$id]->isSynchronized(false)) {
|
2013-02-06 20:42:01 +00:00
|
|
|
$this->synchronize($id);
|
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
2010-09-02 11:20:20 +01:00
|
|
|
/**
|
2011-04-19 22:40:18 +01:00
|
|
|
* Removes a service definition.
|
2010-09-02 11:20:20 +01:00
|
|
|
*
|
|
|
|
* @param string $id The service identifier
|
|
|
|
*/
|
2011-04-19 22:40:18 +01:00
|
|
|
public function removeDefinition($id)
|
2010-09-02 11:20:20 +01:00
|
|
|
{
|
2011-01-03 08:07:06 +00:00
|
|
|
unset($this->definitions[strtolower($id)]);
|
2010-09-02 11:20:20 +01:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Returns true if the given service is defined.
|
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param string $id The service identifier
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @return bool true if the service is defined, false otherwise
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
2010-06-27 17:28:29 +01:00
|
|
|
public function has($id)
|
2010-05-06 12:25:53 +01:00
|
|
|
{
|
2011-01-03 08:07:06 +00:00
|
|
|
$id = strtolower($id);
|
|
|
|
|
2013-06-04 14:12:01 +01:00
|
|
|
return isset($this->definitions[$id]) || isset($this->aliasDefinitions[$id]) || parent::has($id);
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets a service.
|
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @param string $id The service identifier
|
|
|
|
* @param int $invalidBehavior The behavior when the service does not exist
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @return object The associated service
|
|
|
|
*
|
2016-02-07 18:10:24 +00:00
|
|
|
* @throws InvalidArgumentException when no definitions are available
|
|
|
|
* @throws ServiceCircularReferenceException When a circular reference is detected
|
|
|
|
* @throws ServiceNotFoundException When the service is not defined
|
2013-03-29 23:21:12 +00:00
|
|
|
* @throws \Exception
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @see Reference
|
|
|
|
*/
|
2010-06-27 17:28:29 +01:00
|
|
|
public function get($id, $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2011-01-03 08:07:06 +00:00
|
|
|
$id = strtolower($id);
|
|
|
|
|
2014-03-26 13:45:08 +00:00
|
|
|
if ($service = parent::get($id, ContainerInterface::NULL_ON_INVALID_REFERENCE)) {
|
2014-03-27 18:14:17 +00:00
|
|
|
return $service;
|
2014-03-26 13:45:08 +00:00
|
|
|
}
|
2014-03-27 18:14:17 +00:00
|
|
|
|
2016-09-04 18:06:49 +01:00
|
|
|
if (!array_key_exists($id, $this->definitions) && isset($this->aliasDefinitions[$id])) {
|
2017-01-10 10:21:41 +00:00
|
|
|
return $this->get((string) $this->aliasDefinitions[$id], $invalidBehavior);
|
2014-03-26 13:45:08 +00:00
|
|
|
}
|
2011-01-03 08:07:06 +00:00
|
|
|
|
2010-05-07 15:09:11 +01:00
|
|
|
try {
|
2014-03-26 13:45:08 +00:00
|
|
|
$definition = $this->getDefinition($id);
|
2016-02-07 18:10:24 +00:00
|
|
|
} catch (ServiceNotFoundException $e) {
|
2013-04-17 12:21:11 +01:00
|
|
|
if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE !== $invalidBehavior) {
|
2014-04-16 08:15:58 +01:00
|
|
|
return;
|
2013-04-17 12:21:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
throw $e;
|
2014-03-26 13:45:08 +00:00
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
2014-03-26 13:45:08 +00:00
|
|
|
$this->loading[$id] = true;
|
2010-05-06 12:25:53 +01:00
|
|
|
|
2014-03-26 13:45:08 +00:00
|
|
|
try {
|
|
|
|
$service = $this->createService($definition, $id);
|
|
|
|
} catch (\Exception $e) {
|
|
|
|
unset($this->loading[$id]);
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2014-03-26 13:45:08 +00:00
|
|
|
if ($e instanceof InactiveScopeException && self::EXCEPTION_ON_INVALID_REFERENCE !== $invalidBehavior) {
|
2014-04-18 21:40:13 +01:00
|
|
|
return;
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2016-05-12 16:11:08 +01:00
|
|
|
throw $e;
|
|
|
|
} catch (\Throwable $e) {
|
|
|
|
unset($this->loading[$id]);
|
|
|
|
|
2014-03-26 13:45:08 +00:00
|
|
|
throw $e;
|
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2014-03-26 13:45:08 +00:00
|
|
|
unset($this->loading[$id]);
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2014-03-26 13:45:08 +00:00
|
|
|
return $service;
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
|
|
|
/**
|
2010-07-15 14:11:33 +01:00
|
|
|
* Merges a ContainerBuilder with the current ContainerBuilder configuration.
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2010-07-15 14:11:33 +01:00
|
|
|
* $container = new ContainerBuilder(array('foo' => 'bar'));
|
2010-05-06 12:25:53 +01:00
|
|
|
* $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
|
2010-07-15 14:11:33 +01:00
|
|
|
* parameter, the value will still be 'bar' as defined in the ContainerBuilder
|
2010-05-06 12:25:53 +01:00
|
|
|
* constructor.
|
2011-02-13 18:06:41 +00:00
|
|
|
*
|
2011-12-05 00:09:11 +00:00
|
|
|
* @throws BadMethodCallException When this ContainerBuilder is frozen
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
2010-07-15 14:11:33 +01:00
|
|
|
public function merge(ContainerBuilder $container)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2011-12-05 00:09:11 +00:00
|
|
|
if ($this->isFrozen()) {
|
|
|
|
throw new BadMethodCallException('Cannot merge on a frozen container.');
|
2010-07-16 08:15:22 +01:00
|
|
|
}
|
|
|
|
|
2010-07-15 14:11:33 +01:00
|
|
|
$this->addDefinitions($container->getDefinitions());
|
|
|
|
$this->addAliases($container->getAliases());
|
2011-03-11 13:50:46 +00:00
|
|
|
$this->getParameterBag()->add($container->getParameterBag()->all());
|
2010-07-15 14:11:33 +01:00
|
|
|
|
2012-12-28 09:40:13 +00:00
|
|
|
if ($this->trackResources) {
|
|
|
|
foreach ($container->getResources() as $resource) {
|
|
|
|
$this->addResource($resource);
|
|
|
|
}
|
2010-07-15 14:11:33 +01:00
|
|
|
}
|
|
|
|
|
2011-02-15 06:52:11 +00:00
|
|
|
foreach ($this->extensions as $name => $extension) {
|
2011-02-15 04:58:18 +00:00
|
|
|
if (!isset($this->extensionConfigs[$name])) {
|
|
|
|
$this->extensionConfigs[$name] = array();
|
2010-07-15 14:11:33 +01:00
|
|
|
}
|
2011-02-15 04:58:18 +00:00
|
|
|
|
|
|
|
$this->extensionConfigs[$name] = array_merge($this->extensionConfigs[$name], $container->getExtensionConfig($name));
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2010-07-15 14:11:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-02-15 04:58:18 +00:00
|
|
|
* Returns the configuration array for the given extension.
|
2010-07-15 14:11:33 +01:00
|
|
|
*
|
2011-02-15 04:58:18 +00:00
|
|
|
* @param string $name The name of the extension
|
2011-02-05 18:42:07 +00:00
|
|
|
*
|
2011-02-15 04:58:18 +00:00
|
|
|
* @return array An array of configuration
|
2011-02-05 18:42:07 +00:00
|
|
|
*/
|
|
|
|
public function getExtensionConfig($name)
|
|
|
|
{
|
2011-02-15 04:58:18 +00:00
|
|
|
if (!isset($this->extensionConfigs[$name])) {
|
2011-03-03 12:53:29 +00:00
|
|
|
$this->extensionConfigs[$name] = array();
|
2011-02-05 18:42:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return $this->extensionConfigs[$name];
|
|
|
|
}
|
|
|
|
|
2012-09-20 22:20:53 +01:00
|
|
|
/**
|
|
|
|
* Prepends a config array to the configs of the given extension.
|
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @param string $name The name of the extension
|
|
|
|
* @param array $config The config to set
|
2012-09-20 22:20:53 +01:00
|
|
|
*/
|
|
|
|
public function prependExtensionConfig($name, array $config)
|
|
|
|
{
|
|
|
|
if (!isset($this->extensionConfigs[$name])) {
|
|
|
|
$this->extensionConfigs[$name] = array();
|
|
|
|
}
|
|
|
|
|
|
|
|
array_unshift($this->extensionConfigs[$name], $config);
|
|
|
|
}
|
|
|
|
|
2010-07-15 14:11:33 +01:00
|
|
|
/**
|
2011-01-16 07:12:36 +00:00
|
|
|
* Compiles the container.
|
2010-07-16 08:15:22 +01:00
|
|
|
*
|
2011-01-16 07:12:36 +00:00
|
|
|
* This method passes the container to compiler
|
|
|
|
* passes whose job is to manipulate and optimize
|
|
|
|
* the container.
|
|
|
|
*
|
|
|
|
* The main compiler passes roughly do four things:
|
2010-07-16 08:15:22 +01:00
|
|
|
*
|
|
|
|
* * The extension configurations are merged;
|
|
|
|
* * Parameter values are resolved;
|
2011-01-16 07:12:36 +00:00
|
|
|
* * The parameter bag is frozen;
|
2010-07-16 08:15:22 +01:00
|
|
|
* * Extension loading is disabled.
|
2010-07-15 14:11:33 +01:00
|
|
|
*/
|
2011-01-16 07:12:36 +00:00
|
|
|
public function compile()
|
2010-07-15 14:11:33 +01:00
|
|
|
{
|
2013-09-06 16:04:46 +01:00
|
|
|
$compiler = $this->getCompiler();
|
2011-03-08 13:34:07 +00:00
|
|
|
|
2012-12-28 09:40:13 +00:00
|
|
|
if ($this->trackResources) {
|
2013-09-06 16:04:46 +01:00
|
|
|
foreach ($compiler->getPassConfig()->getPasses() as $pass) {
|
2012-12-28 09:40:13 +00:00
|
|
|
$this->addObjectResource($pass);
|
|
|
|
}
|
2013-11-09 11:47:52 +00:00
|
|
|
}
|
|
|
|
|
2013-11-13 21:30:16 +00:00
|
|
|
$compiler->compile($this);
|
2013-03-29 23:21:12 +00:00
|
|
|
|
2013-11-09 11:47:52 +00:00
|
|
|
if ($this->trackResources) {
|
2013-03-29 23:21:12 +00:00
|
|
|
foreach ($this->definitions as $definition) {
|
|
|
|
if ($definition->isLazy() && ($class = $definition->getClass()) && class_exists($class)) {
|
|
|
|
$this->addClassResource(new \ReflectionClass($class));
|
|
|
|
}
|
|
|
|
}
|
2011-01-27 19:42:41 +00:00
|
|
|
}
|
|
|
|
|
2011-02-15 04:58:18 +00:00
|
|
|
$this->extensionConfigs = array();
|
2011-01-16 09:17:38 +00:00
|
|
|
|
2011-01-16 07:12:36 +00:00
|
|
|
parent::compile();
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Gets all service ids.
|
|
|
|
*
|
|
|
|
* @return array An array of all defined service ids
|
|
|
|
*/
|
|
|
|
public function getServiceIds()
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2013-06-04 14:12:01 +01:00
|
|
|
return array_unique(array_merge(array_keys($this->getDefinitions()), array_keys($this->aliasDefinitions), parent::getServiceIds()));
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds the service aliases.
|
|
|
|
*/
|
|
|
|
public function addAliases(array $aliases)
|
2010-02-02 10:45:21 +00:00
|
|
|
{
|
2010-05-07 15:09:11 +01:00
|
|
|
foreach ($aliases as $alias => $id) {
|
2010-05-06 12:25:53 +01:00
|
|
|
$this->setAlias($alias, $id);
|
|
|
|
}
|
2010-02-02 10:45:21 +00:00
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the service aliases.
|
|
|
|
*/
|
|
|
|
public function setAliases(array $aliases)
|
2010-01-21 20:28:21 +00:00
|
|
|
{
|
2013-06-04 14:12:01 +01:00
|
|
|
$this->aliasDefinitions = array();
|
2010-05-06 12:25:53 +01:00
|
|
|
$this->addAliases($aliases);
|
2010-01-21 20:28:21 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Sets an alias for an existing service.
|
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @param string $alias The alias to create
|
|
|
|
* @param string|Alias $id The service to alias
|
2012-09-07 23:56:45 +01:00
|
|
|
*
|
2012-12-16 12:02:54 +00:00
|
|
|
* @throws InvalidArgumentException if the id is not a string or an Alias
|
|
|
|
* @throws InvalidArgumentException if the alias is for itself
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function setAlias($alias, $id)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2011-01-03 08:07:06 +00:00
|
|
|
$alias = strtolower($alias);
|
2011-01-07 14:44:29 +00:00
|
|
|
|
|
|
|
if (is_string($id)) {
|
|
|
|
$id = new Alias($id);
|
2011-12-18 13:42:59 +00:00
|
|
|
} elseif (!$id instanceof Alias) {
|
2011-12-04 23:51:22 +00:00
|
|
|
throw new InvalidArgumentException('$id must be a string, or an Alias object.');
|
2011-01-07 14:44:29 +00:00
|
|
|
}
|
2011-01-03 08:07:06 +00:00
|
|
|
|
2015-04-25 17:37:49 +01:00
|
|
|
if ($alias === (string) $id) {
|
2013-04-10 11:24:37 +01:00
|
|
|
throw new InvalidArgumentException(sprintf('An alias can not reference itself, got a circular reference on "%s".', $alias));
|
2011-02-12 14:43:38 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
unset($this->definitions[$alias]);
|
|
|
|
|
2013-06-04 14:12:01 +01:00
|
|
|
$this->aliasDefinitions[$alias] = $id;
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
2010-09-02 11:20:20 +01:00
|
|
|
/**
|
|
|
|
* Removes an alias.
|
|
|
|
*
|
|
|
|
* @param string $alias The alias to remove
|
|
|
|
*/
|
|
|
|
public function removeAlias($alias)
|
|
|
|
{
|
2013-06-04 14:12:01 +01:00
|
|
|
unset($this->aliasDefinitions[strtolower($alias)]);
|
2010-09-02 11:20:20 +01:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Returns true if an alias exists under the given identifier.
|
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param string $id The service identifier
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @return bool true if the alias exists, false otherwise
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function hasAlias($id)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2013-06-04 14:12:01 +01:00
|
|
|
return isset($this->aliasDefinitions[strtolower($id)]);
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Gets all defined aliases.
|
|
|
|
*
|
2012-09-07 23:56:45 +01:00
|
|
|
* @return Alias[] An array of aliases
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function getAliases()
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2013-06-04 14:12:01 +01:00
|
|
|
return $this->aliasDefinitions;
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Gets an alias.
|
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param string $id The service identifier
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2012-08-03 10:22:09 +01:00
|
|
|
* @return Alias An Alias instance
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2011-12-04 23:51:22 +00:00
|
|
|
* @throws InvalidArgumentException if the alias does not exist
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function getAlias($id)
|
|
|
|
{
|
2011-01-03 08:07:06 +00:00
|
|
|
$id = strtolower($id);
|
|
|
|
|
2015-04-25 17:37:49 +01:00
|
|
|
if (!isset($this->aliasDefinitions[$id])) {
|
2011-12-04 23:51:22 +00:00
|
|
|
throw new InvalidArgumentException(sprintf('The service alias "%s" does not exist.', $id));
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2013-06-04 14:12:01 +01:00
|
|
|
return $this->aliasDefinitions[$id];
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Registers a service definition.
|
|
|
|
*
|
|
|
|
* This methods allows for simple registration of service definition
|
|
|
|
* with a fluid interface.
|
|
|
|
*
|
2017-08-08 18:11:20 +01:00
|
|
|
* @param string $id The service identifier
|
|
|
|
* @param string $class|null The service class
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @return Definition A Definition instance
|
|
|
|
*/
|
2010-07-04 17:56:48 +01:00
|
|
|
public function register($id, $class = null)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2015-04-04 18:31:25 +01:00
|
|
|
return $this->setDefinition($id, new Definition($class));
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds the service definitions.
|
|
|
|
*
|
|
|
|
* @param Definition[] $definitions An array of service definitions
|
|
|
|
*/
|
|
|
|
public function addDefinitions(array $definitions)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2010-05-07 15:09:11 +01:00
|
|
|
foreach ($definitions as $id => $definition) {
|
2010-05-06 12:25:53 +01:00
|
|
|
$this->setDefinition($id, $definition);
|
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Sets the service definitions.
|
|
|
|
*
|
2012-11-01 15:08:59 +00:00
|
|
|
* @param Definition[] $definitions An array of service definitions
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function setDefinitions(array $definitions)
|
2010-03-01 17:37:22 +00:00
|
|
|
{
|
2010-05-06 12:25:53 +01:00
|
|
|
$this->definitions = array();
|
|
|
|
$this->addDefinitions($definitions);
|
2010-03-01 17:37:22 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Gets all service definitions.
|
|
|
|
*
|
2012-09-07 23:56:45 +01:00
|
|
|
* @return Definition[] An array of Definition instances
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function getDefinitions()
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2010-05-06 12:25:53 +01:00
|
|
|
return $this->definitions;
|
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Sets a service definition.
|
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param string $id The service identifier
|
|
|
|
* @param Definition $definition A Definition instance
|
2010-10-02 15:47:35 +01:00
|
|
|
*
|
2012-09-07 23:56:45 +01:00
|
|
|
* @return Definition the service definition
|
|
|
|
*
|
2011-12-04 23:57:59 +00:00
|
|
|
* @throws BadMethodCallException When this ContainerBuilder is frozen
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function setDefinition($id, Definition $definition)
|
|
|
|
{
|
2010-10-02 15:47:35 +01:00
|
|
|
if ($this->isFrozen()) {
|
2011-12-04 23:51:22 +00:00
|
|
|
throw new BadMethodCallException('Adding definition to a frozen container is not allowed');
|
2010-10-02 15:47:35 +01:00
|
|
|
}
|
|
|
|
|
2011-01-03 08:07:06 +00:00
|
|
|
$id = strtolower($id);
|
|
|
|
|
2013-06-04 14:12:01 +01:00
|
|
|
unset($this->aliasDefinitions[$id]);
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
return $this->definitions[$id] = $definition;
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Returns true if a service definition exists under the given identifier.
|
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param string $id The service identifier
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @return bool true if the service definition exists, false otherwise
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function hasDefinition($id)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2016-09-04 18:06:49 +01:00
|
|
|
return array_key_exists(strtolower($id), $this->definitions);
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Gets a service definition.
|
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param string $id The service identifier
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @return Definition A Definition instance
|
|
|
|
*
|
2016-02-07 18:10:24 +00:00
|
|
|
* @throws ServiceNotFoundException if the service definition does not exist
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function getDefinition($id)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2011-01-03 08:07:06 +00:00
|
|
|
$id = strtolower($id);
|
|
|
|
|
2016-09-04 18:06:49 +01:00
|
|
|
if (!array_key_exists($id, $this->definitions)) {
|
2016-02-07 18:10:24 +00:00
|
|
|
throw new ServiceNotFoundException($id);
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
return $this->definitions[$id];
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
2010-07-15 14:11:33 +01:00
|
|
|
/**
|
|
|
|
* Gets a service definition by id or alias.
|
|
|
|
*
|
|
|
|
* The method "unaliases" recursively to return a Definition instance.
|
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param string $id The service identifier or alias
|
2010-07-15 14:11:33 +01:00
|
|
|
*
|
|
|
|
* @return Definition A Definition instance
|
|
|
|
*
|
2016-02-07 18:10:24 +00:00
|
|
|
* @throws ServiceNotFoundException if the service definition does not exist
|
2010-07-15 14:11:33 +01:00
|
|
|
*/
|
|
|
|
public function findDefinition($id)
|
|
|
|
{
|
2015-04-25 17:37:49 +01:00
|
|
|
$id = strtolower($id);
|
|
|
|
|
|
|
|
while (isset($this->aliasDefinitions[$id])) {
|
|
|
|
$id = (string) $this->aliasDefinitions[$id];
|
2010-07-15 14:11:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return $this->getDefinition($id);
|
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Creates a service for a service definition.
|
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param Definition $definition A service definition instance
|
|
|
|
* @param string $id The service identifier
|
2014-04-12 18:54:57 +01:00
|
|
|
* @param bool $tryProxy Whether to try proxying the service with a lazy proxy
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2012-09-07 23:56:45 +01:00
|
|
|
* @return object The service described by the service definition
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @throws RuntimeException When the scope is inactive
|
|
|
|
* @throws RuntimeException When the factory definition is incomplete
|
|
|
|
* @throws RuntimeException When the service is a synthetic service
|
2011-12-04 23:51:22 +00:00
|
|
|
* @throws InvalidArgumentException When configure callable is not callable
|
2013-03-29 23:21:12 +00:00
|
|
|
*
|
|
|
|
* @internal this method is public because of PHP 5.3 limitations, do not use it explicitly in your code
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
2013-03-29 23:21:12 +00:00
|
|
|
public function createService(Definition $definition, $id, $tryProxy = true)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2016-11-23 17:45:56 +00:00
|
|
|
if ($definition instanceof DefinitionDecorator) {
|
2016-11-24 10:37:50 +00:00
|
|
|
throw new RuntimeException(sprintf('Constructing service "%s" from a parent definition is not supported at build time.', $id));
|
2016-11-17 00:37:44 +00:00
|
|
|
}
|
|
|
|
|
2013-01-21 22:08:41 +00:00
|
|
|
if ($definition->isSynthetic()) {
|
2013-01-22 07:14:10 +00:00
|
|
|
throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The DIC does not know how to construct this service.', $id));
|
2013-01-21 22:08:41 +00:00
|
|
|
}
|
|
|
|
|
2013-03-29 23:21:12 +00:00
|
|
|
if ($tryProxy && $definition->isLazy()) {
|
|
|
|
$container = $this;
|
|
|
|
|
|
|
|
$proxy = $this
|
|
|
|
->getProxyInstantiator()
|
|
|
|
->instantiateProxy(
|
|
|
|
$container,
|
|
|
|
$definition,
|
|
|
|
$id, function () use ($definition, $id, $container) {
|
|
|
|
return $container->createService($definition, $id, false);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
$this->shareService($definition, $proxy, $id);
|
|
|
|
|
|
|
|
return $proxy;
|
|
|
|
}
|
|
|
|
|
2012-06-26 18:33:57 +01:00
|
|
|
$parameterBag = $this->getParameterBag();
|
|
|
|
|
2010-05-07 15:09:11 +01:00
|
|
|
if (null !== $definition->getFile()) {
|
2012-06-26 18:33:57 +01:00
|
|
|
require_once $parameterBag->resolveValue($definition->getFile());
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
|
|
|
|
2013-01-22 07:14:10 +00:00
|
|
|
$arguments = $this->resolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getArguments())));
|
2010-05-06 12:25:53 +01:00
|
|
|
|
2014-12-23 17:59:20 +00:00
|
|
|
if (null !== $factory = $definition->getFactory()) {
|
|
|
|
if (is_array($factory)) {
|
|
|
|
$factory = array($this->resolveServices($parameterBag->resolveValue($factory[0])), $factory[1]);
|
|
|
|
} elseif (!is_string($factory)) {
|
2014-09-27 17:06:30 +01:00
|
|
|
throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory', $id));
|
|
|
|
}
|
|
|
|
|
2014-12-23 17:59:20 +00:00
|
|
|
$service = call_user_func_array($factory, $arguments);
|
2015-01-06 18:57:38 +00:00
|
|
|
} elseif (null !== $definition->getFactoryMethod(false)) {
|
|
|
|
if (null !== $definition->getFactoryClass(false)) {
|
|
|
|
$factory = $parameterBag->resolveValue($definition->getFactoryClass(false));
|
|
|
|
} elseif (null !== $definition->getFactoryService(false)) {
|
|
|
|
$factory = $this->get($parameterBag->resolveValue($definition->getFactoryService(false)));
|
2010-07-03 23:35:39 +01:00
|
|
|
} else {
|
2013-02-06 15:37:27 +00:00
|
|
|
throw new RuntimeException(sprintf('Cannot create service "%s" from factory method without a factory service or factory class.', $id));
|
2010-07-03 23:35:39 +01:00
|
|
|
}
|
2010-07-04 17:56:48 +01:00
|
|
|
|
2015-01-06 18:57:38 +00:00
|
|
|
$service = call_user_func_array(array($factory, $definition->getFactoryMethod(false)), $arguments);
|
2010-05-07 15:09:11 +01:00
|
|
|
} else {
|
2012-06-26 18:33:57 +01:00
|
|
|
$r = new \ReflectionClass($parameterBag->resolveValue($definition->getClass()));
|
2010-07-04 17:56:48 +01:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
$service = null === $r->getConstructor() ? $r->newInstance() : $r->newInstanceArgs($arguments);
|
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2013-03-29 23:21:12 +00:00
|
|
|
if ($tryProxy || !$definition->isLazy()) {
|
|
|
|
// share only if proxying failed, or if not a proxy
|
|
|
|
$this->shareService($definition, $service, $id);
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2015-10-20 13:28:37 +01:00
|
|
|
$properties = $this->resolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getProperties())));
|
2011-05-03 22:46:02 +01:00
|
|
|
foreach ($properties as $name => $value) {
|
2011-06-27 07:28:54 +01:00
|
|
|
$service->$name = $value;
|
2011-05-03 22:46:02 +01:00
|
|
|
}
|
|
|
|
|
2016-11-19 11:21:18 +00:00
|
|
|
foreach ($definition->getMethodCalls() as $call) {
|
|
|
|
$this->callMethod($service, $call);
|
|
|
|
}
|
|
|
|
|
2010-05-07 15:09:11 +01:00
|
|
|
if ($callable = $definition->getConfigurator()) {
|
2012-11-18 20:27:35 +00:00
|
|
|
if (is_array($callable)) {
|
2015-06-02 14:43:57 +01:00
|
|
|
$callable[0] = $parameterBag->resolveValue($callable[0]);
|
|
|
|
|
|
|
|
if ($callable[0] instanceof Reference) {
|
|
|
|
$callable[0] = $this->get((string) $callable[0], $callable[0]->getInvalidBehavior());
|
|
|
|
} elseif ($callable[0] instanceof Definition) {
|
|
|
|
$callable[0] = $this->createService($callable[0], null);
|
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
|
|
|
|
2010-05-07 15:09:11 +01:00
|
|
|
if (!is_callable($callable)) {
|
2011-12-04 23:51:22 +00:00
|
|
|
throw new InvalidArgumentException(sprintf('The configure callable for class "%s" is not a callable.', get_class($service)));
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
call_user_func($callable, $service);
|
|
|
|
}
|
|
|
|
|
|
|
|
return $service;
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
2013-09-02 11:46:47 +01:00
|
|
|
* Replaces service references by the real service instance and evaluates expressions.
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param mixed $value A value
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2013-09-02 11:46:47 +01:00
|
|
|
* @return mixed The same value with all service references replaced by
|
|
|
|
* the real service instances and all expressions evaluated
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function resolveServices($value)
|
2010-01-04 14:26:20 +00:00
|
|
|
{
|
2010-05-07 15:09:11 +01:00
|
|
|
if (is_array($value)) {
|
2015-10-22 16:08:54 +01:00
|
|
|
foreach ($value as $k => $v) {
|
|
|
|
$value[$k] = $this->resolveServices($v);
|
|
|
|
}
|
2012-11-18 20:27:35 +00:00
|
|
|
} elseif ($value instanceof Reference) {
|
2010-06-27 17:28:29 +01:00
|
|
|
$value = $this->get((string) $value, $value->getInvalidBehavior());
|
2012-11-18 20:27:35 +00:00
|
|
|
} elseif ($value instanceof Definition) {
|
2011-05-23 21:00:38 +01:00
|
|
|
$value = $this->createService($value, null);
|
2013-09-02 11:46:47 +01:00
|
|
|
} elseif ($value instanceof Expression) {
|
2013-09-04 16:17:08 +01:00
|
|
|
$value = $this->getExpressionLanguage()->evaluate($value, array('container' => $this));
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return $value;
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
2010-08-05 06:34:53 +01:00
|
|
|
* Returns service ids for a given tag.
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2013-05-02 18:49:45 +01:00
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* $container->register('foo')->addTag('my.tag', array('hello' => 'world'));
|
|
|
|
*
|
|
|
|
* $serviceIds = $container->findTaggedServiceIds('my.tag');
|
|
|
|
* foreach ($serviceIds as $serviceId => $tags) {
|
|
|
|
* foreach ($tags as $tag) {
|
|
|
|
* echo $tag['hello'];
|
|
|
|
* }
|
|
|
|
* }
|
|
|
|
*
|
2010-08-05 06:34:53 +01:00
|
|
|
* @param string $name The tag name
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2016-06-28 06:50:50 +01:00
|
|
|
* @return array An array of tags with the tagged service as key, holding a list of attribute arrays
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
2010-08-05 06:34:53 +01:00
|
|
|
public function findTaggedServiceIds($name)
|
2010-02-09 08:45:23 +00:00
|
|
|
{
|
2010-08-05 06:34:53 +01:00
|
|
|
$tags = array();
|
2010-05-07 15:09:11 +01:00
|
|
|
foreach ($this->getDefinitions() as $id => $definition) {
|
2013-05-02 18:49:45 +01:00
|
|
|
if ($definition->hasTag($name)) {
|
2010-08-05 06:34:53 +01:00
|
|
|
$tags[$id] = $definition->getTag($name);
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-05 06:34:53 +01:00
|
|
|
return $tags;
|
2010-02-09 08:45:23 +00:00
|
|
|
}
|
|
|
|
|
2012-09-16 16:15:14 +01:00
|
|
|
/**
|
|
|
|
* Returns all tags the defined services use.
|
|
|
|
*
|
|
|
|
* @return array An array of tags
|
|
|
|
*/
|
|
|
|
public function findTags()
|
|
|
|
{
|
|
|
|
$tags = array();
|
|
|
|
foreach ($this->getDefinitions() as $id => $definition) {
|
|
|
|
$tags = array_merge(array_keys($definition->getTags()), $tags);
|
|
|
|
}
|
|
|
|
|
|
|
|
return array_unique($tags);
|
|
|
|
}
|
|
|
|
|
2014-09-23 16:21:57 +01:00
|
|
|
public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
|
|
|
|
{
|
|
|
|
$this->expressionLanguageProviders[] = $provider;
|
|
|
|
}
|
|
|
|
|
2014-12-17 09:56:43 +00:00
|
|
|
/**
|
|
|
|
* @return ExpressionFunctionProviderInterface[]
|
|
|
|
*/
|
|
|
|
public function getExpressionLanguageProviders()
|
|
|
|
{
|
|
|
|
return $this->expressionLanguageProviders;
|
|
|
|
}
|
|
|
|
|
2011-02-13 18:06:41 +00:00
|
|
|
/**
|
|
|
|
* Returns the Service Conditionals.
|
|
|
|
*
|
2016-06-28 06:50:50 +01:00
|
|
|
* @param mixed $value An array of conditionals to return
|
2011-12-13 07:50:54 +00:00
|
|
|
*
|
2011-02-13 18:06:41 +00:00
|
|
|
* @return array An array of Service conditionals
|
|
|
|
*/
|
2012-07-09 13:50:58 +01:00
|
|
|
public static function getServiceConditionals($value)
|
2010-05-06 12:25:53 +01:00
|
|
|
{
|
|
|
|
$services = array();
|
2010-02-09 08:45:23 +00:00
|
|
|
|
2010-05-07 15:09:11 +01:00
|
|
|
if (is_array($value)) {
|
2010-05-08 14:32:30 +01:00
|
|
|
foreach ($value as $v) {
|
2010-05-06 12:25:53 +01:00
|
|
|
$services = array_unique(array_merge($services, self::getServiceConditionals($v)));
|
|
|
|
}
|
2017-09-07 10:04:22 +01:00
|
|
|
} elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
|
2010-05-06 12:25:53 +01:00
|
|
|
$services[] = (string) $value;
|
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
return $services;
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|
2013-02-06 20:42:01 +00:00
|
|
|
|
2013-03-29 23:21:12 +00:00
|
|
|
/**
|
|
|
|
* Retrieves the currently set proxy instantiator or instantiates one.
|
|
|
|
*
|
|
|
|
* @return InstantiatorInterface
|
|
|
|
*/
|
|
|
|
private function getProxyInstantiator()
|
|
|
|
{
|
|
|
|
if (!$this->proxyInstantiator) {
|
|
|
|
$this->proxyInstantiator = new RealServiceInstantiator();
|
|
|
|
}
|
|
|
|
|
|
|
|
return $this->proxyInstantiator;
|
|
|
|
}
|
|
|
|
|
2013-02-06 20:42:01 +00:00
|
|
|
/**
|
|
|
|
* Synchronizes a service change.
|
|
|
|
*
|
|
|
|
* This method updates all services that depend on the given
|
|
|
|
* service by calling all methods referencing it.
|
|
|
|
*
|
|
|
|
* @param string $id A service id
|
2015-01-06 16:17:37 +00:00
|
|
|
*
|
|
|
|
* @deprecated since version 2.7, will be removed in 3.0.
|
2013-02-06 20:42:01 +00:00
|
|
|
*/
|
|
|
|
private function synchronize($id)
|
|
|
|
{
|
2015-01-06 16:17:37 +00:00
|
|
|
if ('request' !== $id) {
|
2015-06-07 07:33:05 +01:00
|
|
|
@trigger_error('The '.__METHOD__.' method is deprecated in version 2.7 and will be removed in version 3.0.', E_USER_DEPRECATED);
|
2015-01-06 16:17:37 +00:00
|
|
|
}
|
|
|
|
|
2013-02-06 20:42:01 +00:00
|
|
|
foreach ($this->definitions as $definitionId => $definition) {
|
|
|
|
// only check initialized services
|
|
|
|
if (!$this->initialized($definitionId)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($definition->getMethodCalls() as $call) {
|
|
|
|
foreach ($call[1] as $argument) {
|
|
|
|
if ($argument instanceof Reference && $id == (string) $argument) {
|
|
|
|
$this->callMethod($this->get($definitionId), $call);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private function callMethod($service, $call)
|
|
|
|
{
|
|
|
|
$services = self::getServiceConditionals($call[1]);
|
|
|
|
|
|
|
|
foreach ($services as $s) {
|
|
|
|
if (!$this->has($s)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-20 13:28:37 +01:00
|
|
|
call_user_func_array(array($service, $call[0]), $this->resolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1]))));
|
2013-02-06 20:42:01 +00:00
|
|
|
}
|
2013-03-29 23:21:12 +00:00
|
|
|
|
|
|
|
/**
|
2014-12-21 17:00:50 +00:00
|
|
|
* Shares a given service in the container.
|
2013-03-29 23:21:12 +00:00
|
|
|
*
|
2017-01-10 10:21:41 +00:00
|
|
|
* @param Definition $definition
|
|
|
|
* @param mixed $service
|
|
|
|
* @param string|null $id
|
2013-03-29 23:21:12 +00:00
|
|
|
*
|
|
|
|
* @throws InactiveScopeException
|
|
|
|
*/
|
|
|
|
private function shareService(Definition $definition, $service, $id)
|
|
|
|
{
|
2017-01-10 10:21:41 +00:00
|
|
|
if (null !== $id && self::SCOPE_PROTOTYPE !== $scope = $definition->getScope()) {
|
2013-03-29 23:21:12 +00:00
|
|
|
if (self::SCOPE_CONTAINER !== $scope && !isset($this->scopedServices[$scope])) {
|
|
|
|
throw new InactiveScopeException($id, $scope);
|
|
|
|
}
|
|
|
|
|
|
|
|
$this->services[$lowerId = strtolower($id)] = $service;
|
|
|
|
|
|
|
|
if (self::SCOPE_CONTAINER !== $scope) {
|
|
|
|
$this->scopedServices[$scope][$lowerId] = $service;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-09-02 11:46:47 +01:00
|
|
|
|
|
|
|
private function getExpressionLanguage()
|
|
|
|
{
|
|
|
|
if (null === $this->expressionLanguage) {
|
|
|
|
if (!class_exists('Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
|
|
|
|
throw new RuntimeException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
|
|
|
|
}
|
2014-09-23 16:21:57 +01:00
|
|
|
$this->expressionLanguage = new ExpressionLanguage(null, $this->expressionLanguageProviders);
|
2013-09-02 11:46:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return $this->expressionLanguage;
|
|
|
|
}
|
2010-01-04 14:26:20 +00:00
|
|
|
}
|