Deprecated: Constant E_STRICT is deprecated in /home/normanv/www/annuairepro/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/normanv/www/annuairepro/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/serializer/Normalizer/ArrayDenormalizer.php line 38

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\Serializer\Normalizer;
  14. use Symfony\Component\PropertyInfo\Type;
  15. use Symfony\Component\Serializer\Exception\BadMethodCallException;
  16. use Symfony\Component\Serializer\Exception\InvalidArgumentException;
  17. use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
  18. use Symfony\Component\Serializer\Serializer;
  19. use Symfony\Component\Serializer\SerializerAwareInterface;
  20. use Symfony\Component\Serializer\SerializerInterface;
  22. /**
  23.  * Denormalizes arrays of objects.
  24.  *
  25.  * @author Alexander M. Turek <me@derrabus.de>
  26.  *
  27.  * @final
  28.  */
  29. class ArrayDenormalizer implements ContextAwareDenormalizerInterface, DenormalizerAwareInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
  30. {
  31.     use DenormalizerAwareTrait;
  33.     /**
  34.      * {@inheritdoc}
  35.      *
  36.      * @throws NotNormalizableValueException
  37.      */
  38.     public function denormalize($data, string $type, string $format = null, array $context = []): array
  39.     {
  40.         if (null === $this->denormalizer) {
  41.             throw new BadMethodCallException('Please set a denormalizer before calling denormalize()!');
  42.         }
  43.         if (!\is_array($data)) {
  44.             throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('Data expected to be "%s", "%s" given.', $type, get_debug_type($data)), $data, [Type::BUILTIN_TYPE_ARRAY], $context['deserialization_path'] ?? null);
  45.         }
  46.         if (!str_ends_with($type, '[]')) {
  47.             throw new InvalidArgumentException('Unsupported class: '.$type);
  48.         }
  50.         $type = substr($type, 0, -2);
  52.         $builtinTypes = array_map(static function (Type $keyType) {
  53.             return $keyType->getBuiltinType();
  54.         }, \is_array($keyType = $context['key_type'] ?? []) ? $keyType : [$keyType]);
  56.         foreach ($data as $key => $value) {
  57.             $subContext = $context;
  58.             $subContext['deserialization_path'] = ($context['deserialization_path'] ?? false) ? sprintf('%s[%s]', $context['deserialization_path'], $key) : "[$key]";
  60.             $this->validateKeyType($builtinTypes, $key, $subContext['deserialization_path']);
  62.             $data[$key] = $this->denormalizer->denormalize($value, $type, $format, $subContext);
  63.         }
  65.         return $data;
  66.     }
  68.     /**
  69.      * {@inheritdoc}
  70.      */
  71.     public function supportsDenormalization($data, string $type, string $format = null, array $context = []): bool
  72.     {
  73.         if (null === $this->denormalizer) {
  74.             throw new BadMethodCallException(sprintf('The nested denormalizer needs to be set to allow "%s()" to be used.', __METHOD__));
  75.         }
  77.         return str_ends_with($type, '[]')
  78.             && $this->denormalizer->supportsDenormalization($data, substr($type, 0, -2), $format, $context);
  79.     }
  81.     /**
  82.      * {@inheritdoc}
  83.      *
  84.      * @deprecated call setDenormalizer() instead
  85.      */
  86.     public function setSerializer(SerializerInterface $serializer)
  87.     {
  88.         if (!$serializer instanceof DenormalizerInterface) {
  89.             throw new InvalidArgumentException('Expected a serializer that also implements DenormalizerInterface.');
  90.         }
  92.         if (Serializer::class !== debug_backtrace()[1]['class'] ?? null) {
  93.             trigger_deprecation('symfony/serializer', '5.3', 'Calling "%s()" is deprecated. Please call setDenormalizer() instead.', __METHOD__);
  94.         }
  96.         $this->setDenormalizer($serializer);
  97.     }
  99.     /**
  100.      * {@inheritdoc}
  101.      */
  102.     public function hasCacheableSupportsMethod(): bool
  103.     {
  104.         return $this->denormalizer instanceof CacheableSupportsMethodInterface && $this->denormalizer->hasCacheableSupportsMethod();
  105.     }
  107.     /**
  108.      * @param mixed $key
  109.      */
  110.     private function validateKeyType(array $builtinTypes, $key, string $path): void
  111.     {
  112.         if (!$builtinTypes) {
  113.             return;
  114.         }
  116.         foreach ($builtinTypes as $builtinType) {
  117.             if (('is_'.$builtinType)($key)) {
  118.                 return;
  119.             }
  120.         }
  122.         throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the key "%s" must be "%s" ("%s" given).', $key, implode('", "', $builtinTypes), get_debug_type($key)), $key, $builtinTypes, $path, true);
  123.     }
  124. }