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/property-info/Type.php line 79

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\PropertyInfo;
  14. /**
  15.  * Type value object (immutable).
  16.  *
  17.  * @author Kévin Dunglas <dunglas@gmail.com>
  18.  *
  19.  * @final
  20.  */
  21. class Type
  22. {
  23.     public const BUILTIN_TYPE_INT = 'int';
  24.     public const BUILTIN_TYPE_FLOAT = 'float';
  25.     public const BUILTIN_TYPE_STRING = 'string';
  26.     public const BUILTIN_TYPE_BOOL = 'bool';
  27.     public const BUILTIN_TYPE_RESOURCE = 'resource';
  28.     public const BUILTIN_TYPE_OBJECT = 'object';
  29.     public const BUILTIN_TYPE_ARRAY = 'array';
  30.     public const BUILTIN_TYPE_NULL = 'null';
  31.     public const BUILTIN_TYPE_FALSE = 'false';
  32.     public const BUILTIN_TYPE_TRUE = 'true';
  33.     public const BUILTIN_TYPE_CALLABLE = 'callable';
  34.     public const BUILTIN_TYPE_ITERABLE = 'iterable';
  36.     /**
  37.      * List of PHP builtin types.
  38.      *
  39.      * @var string[]
  40.      */
  41.     public static $builtinTypes = [
  42.         self::BUILTIN_TYPE_INT,
  43.         self::BUILTIN_TYPE_FLOAT,
  44.         self::BUILTIN_TYPE_STRING,
  45.         self::BUILTIN_TYPE_BOOL,
  46.         self::BUILTIN_TYPE_RESOURCE,
  47.         self::BUILTIN_TYPE_OBJECT,
  48.         self::BUILTIN_TYPE_ARRAY,
  49.         self::BUILTIN_TYPE_CALLABLE,
  50.         self::BUILTIN_TYPE_FALSE,
  51.         self::BUILTIN_TYPE_TRUE,
  52.         self::BUILTIN_TYPE_NULL,
  53.         self::BUILTIN_TYPE_ITERABLE,
  54.     ];
  56.     /**
  57.      * List of PHP builtin collection types.
  58.      *
  59.      * @var string[]
  60.      */
  61.     public static $builtinCollectionTypes = [
  62.         self::BUILTIN_TYPE_ARRAY,
  63.         self::BUILTIN_TYPE_ITERABLE,
  64.     ];
  66.     private $builtinType;
  67.     private $nullable;
  68.     private $class;
  69.     private $collection;
  70.     private $collectionKeyType;
  71.     private $collectionValueType;
  73.     /**
  74.      * @param Type[]|Type|null $collectionKeyType
  75.      * @param Type[]|Type|null $collectionValueType
  76.      *
  77.      * @throws \InvalidArgumentException
  78.      */
  79.     public function __construct(string $builtinType, bool $nullable = false, string $class = null, bool $collection = false, $collectionKeyType = null, $collectionValueType = null)
  80.     {
  81.         if (!\in_array($builtinType, self::$builtinTypes)) {
  82.             throw new \InvalidArgumentException(sprintf('"%s" is not a valid PHP type.', $builtinType));
  83.         }
  85.         $this->builtinType = $builtinType;
  86.         $this->nullable = $nullable;
  87.         $this->class = $class;
  88.         $this->collection = $collection;
  89.         $this->collectionKeyType = $this->validateCollectionArgument($collectionKeyType, 5, '$collectionKeyType') ?? [];
  90.         $this->collectionValueType = $this->validateCollectionArgument($collectionValueType, 6, '$collectionValueType') ?? [];
  91.     }
  93.     private function validateCollectionArgument($collectionArgument, int $argumentIndex, string $argumentName): ?array
  94.     {
  95.         if (null === $collectionArgument) {
  96.             return null;
  97.         }
  99.         if (!\is_array($collectionArgument) && !$collectionArgument instanceof self) {
  100.             throw new \TypeError(sprintf('"%s()": Argument #%d (%s) must be of type "%s[]", "%s" or "null", "%s" given.', __METHOD__, $argumentIndex, $argumentName, self::class, self::class, get_debug_type($collectionArgument)));
  101.         }
  103.         if (\is_array($collectionArgument)) {
  104.             foreach ($collectionArgument as $type) {
  105.                 if (!$type instanceof self) {
  106.                     throw new \TypeError(sprintf('"%s()": Argument #%d (%s) must be of type "%s[]", "%s" or "null", array value "%s" given.', __METHOD__, $argumentIndex, $argumentName, self::class, self::class, get_debug_type($collectionArgument)));
  107.                 }
  108.             }
  110.             return $collectionArgument;
  111.         }
  113.         return [$collectionArgument];
  114.     }
  116.     /**
  117.      * Gets built-in type.
  118.      *
  119.      * Can be bool, int, float, string, array, object, resource, null, callback or iterable.
  120.      */
  121.     public function getBuiltinType(): string
  122.     {
  123.         return $this->builtinType;
  124.     }
  126.     public function isNullable(): bool
  127.     {
  128.         return $this->nullable;
  129.     }
  131.     /**
  132.      * Gets the class name.
  133.      *
  134.      * Only applicable if the built-in type is object.
  135.      */
  136.     public function getClassName(): ?string
  137.     {
  138.         return $this->class;
  139.     }
  141.     public function isCollection(): bool
  142.     {
  143.         return $this->collection;
  144.     }
  146.     /**
  147.      * Gets collection key type.
  148.      *
  149.      * Only applicable for a collection type.
  150.      *
  151.      * @deprecated since Symfony 5.3, use "getCollectionKeyTypes()" instead
  152.      */
  153.     public function getCollectionKeyType(): ?self
  154.     {
  155.         trigger_deprecation('symfony/property-info', '5.3', 'The "%s()" method is deprecated, use "getCollectionKeyTypes()" instead.', __METHOD__);
  157.         $type = $this->getCollectionKeyTypes();
  158.         if (0 === \count($type)) {
  159.             return null;
  160.         }
  162.         if (\is_array($type)) {
  163.             [$type] = $type;
  164.         }
  166.         return $type;
  167.     }
  169.     /**
  170.      * Gets collection key types.
  171.      *
  172.      * Only applicable for a collection type.
  173.      *
  174.      * @return Type[]
  175.      */
  176.     public function getCollectionKeyTypes(): array
  177.     {
  178.         return $this->collectionKeyType;
  179.     }
  181.     /**
  182.      * Gets collection value type.
  183.      *
  184.      * Only applicable for a collection type.
  185.      *
  186.      * @deprecated since Symfony 5.3, use "getCollectionValueTypes()" instead
  187.      */
  188.     public function getCollectionValueType(): ?self
  189.     {
  190.         trigger_deprecation('symfony/property-info', '5.3', 'The "%s()" method is deprecated, use "getCollectionValueTypes()" instead.', __METHOD__);
  192.         return $this->getCollectionValueTypes()[0] ?? null;
  193.     }
  195.     /**
  196.      * Gets collection value types.
  197.      *
  198.      * Only applicable for a collection type.
  199.      *
  200.      * @return Type[]
  201.      */
  202.     public function getCollectionValueTypes(): array
  203.     {
  204.         return $this->collectionValueType;
  205.     }
  206. }