vendor/symfony/dependency-injection/Definition.php line 64

  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 Symfony\Component\DependencyInjection\Argument\BoundArgument;
  15. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  16. use Symfony\Component\DependencyInjection\Exception\OutOfBoundsException;
  18. /**
  19.  * Definition represents a service definition.
  20.  *
  21.  * @author Fabien Potencier <fabien@symfony.com>
  22.  */
  23. class Definition
  24. {
  25.     private const DEFAULT_DEPRECATION_TEMPLATE = 'The "%service_id%" service is deprecated. You should stop using it, as it will be removed in the future.';
  27.     private ?string $class = null;
  28.     private ?string $file = null;
  29.     private string|array|null $factory = null;
  30.     private bool $shared = true;
  31.     private array $deprecation = [];
  32.     private array $properties = [];
  33.     private array $calls = [];
  34.     private array $instanceof = [];
  35.     private bool $autoconfigured = false;
  36.     private string|array|null $configurator = null;
  37.     private array $tags = [];
  38.     private bool $public = false;
  39.     private bool $synthetic = false;
  40.     private bool $abstract = false;
  41.     private bool $lazy = false;
  42.     private ?array $decoratedService = null;
  43.     private bool $autowired = false;
  44.     private array $changes = [];
  45.     private array $bindings = [];
  46.     private array $errors = [];
  48.     protected $arguments = [];
  50.     /**
  51.      * @internal
  52.      *
  53.      * Used to store the name of the inner id when using service decoration together with autowiring
  54.      */
  55.     public ?string $innerServiceId = null;
  57.     /**
  58.      * @internal
  59.      *
  60.      * Used to store the behavior to follow when using service decoration and the decorated service is invalid
  61.      */
  62.     public ?int $decorationOnInvalid = null;
  64.     public function __construct(string $class = null, array $arguments = [])
  65.     {
  66.         if (null !== $class) {
  67.             $this->setClass($class);
  68.         }
  69.         $this->arguments = $arguments;
  70.     }
  72.     /**
  73.      * Returns all changes tracked for the Definition object.
  74.      */
  75.     public function getChanges(): array
  76.     {
  77.         return $this->changes;
  78.     }
  80.     /**
  81.      * Sets the tracked changes for the Definition object.
  82.      *
  83.      * @param array $changes An array of changes for this Definition
  84.      *
  85.      * @return $this
  86.      */
  87.     public function setChanges(array $changes): static
  88.     {
  89.         $this->changes = $changes;
  91.         return $this;
  92.     }
  94.     /**
  95.      * Sets a factory.
  96.      *
  97.      * @param string|array|Reference|null $factory A PHP function, reference or an array containing a class/Reference and a method to call
  98.      *
  99.      * @return $this
  100.      */
  101.     public function setFactory(string|array|Reference|null $factory): static
  102.     {
  103.         $this->changes['factory'] = true;
  105.         if (\is_string($factory) && str_contains($factory, '::')) {
  106.             $factory = explode('::', $factory, 2);
  107.         } elseif ($factory instanceof Reference) {
  108.             $factory = [$factory, '__invoke'];
  109.         }
  111.         $this->factory = $factory;
  113.         return $this;
  114.     }
  116.     /**
  117.      * Gets the factory.
  118.      *
  119.      * @return string|array|null The PHP function or an array containing a class/Reference and a method to call
  120.      */
  121.     public function getFactory(): string|array|null
  122.     {
  123.         return $this->factory;
  124.     }
  126.     /**
  127.      * Sets the service that this service is decorating.
  128.      *
  129.      * @param string|null $id        The decorated service id, use null to remove decoration
  130.      * @param string|null $renamedId The new decorated service id
  131.      *
  132.      * @return $this
  133.      *
  134.      * @throws InvalidArgumentException in case the decorated service id and the new decorated service id are equals
  135.      */
  136.     public function setDecoratedService(?string $id, string $renamedId = null, int $priority = 0, int $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE): static
  137.     {
  138.         if ($renamedId && $id === $renamedId) {
  139.             throw new InvalidArgumentException(sprintf('The decorated service inner name for "%s" must be different than the service name itself.', $id));
  140.         }
  142.         $this->changes['decorated_service'] = true;
  144.         if (null === $id) {
  145.             $this->decoratedService = null;
  146.         } else {
  147.             $this->decoratedService = [$id, $renamedId, $priority];
  149.             if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE !== $invalidBehavior) {
  150.                 $this->decoratedService[] = $invalidBehavior;
  151.             }
  152.         }
  154.         return $this;
  155.     }
  157.     /**
  158.      * Gets the service that this service is decorating.
  159.      *
  160.      * @return array|null An array composed of the decorated service id, the new id for it and the priority of decoration, null if no service is decorated
  161.      */
  162.     public function getDecoratedService(): ?array
  163.     {
  164.         return $this->decoratedService;
  165.     }
  167.     /**
  168.      * Sets the service class.
  169.      *
  170.      * @return $this
  171.      */
  172.     public function setClass(?string $class): static
  173.     {
  174.         $this->changes['class'] = true;
  176.         $this->class = $class;
  178.         return $this;
  179.     }
  181.     /**
  182.      * Gets the service class.
  183.      */
  184.     public function getClass(): ?string
  185.     {
  186.         return $this->class;
  187.     }
  189.     /**
  190.      * Sets the arguments to pass to the service constructor/factory method.
  191.      *
  192.      * @return $this
  193.      */
  194.     public function setArguments(array $arguments): static
  195.     {
  196.         $this->arguments = $arguments;
  198.         return $this;
  199.     }
  201.     /**
  202.      * Sets the properties to define when creating the service.
  203.      *
  204.      * @return $this
  205.      */
  206.     public function setProperties(array $properties): static
  207.     {
  208.         $this->properties = $properties;
  210.         return $this;
  211.     }
  213.     /**
  214.      * Gets the properties to define when creating the service.
  215.      */
  216.     public function getProperties(): array
  217.     {
  218.         return $this->properties;
  219.     }
  221.     /**
  222.      * Sets a specific property.
  223.      *
  224.      * @return $this
  225.      */
  226.     public function setProperty(string $name, mixed $value): static
  227.     {
  228.         $this->properties[$name] = $value;
  230.         return $this;
  231.     }
  233.     /**
  234.      * Adds an argument to pass to the service constructor/factory method.
  235.      *
  236.      * @return $this
  237.      */
  238.     public function addArgument(mixed $argument): static
  239.     {
  240.         $this->arguments[] = $argument;
  242.         return $this;
  243.     }
  245.     /**
  246.      * Replaces a specific argument.
  247.      *
  248.      * @return $this
  249.      *
  250.      * @throws OutOfBoundsException When the replaced argument does not exist
  251.      */
  252.     public function replaceArgument(int|string $index, mixed $argument): static
  253.     {
  254.         if (0 === \count($this->arguments)) {
  255.             throw new OutOfBoundsException(sprintf('Cannot replace arguments for class "%s" if none have been configured yet.', $this->class));
  256.         }
  258.         if (\is_int($index) && ($index < 0 || $index > \count($this->arguments) - 1)) {
  259.             throw new OutOfBoundsException(sprintf('The index "%d" is not in the range [0, %d] of the arguments of class "%s".', $index, \count($this->arguments) - 1, $this->class));
  260.         }
  262.         if (!\array_key_exists($index, $this->arguments)) {
  263.             throw new OutOfBoundsException(sprintf('The argument "%s" doesn\'t exist in class "%s".', $index, $this->class));
  264.         }
  266.         $this->arguments[$index] = $argument;
  268.         return $this;
  269.     }
  271.     /**
  272.      * Sets a specific argument.
  273.      *
  274.      * @return $this
  275.      */
  276.     public function setArgument(int|string $key, mixed $value): static
  277.     {
  278.         $this->arguments[$key] = $value;
  280.         return $this;
  281.     }
  283.     /**
  284.      * Gets the arguments to pass to the service constructor/factory method.
  285.      */
  286.     public function getArguments(): array
  287.     {
  288.         return $this->arguments;
  289.     }
  291.     /**
  292.      * Gets an argument to pass to the service constructor/factory method.
  293.      *
  294.      * @throws OutOfBoundsException When the argument does not exist
  295.      */
  296.     public function getArgument(int|string $index): mixed
  297.     {
  298.         if (!\array_key_exists($index, $this->arguments)) {
  299.             throw new OutOfBoundsException(sprintf('The argument "%s" doesn\'t exist in class "%s".', $index, $this->class));
  300.         }
  302.         return $this->arguments[$index];
  303.     }
  305.     /**
  306.      * Sets the methods to call after service initialization.
  307.      *
  308.      * @return $this
  309.      */
  310.     public function setMethodCalls(array $calls = []): static
  311.     {
  312.         $this->calls = [];
  313.         foreach ($calls as $call) {
  314.             $this->addMethodCall($call[0], $call[1], $call[2] ?? false);
  315.         }
  317.         return $this;
  318.     }
  320.     /**
  321.      * Adds a method to call after service initialization.
  322.      *
  323.      * @param string $method       The method name to call
  324.      * @param array  $arguments    An array of arguments to pass to the method call
  325.      * @param bool   $returnsClone Whether the call returns the service instance or not
  326.      *
  327.      * @return $this
  328.      *
  329.      * @throws InvalidArgumentException on empty $method param
  330.      */
  331.     public function addMethodCall(string $method, array $arguments = [], bool $returnsClone = false): static
  332.     {
  333.         if (empty($method)) {
  334.             throw new InvalidArgumentException('Method name cannot be empty.');
  335.         }
  336.         $this->calls[] = $returnsClone ? [$method, $arguments, true] : [$method, $arguments];
  338.         return $this;
  339.     }
  341.     /**
  342.      * Removes a method to call after service initialization.
  343.      *
  344.      * @return $this
  345.      */
  346.     public function removeMethodCall(string $method): static
  347.     {
  348.         foreach ($this->calls as $i => $call) {
  349.             if ($call[0] === $method) {
  350.                 unset($this->calls[$i]);
  351.             }
  352.         }
  354.         return $this;
  355.     }
  357.     /**
  358.      * Check if the current definition has a given method to call after service initialization.
  359.      */
  360.     public function hasMethodCall(string $method): bool
  361.     {
  362.         foreach ($this->calls as $call) {
  363.             if ($call[0] === $method) {
  364.                 return true;
  365.             }
  366.         }
  368.         return false;
  369.     }
  371.     /**
  372.      * Gets the methods to call after service initialization.
  373.      */
  374.     public function getMethodCalls(): array
  375.     {
  376.         return $this->calls;
  377.     }
  379.     /**
  380.      * Sets the definition templates to conditionally apply on the current definition, keyed by parent interface/class.
  381.      *
  382.      * @param ChildDefinition[] $instanceof
  383.      *
  384.      * @return $this
  385.      */
  386.     public function setInstanceofConditionals(array $instanceof): static
  387.     {
  388.         $this->instanceof = $instanceof;
  390.         return $this;
  391.     }
  393.     /**
  394.      * Gets the definition templates to conditionally apply on the current definition, keyed by parent interface/class.
  395.      *
  396.      * @return ChildDefinition[]
  397.      */
  398.     public function getInstanceofConditionals(): array
  399.     {
  400.         return $this->instanceof;
  401.     }
  403.     /**
  404.      * Sets whether or not instanceof conditionals should be prepended with a global set.
  405.      *
  406.      * @return $this
  407.      */
  408.     public function setAutoconfigured(bool $autoconfigured): static
  409.     {
  410.         $this->changes['autoconfigured'] = true;
  412.         $this->autoconfigured = $autoconfigured;
  414.         return $this;
  415.     }
  417.     public function isAutoconfigured(): bool
  418.     {
  419.         return $this->autoconfigured;
  420.     }
  422.     /**
  423.      * Sets tags for this definition.
  424.      *
  425.      * @return $this
  426.      */
  427.     public function setTags(array $tags): static
  428.     {
  429.         $this->tags = $tags;
  431.         return $this;
  432.     }
  434.     /**
  435.      * Returns all tags.
  436.      */
  437.     public function getTags(): array
  438.     {
  439.         return $this->tags;
  440.     }
  442.     /**
  443.      * Gets a tag by name.
  444.      */
  445.     public function getTag(string $name): array
  446.     {
  447.         return $this->tags[$name] ?? [];
  448.     }
  450.     /**
  451.      * Adds a tag for this definition.
  452.      *
  453.      * @return $this
  454.      */
  455.     public function addTag(string $name, array $attributes = []): static
  456.     {
  457.         $this->tags[$name][] = $attributes;
  459.         return $this;
  460.     }
  462.     /**
  463.      * Whether this definition has a tag with the given name.
  464.      */
  465.     public function hasTag(string $name): bool
  466.     {
  467.         return isset($this->tags[$name]);
  468.     }
  470.     /**
  471.      * Clears all tags for a given name.
  472.      *
  473.      * @return $this
  474.      */
  475.     public function clearTag(string $name): static
  476.     {
  477.         unset($this->tags[$name]);
  479.         return $this;
  480.     }
  482.     /**
  483.      * Clears the tags for this definition.
  484.      *
  485.      * @return $this
  486.      */
  487.     public function clearTags(): static
  488.     {
  489.         $this->tags = [];
  491.         return $this;
  492.     }
  494.     /**
  495.      * Sets a file to require before creating the service.
  496.      *
  497.      * @return $this
  498.      */
  499.     public function setFile(?string $file): static
  500.     {
  501.         $this->changes['file'] = true;
  503.         $this->file = $file;
  505.         return $this;
  506.     }
  508.     /**
  509.      * Gets the file to require before creating the service.
  510.      */
  511.     public function getFile(): ?string
  512.     {
  513.         return $this->file;
  514.     }
  516.     /**
  517.      * Sets if the service must be shared or not.
  518.      *
  519.      * @return $this
  520.      */
  521.     public function setShared(bool $shared): static
  522.     {
  523.         $this->changes['shared'] = true;
  525.         $this->shared = $shared;
  527.         return $this;
  528.     }
  530.     /**
  531.      * Whether this service is shared.
  532.      */
  533.     public function isShared(): bool
  534.     {
  535.         return $this->shared;
  536.     }
  538.     /**
  539.      * Sets the visibility of this service.
  540.      *
  541.      * @return $this
  542.      */
  543.     public function setPublic(bool $boolean): static
  544.     {
  545.         $this->changes['public'] = true;
  547.         $this->public = $boolean;
  549.         return $this;
  550.     }
  552.     /**
  553.      * Whether this service is public facing.
  554.      */
  555.     public function isPublic(): bool
  556.     {
  557.         return $this->public;
  558.     }
  560.     /**
  561.      * Whether this service is private.
  562.      */
  563.     public function isPrivate(): bool
  564.     {
  565.         return !$this->public;
  566.     }
  568.     /**
  569.      * Sets the lazy flag of this service.
  570.      *
  571.      * @return $this
  572.      */
  573.     public function setLazy(bool $lazy): static
  574.     {
  575.         $this->changes['lazy'] = true;
  577.         $this->lazy = $lazy;
  579.         return $this;
  580.     }
  582.     /**
  583.      * Whether this service is lazy.
  584.      */
  585.     public function isLazy(): bool
  586.     {
  587.         return $this->lazy;
  588.     }
  590.     /**
  591.      * Sets whether this definition is synthetic, that is not constructed by the
  592.      * container, but dynamically injected.
  593.      *
  594.      * @return $this
  595.      */
  596.     public function setSynthetic(bool $boolean): static
  597.     {
  598.         $this->synthetic = $boolean;
  600.         if (!isset($this->changes['public'])) {
  601.             $this->setPublic(true);
  602.         }
  604.         return $this;
  605.     }
  607.     /**
  608.      * Whether this definition is synthetic, that is not constructed by the
  609.      * container, but dynamically injected.
  610.      */
  611.     public function isSynthetic(): bool
  612.     {
  613.         return $this->synthetic;
  614.     }
  616.     /**
  617.      * Whether this definition is abstract, that means it merely serves as a
  618.      * template for other definitions.
  619.      *
  620.      * @return $this
  621.      */
  622.     public function setAbstract(bool $boolean): static
  623.     {
  624.         $this->abstract = $boolean;
  626.         return $this;
  627.     }
  629.     /**
  630.      * Whether this definition is abstract, that means it merely serves as a
  631.      * template for other definitions.
  632.      */
  633.     public function isAbstract(): bool
  634.     {
  635.         return $this->abstract;
  636.     }
  638.     /**
  639.      * Whether this definition is deprecated, that means it should not be called
  640.      * anymore.
  641.      *
  642.      * @param string $package The name of the composer package that is triggering the deprecation
  643.      * @param string $version The version of the package that introduced the deprecation
  644.      * @param string $message The deprecation message to use
  645.      *
  646.      * @return $this
  647.      *
  648.      * @throws InvalidArgumentException when the message template is invalid
  649.      */
  650.     public function setDeprecated(string $package, string $version, string $message): static
  651.     {
  652.         if ('' !== $message) {
  653.             if (preg_match('#[\r\n]|\*/#', $message)) {
  654.                 throw new InvalidArgumentException('Invalid characters found in deprecation template.');
  655.             }
  657.             if (!str_contains($message, '%service_id%')) {
  658.                 throw new InvalidArgumentException('The deprecation template must contain the "%service_id%" placeholder.');
  659.             }
  660.         }
  662.         $this->changes['deprecated'] = true;
  663.         $this->deprecation = ['package' => $package, 'version' => $version, 'message' => $message ?: self::DEFAULT_DEPRECATION_TEMPLATE];
  665.         return $this;
  666.     }
  668.     /**
  669.      * Whether this definition is deprecated, that means it should not be called
  670.      * anymore.
  671.      */
  672.     public function isDeprecated(): bool
  673.     {
  674.         return (bool) $this->deprecation;
  675.     }
  677.     /**
  678.      * @param string $id Service id relying on this definition
  679.      */
  680.     public function getDeprecation(string $id): array
  681.     {
  682.         return [
  683.             'package' => $this->deprecation['package'],
  684.             'version' => $this->deprecation['version'],
  685.             'message' => str_replace('%service_id%', $id, $this->deprecation['message']),
  686.         ];
  687.     }
  689.     /**
  690.      * Sets a configurator to call after the service is fully initialized.
  691.      *
  692.      * @param string|array|Reference|null $configurator A PHP function, reference or an array containing a class/Reference and a method to call
  693.      *
  694.      * @return $this
  695.      */
  696.     public function setConfigurator(string|array|Reference|null $configurator): static
  697.     {
  698.         $this->changes['configurator'] = true;
  700.         if (\is_string($configurator) && str_contains($configurator, '::')) {
  701.             $configurator = explode('::', $configurator, 2);
  702.         } elseif ($configurator instanceof Reference) {
  703.             $configurator = [$configurator, '__invoke'];
  704.         }
  706.         $this->configurator = $configurator;
  708.         return $this;
  709.     }
  711.     /**
  712.      * Gets the configurator to call after the service is fully initialized.
  713.      */
  714.     public function getConfigurator(): string|array|null
  715.     {
  716.         return $this->configurator;
  717.     }
  719.     /**
  720.      * Is the definition autowired?
  721.      */
  722.     public function isAutowired(): bool
  723.     {
  724.         return $this->autowired;
  725.     }
  727.     /**
  728.      * Enables/disables autowiring.
  729.      *
  730.      * @return $this
  731.      */
  732.     public function setAutowired(bool $autowired): static
  733.     {
  734.         $this->changes['autowired'] = true;
  736.         $this->autowired = $autowired;
  738.         return $this;
  739.     }
  741.     /**
  742.      * Gets bindings.
  743.      *
  744.      * @return BoundArgument[]
  745.      */
  746.     public function getBindings(): array
  747.     {
  748.         return $this->bindings;
  749.     }
  751.     /**
  752.      * Sets bindings.
  753.      *
  754.      * Bindings map $named or FQCN arguments to values that should be
  755.      * injected in the matching parameters (of the constructor, of methods
  756.      * called and of controller actions).
  757.      *
  758.      * @return $this
  759.      */
  760.     public function setBindings(array $bindings): static
  761.     {
  762.         foreach ($bindings as $key => $binding) {
  763.             if (0 < strpos($key, '$') && $key !== $k = preg_replace('/[ \t]*\$/', ' $', $key)) {
  764.                 unset($bindings[$key]);
  765.                 $bindings[$key = $k] = $binding;
  766.             }
  767.             if (!$binding instanceof BoundArgument) {
  768.                 $bindings[$key] = new BoundArgument($binding);
  769.             }
  770.         }
  772.         $this->bindings = $bindings;
  774.         return $this;
  775.     }
  777.     /**
  778.      * Add an error that occurred when building this Definition.
  779.      *
  780.      * @return $this
  781.      */
  782.     public function addError(string|\Closure|Definition $error): static
  783.     {
  784.         if ($error instanceof self) {
  785.             $this->errors = array_merge($this->errors, $error->errors);
  786.         } else {
  787.             $this->errors[] = $error;
  788.         }
  790.         return $this;
  791.     }
  793.     /**
  794.      * Returns any errors that occurred while building this Definition.
  795.      */
  796.     public function getErrors(): array
  797.     {
  798.         foreach ($this->errors as $i => $error) {
  799.             if ($error instanceof \Closure) {
  800.                 $this->errors[$i] = (string) $error();
  801.             } elseif (!\is_string($error)) {
  802.                 $this->errors[$i] = (string) $error;
  803.             }
  804.         }
  806.         return $this->errors;
  807.     }
  809.     public function hasErrors(): bool
  810.     {
  811.         return (bool) $this->errors;
  812.     }
  813. }