vendor/symfony/serializer/Serializer.php line 230

  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;
  14. use Symfony\Component\Serializer\Encoder\ChainDecoder;
  15. use Symfony\Component\Serializer\Encoder\ChainEncoder;
  16. use Symfony\Component\Serializer\Encoder\ContextAwareDecoderInterface;
  17. use Symfony\Component\Serializer\Encoder\ContextAwareEncoderInterface;
  18. use Symfony\Component\Serializer\Encoder\DecoderInterface;
  19. use Symfony\Component\Serializer\Encoder\EncoderInterface;
  20. use Symfony\Component\Serializer\Exception\InvalidArgumentException;
  21. use Symfony\Component\Serializer\Exception\LogicException;
  22. use Symfony\Component\Serializer\Exception\NotEncodableValueException;
  23. use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
  24. use Symfony\Component\Serializer\Exception\PartialDenormalizationException;
  25. use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
  26. use Symfony\Component\Serializer\Normalizer\CacheableSupportsMethodInterface;
  27. use Symfony\Component\Serializer\Normalizer\ContextAwareDenormalizerInterface;
  28. use Symfony\Component\Serializer\Normalizer\ContextAwareNormalizerInterface;
  29. use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
  30. use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
  31. use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
  32. use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
  34. /**
  35.  * Serializer serializes and deserializes data.
  36.  *
  37.  * objects are turned into arrays by normalizers.
  38.  * arrays are turned into various output formats by encoders.
  39.  *
  40.  *     $serializer->serialize($obj, 'xml')
  41.  *     $serializer->decode($data, 'xml')
  42.  *     $serializer->denormalize($data, 'Class', 'xml')
  43.  *
  44.  * @author Jordi Boggiano <j.boggiano@seld.be>
  45.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  46.  * @author Lukas Kahwe Smith <smith@pooteeweet.org>
  47.  * @author Kévin Dunglas <dunglas@gmail.com>
  48.  */
  49. class Serializer implements SerializerInterface, ContextAwareNormalizerInterface, ContextAwareDenormalizerInterface, ContextAwareEncoderInterface, ContextAwareDecoderInterface
  50. {
  51.     /**
  52.      * Flag to control whether an empty array should be transformed to an
  53.      * object (in JSON: {}) or to a list (in JSON: []).
  54.      */
  55.     public const EMPTY_ARRAY_AS_OBJECT = 'empty_array_as_object';
  57.     private const SCALAR_TYPES = [
  58.         'int' => true,
  59.         'bool' => true,
  60.         'float' => true,
  61.         'string' => true,
  62.     ];
  64.     /**
  65.      * @var Encoder\ChainEncoder
  66.      */
  67.     protected $encoder;
  69.     /**
  70.      * @var Encoder\ChainDecoder
  71.      */
  72.     protected $decoder;
  74.     private $normalizers = [];
  75.     private $denormalizerCache = [];
  76.     private $normalizerCache = [];
  78.     /**
  79.      * @param array<NormalizerInterface|DenormalizerInterface> $normalizers
  80.      * @param array<EncoderInterface|DecoderInterface>         $encoders
  81.      */
  82.     public function __construct(array $normalizers = [], array $encoders = [])
  83.     {
  84.         foreach ($normalizers as $normalizer) {
  85.             if ($normalizer instanceof SerializerAwareInterface) {
  86.                 $normalizer->setSerializer($this);
  87.             }
  89.             if ($normalizer instanceof DenormalizerAwareInterface) {
  90.                 $normalizer->setDenormalizer($this);
  91.             }
  93.             if ($normalizer instanceof NormalizerAwareInterface) {
  94.                 $normalizer->setNormalizer($this);
  95.             }
  97.             if (!($normalizer instanceof NormalizerInterface || $normalizer instanceof DenormalizerInterface)) {
  98.                 throw new InvalidArgumentException(sprintf('The class "%s" neither implements "%s" nor "%s".', get_debug_type($normalizer), NormalizerInterface::class, DenormalizerInterface::class));
  99.             }
  100.         }
  101.         $this->normalizers = $normalizers;
  103.         $decoders = [];
  104.         $realEncoders = [];
  105.         foreach ($encoders as $encoder) {
  106.             if ($encoder instanceof SerializerAwareInterface) {
  107.                 $encoder->setSerializer($this);
  108.             }
  109.             if ($encoder instanceof DecoderInterface) {
  110.                 $decoders[] = $encoder;
  111.             }
  112.             if ($encoder instanceof EncoderInterface) {
  113.                 $realEncoders[] = $encoder;
  114.             }
  116.             if (!($encoder instanceof EncoderInterface || $encoder instanceof DecoderInterface)) {
  117.                 throw new InvalidArgumentException(sprintf('The class "%s" neither implements "%s" nor "%s".', get_debug_type($encoder), EncoderInterface::class, DecoderInterface::class));
  118.             }
  119.         }
  120.         $this->encoder = new ChainEncoder($realEncoders);
  121.         $this->decoder = new ChainDecoder($decoders);
  122.     }
  124.     final public function serialize(mixed $data, string $format, array $context = []): string
  125.     {
  126.         if (!$this->supportsEncoding($format, $context)) {
  127.             throw new NotEncodableValueException(sprintf('Serialization for the format "%s" is not supported.', $format));
  128.         }
  130.         if ($this->encoder->needsNormalization($format, $context)) {
  131.             $data = $this->normalize($data, $format, $context);
  132.         }
  134.         return $this->encode($data, $format, $context);
  135.     }
  137.     final public function deserialize(mixed $data, string $type, string $format, array $context = []): mixed
  138.     {
  139.         if (!$this->supportsDecoding($format, $context)) {
  140.             throw new NotEncodableValueException(sprintf('Deserialization for the format "%s" is not supported.', $format));
  141.         }
  143.         $data = $this->decode($data, $format, $context);
  145.         return $this->denormalize($data, $type, $format, $context);
  146.     }
  148.     public function normalize(mixed $data, string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
  149.     {
  150.         // If a normalizer supports the given data, use it
  151.         if ($normalizer = $this->getNormalizer($data, $format, $context)) {
  152.             return $normalizer->normalize($data, $format, $context);
  153.         }
  155.         if (null === $data || \is_scalar($data)) {
  156.             return $data;
  157.         }
  159.         if (\is_array($data) && !$data && ($context[self::EMPTY_ARRAY_AS_OBJECT] ?? false)) {
  160.             return new \ArrayObject();
  161.         }
  163.         if (is_iterable($data)) {
  164.             if ($data instanceof \Countable && ($context[AbstractObjectNormalizer::PRESERVE_EMPTY_OBJECTS] ?? false) && !\count($data)) {
  165.                 return new \ArrayObject();
  166.             }
  168.             $normalized = [];
  169.             foreach ($data as $key => $val) {
  170.                 $normalized[$key] = $this->normalize($val, $format, $context);
  171.             }
  173.             return $normalized;
  174.         }
  176.         if (\is_object($data)) {
  177.             if (!$this->normalizers) {
  178.                 throw new LogicException('You must register at least one normalizer to be able to normalize objects.');
  179.             }
  181.             throw new NotNormalizableValueException(sprintf('Could not normalize object of type "%s", no supporting normalizer found.', get_debug_type($data)));
  182.         }
  184.         throw new NotNormalizableValueException('An unexpected value could not be normalized: '.(!\is_resource($data) ? var_export($data, true) : sprintf('"%s" resource', get_resource_type($data))));
  185.     }
  187.     /**
  188.      * @throws NotNormalizableValueException
  189.      */
  190.     public function denormalize(mixed $data, string $type, string $format = null, array $context = []): mixed
  191.     {
  192.         if (isset($context[DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS], $context['not_normalizable_value_exceptions'])) {
  193.             throw new LogicException('Passing a value for "not_normalizable_value_exceptions" context key is not allowed.');
  194.         }
  196.         $normalizer = $this->getDenormalizer($data, $type, $format, $context);
  198.         // Check for a denormalizer first, e.g. the data is wrapped
  199.         if (!$normalizer && isset(self::SCALAR_TYPES[$type])) {
  200.             if (!('is_'.$type)($data)) {
  201.                 throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('Data expected to be of type "%s" ("%s" given).', $type, get_debug_type($data)), $data, [$type], $context['deserialization_path'] ?? null, true);
  202.             }
  204.             return $data;
  205.         }
  207.         if (!$this->normalizers) {
  208.             throw new LogicException('You must register at least one normalizer to be able to denormalize objects.');
  209.         }
  211.         if (!$normalizer) {
  212.             throw new NotNormalizableValueException(sprintf('Could not denormalize object of type "%s", no supporting normalizer found.', $type));
  213.         }
  215.         if (isset($context[DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS])) {
  216.             unset($context[DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS]);
  217.             $context['not_normalizable_value_exceptions'] = [];
  218.             $errors = &$context['not_normalizable_value_exceptions'];
  219.             $denormalized = $normalizer->denormalize($data, $type, $format, $context);
  220.             if ($errors) {
  221.                 throw new PartialDenormalizationException($denormalized, $errors);
  222.             }
  224.             return $denormalized;
  225.         }
  227.         return $normalizer->denormalize($data, $type, $format, $context);
  228.     }
  230.     public function supportsNormalization(mixed $data, string $format = null, array $context = []): bool
  231.     {
  232.         return null !== $this->getNormalizer($data, $format, $context);
  233.     }
  235.     public function supportsDenormalization(mixed $data, string $type, string $format = null, array $context = []): bool
  236.     {
  237.         return isset(self::SCALAR_TYPES[$type]) || null !== $this->getDenormalizer($data, $type, $format, $context);
  238.     }
  240.     /**
  241.      * Returns a matching normalizer.
  242.      *
  243.      * @param mixed       $data    Data to get the serializer for
  244.      * @param string|null $format  Format name, present to give the option to normalizers to act differently based on formats
  245.      * @param array       $context Options available to the normalizer
  246.      */
  247.     private function getNormalizer(mixed $data, ?string $format, array $context): ?NormalizerInterface
  248.     {
  249.         $type = \is_object($data) ? $data::class : 'native-'.\gettype($data);
  251.         if (!isset($this->normalizerCache[$format][$type])) {
  252.             $this->normalizerCache[$format][$type] = [];
  254.             foreach ($this->normalizers as $k => $normalizer) {
  255.                 if (!$normalizer instanceof NormalizerInterface) {
  256.                     continue;
  257.                 }
  259.                 if (!$normalizer instanceof CacheableSupportsMethodInterface || !$normalizer->hasCacheableSupportsMethod()) {
  260.                     $this->normalizerCache[$format][$type][$k] = false;
  261.                 } elseif ($normalizer->supportsNormalization($data, $format, $context)) {
  262.                     $this->normalizerCache[$format][$type][$k] = true;
  263.                     break;
  264.                 }
  265.             }
  266.         }
  268.         foreach ($this->normalizerCache[$format][$type] as $k => $cached) {
  269.             $normalizer = $this->normalizers[$k];
  270.             if ($cached || $normalizer->supportsNormalization($data, $format, $context)) {
  271.                 return $normalizer;
  272.             }
  273.         }
  275.         return null;
  276.     }
  278.     /**
  279.      * Returns a matching denormalizer.
  280.      *
  281.      * @param mixed       $data    Data to restore
  282.      * @param string      $class   The expected class to instantiate
  283.      * @param string|null $format  Format name, present to give the option to normalizers to act differently based on formats
  284.      * @param array       $context Options available to the denormalizer
  285.      */
  286.     private function getDenormalizer(mixed $data, string $class, ?string $format, array $context): ?DenormalizerInterface
  287.     {
  288.         if (!isset($this->denormalizerCache[$format][$class])) {
  289.             $this->denormalizerCache[$format][$class] = [];
  291.             foreach ($this->normalizers as $k => $normalizer) {
  292.                 if (!$normalizer instanceof DenormalizerInterface) {
  293.                     continue;
  294.                 }
  296.                 if (!$normalizer instanceof CacheableSupportsMethodInterface || !$normalizer->hasCacheableSupportsMethod()) {
  297.                     $this->denormalizerCache[$format][$class][$k] = false;
  298.                 } elseif ($normalizer->supportsDenormalization(null, $class, $format, $context)) {
  299.                     $this->denormalizerCache[$format][$class][$k] = true;
  300.                     break;
  301.                 }
  302.             }
  303.         }
  305.         foreach ($this->denormalizerCache[$format][$class] as $k => $cached) {
  306.             $normalizer = $this->normalizers[$k];
  307.             if ($cached || $normalizer->supportsDenormalization($data, $class, $format, $context)) {
  308.                 return $normalizer;
  309.             }
  310.         }
  312.         return null;
  313.     }
  315.     final public function encode(mixed $data, string $format, array $context = []): string
  316.     {
  317.         return $this->encoder->encode($data, $format, $context);
  318.     }
  320.     final public function decode(string $data, string $format, array $context = []): mixed
  321.     {
  322.         return $this->decoder->decode($data, $format, $context);
  323.     }
  325.     public function supportsEncoding(string $format, array $context = []): bool
  326.     {
  327.         return $this->encoder->supportsEncoding($format, $context);
  328.     }
  330.     public function supportsDecoding(string $format, array $context = []): bool
  331.     {
  332.         return $this->decoder->supportsDecoding($format, $context);
  333.     }
  334. }