Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/http-kernel/ControllerMetadata/ArgumentMetadata.php line 140

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\HttpKernel\ControllerMetadata;
  14. use Symfony\Component\HttpKernel\Attribute\ArgumentInterface;
  16. /**
  17.  * Responsible for storing metadata of an argument.
  18.  *
  19.  * @author Iltar van der Berg <kjarli@gmail.com>
  20.  */
  21. class ArgumentMetadata
  22. {
  23.     public const IS_INSTANCEOF = 2;
  25.     private $name;
  26.     private $type;
  27.     private $isVariadic;
  28.     private $hasDefaultValue;
  29.     private $defaultValue;
  30.     private $isNullable;
  31.     private $attributes;
  33.     /**
  34.      * @param object[] $attributes
  35.      */
  36.     public function __construct(string $name, ?string $type, bool $isVariadic, bool $hasDefaultValue, $defaultValue, bool $isNullable = false, $attributes = [])
  37.     {
  38.         $this->name = $name;
  39.         $this->type = $type;
  40.         $this->isVariadic = $isVariadic;
  41.         $this->hasDefaultValue = $hasDefaultValue;
  42.         $this->defaultValue = $defaultValue;
  43.         $this->isNullable = $isNullable || null === $type || ($hasDefaultValue && null === $defaultValue);
  45.         if (null === $attributes || $attributes instanceof ArgumentInterface) {
  46.             trigger_deprecation('symfony/http-kernel', '5.3', 'The "%s" constructor expects an array of PHP attributes as last argument, %s given.', __CLASS__, get_debug_type($attributes));
  47.             $attributes = $attributes ? [$attributes] : [];
  48.         }
  50.         $this->attributes = $attributes;
  51.     }
  53.     /**
  54.      * Returns the name as given in PHP, $foo would yield "foo".
  55.      *
  56.      * @return string
  57.      */
  58.     public function getName()
  59.     {
  60.         return $this->name;
  61.     }
  63.     /**
  64.      * Returns the type of the argument.
  65.      *
  66.      * The type is the PHP class in 5.5+ and additionally the basic type in PHP 7.0+.
  67.      *
  68.      * @return string|null
  69.      */
  70.     public function getType()
  71.     {
  72.         return $this->type;
  73.     }
  75.     /**
  76.      * Returns whether the argument is defined as "...$variadic".
  77.      *
  78.      * @return bool
  79.      */
  80.     public function isVariadic()
  81.     {
  82.         return $this->isVariadic;
  83.     }
  85.     /**
  86.      * Returns whether the argument has a default value.
  87.      *
  88.      * Implies whether an argument is optional.
  89.      *
  90.      * @return bool
  91.      */
  92.     public function hasDefaultValue()
  93.     {
  94.         return $this->hasDefaultValue;
  95.     }
  97.     /**
  98.      * Returns whether the argument accepts null values.
  99.      *
  100.      * @return bool
  101.      */
  102.     public function isNullable()
  103.     {
  104.         return $this->isNullable;
  105.     }
  107.     /**
  108.      * Returns the default value of the argument.
  109.      *
  110.      * @return mixed
  111.      *
  112.      * @throws \LogicException if no default value is present; {@see self::hasDefaultValue()}
  113.      */
  114.     public function getDefaultValue()
  115.     {
  116.         if (!$this->hasDefaultValue) {
  117.             throw new \LogicException(sprintf('Argument $%s does not have a default value. Use "%s::hasDefaultValue()" to avoid this exception.', $this->name, __CLASS__));
  118.         }
  120.         return $this->defaultValue;
  121.     }
  123.     /**
  124.      * Returns the attribute (if any) that was set on the argument.
  125.      */
  126.     public function getAttribute(): ?ArgumentInterface
  127.     {
  128.         trigger_deprecation('symfony/http-kernel', '5.3', 'Method "%s()" is deprecated, use "getAttributes()" instead.', __METHOD__);
  130.         if (!$this->attributes) {
  131.             return null;
  132.         }
  134.         return $this->attributes[0] instanceof ArgumentInterface ? $this->attributes[0] : null;
  135.     }
  137.     /**
  138.      * @return object[]
  139.      */
  140.     public function getAttributes(string $name = null, int $flags = 0): array
  141.     {
  142.         if (!$name) {
  143.             return $this->attributes;
  144.         }
  146.         $attributes = [];
  147.         if ($flags & self::IS_INSTANCEOF) {
  148.             foreach ($this->attributes as $attribute) {
  149.                 if ($attribute instanceof $name) {
  150.                     $attributes[] = $attribute;
  151.                 }
  152.             }
  153.         } else {
  154.             foreach ($this->attributes as $attribute) {
  155.                 if (\get_class($attribute) === $name) {
  156.                     $attributes[] = $attribute;
  157.                 }
  158.             }
  159.         }
  161.         return $attributes;
  162.     }
  163. }