vendor/symfony/serializer/Normalizer/AbstractObjectNormalizer.php line 148

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\PropertyAccess\Exception\InvalidArgumentException as PropertyAccessInvalidArgumentException;
  15. use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
  16. use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
  17. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  18. use Symfony\Component\PropertyInfo\Type;
  19. use Symfony\Component\Serializer\Encoder\CsvEncoder;
  20. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  21. use Symfony\Component\Serializer\Encoder\XmlEncoder;
  22. use Symfony\Component\Serializer\Exception\ExtraAttributesException;
  23. use Symfony\Component\Serializer\Exception\InvalidArgumentException;
  24. use Symfony\Component\Serializer\Exception\LogicException;
  25. use Symfony\Component\Serializer\Exception\MissingConstructorArgumentsException;
  26. use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
  27. use Symfony\Component\Serializer\Mapping\AttributeMetadataInterface;
  28. use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata;
  29. use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface;
  30. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
  31. use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
  33. /**
  34.  * Base class for a normalizer dealing with objects.
  35.  *
  36.  * @author Kévin Dunglas <dunglas@gmail.com>
  37.  */
  38. abstract class AbstractObjectNormalizer extends AbstractNormalizer
  39. {
  40.     /**
  41.      * Set to true to respect the max depth metadata on fields.
  42.      */
  43.     public const ENABLE_MAX_DEPTH = 'enable_max_depth';
  45.     /**
  46.      * How to track the current depth in the context.
  47.      */
  48.     public const DEPTH_KEY_PATTERN = 'depth_%s::%s';
  50.     /**
  51.      * While denormalizing, we can verify that types match.
  52.      *
  53.      * You can disable this by setting this flag to true.
  54.      */
  55.     public const DISABLE_TYPE_ENFORCEMENT = 'disable_type_enforcement';
  57.     /**
  58.      * Flag to control whether fields with the value `null` should be output
  59.      * when normalizing or omitted.
  60.      */
  61.     public const SKIP_NULL_VALUES = 'skip_null_values';
  63.     /**
  64.      * Flag to control whether uninitialized PHP>=7.4 typed class properties
  65.      * should be excluded when normalizing.
  66.      */
  67.     public const SKIP_UNINITIALIZED_VALUES = 'skip_uninitialized_values';
  69.     /**
  70.      * Callback to allow to set a value for an attribute when the max depth has
  71.      * been reached.
  72.      *
  73.      * If no callback is given, the attribute is skipped. If a callable is
  74.      * given, its return value is used (even if null).
  75.      *
  76.      * The arguments are:
  77.      *
  78.      * - mixed  $attributeValue value of this field
  79.      * - object $object         the whole object being normalized
  80.      * - string $attributeName  name of the attribute being normalized
  81.      * - string $format         the requested format
  82.      * - array  $context        the serialization context
  83.      */
  84.     public const MAX_DEPTH_HANDLER = 'max_depth_handler';
  86.     /**
  87.      * Specify which context key are not relevant to determine which attributes
  88.      * of an object to (de)normalize.
  89.      */
  90.     public const EXCLUDE_FROM_CACHE_KEY = 'exclude_from_cache_key';
  92.     /**
  93.      * Flag to tell the denormalizer to also populate existing objects on
  94.      * attributes of the main object.
  95.      *
  96.      * Setting this to true is only useful if you also specify the root object
  97.      * in OBJECT_TO_POPULATE.
  98.      */
  99.     public const DEEP_OBJECT_TO_POPULATE = 'deep_object_to_populate';
  101.     /**
  102.      * Flag to control whether an empty object should be kept as an object (in
  103.      * JSON: {}) or converted to a list (in JSON: []).
  104.      */
  105.     public const PRESERVE_EMPTY_OBJECTS = 'preserve_empty_objects';
  107.     private $propertyTypeExtractor;
  108.     private $typesCache = [];
  109.     private $attributesCache = [];
  111.     private $objectClassResolver;
  113.     /**
  114.      * @var ClassDiscriminatorResolverInterface|null
  115.      */
  116.     protected $classDiscriminatorResolver;
  118.     public function __construct(?ClassMetadataFactoryInterface $classMetadataFactory = null, ?NameConverterInterface $nameConverter = null, ?PropertyTypeExtractorInterface $propertyTypeExtractor = null, ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null, ?callable $objectClassResolver = null, array $defaultContext = [])
  119.     {
  120.         parent::__construct($classMetadataFactory, $nameConverter, $defaultContext);
  122.         if (isset($this->defaultContext[self::MAX_DEPTH_HANDLER]) && !\is_callable($this->defaultContext[self::MAX_DEPTH_HANDLER])) {
  123.             throw new InvalidArgumentException(sprintf('The "%s" given in the default context is not callable.', self::MAX_DEPTH_HANDLER));
  124.         }
  126.         $this->defaultContext[self::EXCLUDE_FROM_CACHE_KEY] = array_merge($this->defaultContext[self::EXCLUDE_FROM_CACHE_KEY] ?? [], [self::CIRCULAR_REFERENCE_LIMIT_COUNTERS]);
  128.         $this->propertyTypeExtractor = $propertyTypeExtractor;
  130.         if (null === $classDiscriminatorResolver && null !== $classMetadataFactory) {
  131.             $classDiscriminatorResolver = new ClassDiscriminatorFromClassMetadata($classMetadataFactory);
  132.         }
  133.         $this->classDiscriminatorResolver = $classDiscriminatorResolver;
  134.         $this->objectClassResolver = $objectClassResolver;
  135.     }
  137.     /**
  138.      * {@inheritdoc}
  139.      */
  140.     public function supportsNormalization($data, ?string $format = null)
  141.     {
  142.         return \is_object($data) && !$data instanceof \Traversable;
  143.     }
  145.     /**
  146.      * {@inheritdoc}
  147.      */
  148.     public function normalize($object, ?string $format = null, array $context = [])
  149.     {
  150.         $context['_read_attributes'] = true;
  152.         if (!isset($context['cache_key'])) {
  153.             $context['cache_key'] = $this->getCacheKey($format, $context);
  154.         }
  156.         $this->validateCallbackContext($context);
  158.         if ($this->isCircularReference($object, $context)) {
  159.             return $this->handleCircularReference($object, $format, $context);
  160.         }
  162.         $data = [];
  163.         $stack = [];
  164.         $attributes = $this->getAttributes($object, $format, $context);
  165.         $class = $this->objectClassResolver ? ($this->objectClassResolver)($object) : \get_class($object);
  166.         $attributesMetadata = $this->classMetadataFactory ? $this->classMetadataFactory->getMetadataFor($class)->getAttributesMetadata() : null;
  167.         if (isset($context[self::MAX_DEPTH_HANDLER])) {
  168.             $maxDepthHandler = $context[self::MAX_DEPTH_HANDLER];
  169.             if (!\is_callable($maxDepthHandler)) {
  170.                 throw new InvalidArgumentException(sprintf('The "%s" given in the context is not callable.', self::MAX_DEPTH_HANDLER));
  171.             }
  172.         } else {
  173.             $maxDepthHandler = null;
  174.         }
  176.         foreach ($attributes as $attribute) {
  177.             $maxDepthReached = false;
  178.             if (null !== $attributesMetadata && ($maxDepthReached = $this->isMaxDepthReached($attributesMetadata, $class, $attribute, $context)) && !$maxDepthHandler) {
  179.                 continue;
  180.             }
  182.             $attributeContext = $this->getAttributeNormalizationContext($object, $attribute, $context);
  184.             $discriminatorProperty = null;
  185.             if (null !== $this->classDiscriminatorResolver && null !== $mapping = $this->classDiscriminatorResolver->getMappingForMappedObject($object)) {
  186.                 $discriminatorProperty = $mapping->getTypeProperty();
  187.             }
  189.             try {
  190.                 $attributeValue = $attribute === $discriminatorProperty
  191.                     ? $this->classDiscriminatorResolver->getTypeForMappedObject($object)
  192.                     : $this->getAttributeValue($object, $attribute, $format, $attributeContext);
  193.             } catch (UninitializedPropertyException $e) {
  194.                 if ($context[self::SKIP_UNINITIALIZED_VALUES] ?? $this->defaultContext[self::SKIP_UNINITIALIZED_VALUES] ?? true) {
  195.                     continue;
  196.                 }
  197.                 throw $e;
  198.             } catch (\Error $e) {
  199.                 if (($context[self::SKIP_UNINITIALIZED_VALUES] ?? $this->defaultContext[self::SKIP_UNINITIALIZED_VALUES] ?? true) && $this->isUninitializedValueError($e)) {
  200.                     continue;
  201.                 }
  202.                 throw $e;
  203.             }
  205.             if ($maxDepthReached) {
  206.                 $attributeValue = $maxDepthHandler($attributeValue, $object, $attribute, $format, $attributeContext);
  207.             }
  209.             $attributeValue = $this->applyCallbacks($attributeValue, $object, $attribute, $format, $attributeContext);
  211.             if (null !== $attributeValue && !\is_scalar($attributeValue)) {
  212.                 $stack[$attribute] = $attributeValue;
  213.             }
  215.             $data = $this->updateData($data, $attribute, $attributeValue, $class, $format, $attributeContext);
  216.         }
  218.         foreach ($stack as $attribute => $attributeValue) {
  219.             if (!$this->serializer instanceof NormalizerInterface) {
  220.                 throw new LogicException(sprintf('Cannot normalize attribute "%s" because the injected serializer is not a normalizer.', $attribute));
  221.             }
  223.             $attributeContext = $this->getAttributeNormalizationContext($object, $attribute, $context);
  224.             $childContext = $this->createChildContext($attributeContext, $attribute, $format);
  226.             $data = $this->updateData($data, $attribute, $this->serializer->normalize($attributeValue, $format, $childContext), $class, $format, $attributeContext);
  227.         }
  229.         if (isset($context[self::PRESERVE_EMPTY_OBJECTS]) && !\count($data)) {
  230.             return new \ArrayObject();
  231.         }
  233.         return $data;
  234.     }
  236.     /**
  237.      * Computes the normalization context merged with current one. Metadata always wins over global context, as more specific.
  238.      */
  239.     private function getAttributeNormalizationContext(object $object, string $attribute, array $context): array
  240.     {
  241.         if (null === $metadata = $this->getAttributeMetadata($object, $attribute)) {
  242.             return $context;
  243.         }
  245.         return array_merge($context, $metadata->getNormalizationContextForGroups($this->getGroups($context)));
  246.     }
  248.     /**
  249.      * Computes the denormalization context merged with current one. Metadata always wins over global context, as more specific.
  250.      */
  251.     private function getAttributeDenormalizationContext(string $class, string $attribute, array $context): array
  252.     {
  253.         $context['deserialization_path'] = ($context['deserialization_path'] ?? false) ? $context['deserialization_path'].'.'.$attribute : $attribute;
  255.         if (null === $metadata = $this->getAttributeMetadata($class, $attribute)) {
  256.             return $context;
  257.         }
  259.         return array_merge($context, $metadata->getDenormalizationContextForGroups($this->getGroups($context)));
  260.     }
  262.     private function getAttributeMetadata($objectOrClass, string $attribute): ?AttributeMetadataInterface
  263.     {
  264.         if (!$this->classMetadataFactory) {
  265.             return null;
  266.         }
  268.         return $this->classMetadataFactory->getMetadataFor($objectOrClass)->getAttributesMetadata()[$attribute] ?? null;
  269.     }
  271.     /**
  272.      * {@inheritdoc}
  273.      */
  274.     protected function instantiateObject(array &$data, string $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes, ?string $format = null)
  275.     {
  276.         if (null !== $object = $this->extractObjectToPopulate($class, $context, self::OBJECT_TO_POPULATE)) {
  277.             unset($context[self::OBJECT_TO_POPULATE]);
  279.             return $object;
  280.         }
  282.         if ($this->classDiscriminatorResolver && $mapping = $this->classDiscriminatorResolver->getMappingForClass($class)) {
  283.             if (!isset($data[$mapping->getTypeProperty()])) {
  284.                 throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('Type property "%s" not found for the abstract object "%s".', $mapping->getTypeProperty(), $class), null, ['string'], isset($context['deserialization_path']) ? $context['deserialization_path'].'.'.$mapping->getTypeProperty() : $mapping->getTypeProperty(), false);
  285.             }
  287.             $type = $data[$mapping->getTypeProperty()];
  288.             if (null === ($mappedClass = $mapping->getClassForType($type))) {
  289.                 throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type "%s" is not a valid value.', $type), $type, ['string'], isset($context['deserialization_path']) ? $context['deserialization_path'].'.'.$mapping->getTypeProperty() : $mapping->getTypeProperty(), true);
  290.             }
  292.             if ($mappedClass !== $class) {
  293.                 return $this->instantiateObject($data, $mappedClass, $context, new \ReflectionClass($mappedClass), $allowedAttributes, $format);
  294.             }
  295.         }
  297.         return parent::instantiateObject($data, $class, $context, $reflectionClass, $allowedAttributes, $format);
  298.     }
  300.     /**
  301.      * Gets and caches attributes for the given object, format and context.
  302.      *
  303.      * @return string[]
  304.      */
  305.     protected function getAttributes(object $object, ?string $format, array $context)
  306.     {
  307.         $class = $this->objectClassResolver ? ($this->objectClassResolver)($object) : \get_class($object);
  308.         $key = $class.'-'.$context['cache_key'];
  310.         if (isset($this->attributesCache[$key])) {
  311.             return $this->attributesCache[$key];
  312.         }
  314.         $allowedAttributes = $this->getAllowedAttributes($object, $context, true);
  316.         if (false !== $allowedAttributes) {
  317.             if ($context['cache_key']) {
  318.                 $this->attributesCache[$key] = $allowedAttributes;
  319.             }
  321.             return $allowedAttributes;
  322.         }
  324.         $attributes = $this->extractAttributes($object, $format, $context);
  326.         if ($this->classDiscriminatorResolver && $mapping = $this->classDiscriminatorResolver->getMappingForMappedObject($object)) {
  327.             array_unshift($attributes, $mapping->getTypeProperty());
  328.         }
  330.         if ($context['cache_key'] && \stdClass::class !== $class) {
  331.             $this->attributesCache[$key] = $attributes;
  332.         }
  334.         return $attributes;
  335.     }
  337.     /**
  338.      * Extracts attributes to normalize from the class of the given object, format and context.
  339.      *
  340.      * @return string[]
  341.      */
  342.     abstract protected function extractAttributes(object $object, ?string $format = null, array $context = []);
  344.     /**
  345.      * Gets the attribute value.
  346.      *
  347.      * @return mixed
  348.      */
  349.     abstract protected function getAttributeValue(object $object, string $attribute, ?string $format = null, array $context = []);
  351.     /**
  352.      * {@inheritdoc}
  353.      */
  354.     public function supportsDenormalization($data, string $type, ?string $format = null)
  355.     {
  356.         return class_exists($type) || (interface_exists($type, false) && $this->classDiscriminatorResolver && null !== $this->classDiscriminatorResolver->getMappingForClass($type));
  357.     }
  359.     /**
  360.      * {@inheritdoc}
  361.      */
  362.     public function denormalize($data, string $type, ?string $format = null, array $context = [])
  363.     {
  364.         $context['_read_attributes'] = false;
  366.         if (!isset($context['cache_key'])) {
  367.             $context['cache_key'] = $this->getCacheKey($format, $context);
  368.         }
  370.         $this->validateCallbackContext($context);
  372.         if (null === $data && isset($context['value_type']) && $context['value_type'] instanceof Type && $context['value_type']->isNullable()) {
  373.             return null;
  374.         }
  376.         if (XmlEncoder::FORMAT === $format && !\is_array($data)) {
  377.             $data = ['#' => $data];
  378.         }
  380.         $allowedAttributes = $this->getAllowedAttributes($type, $context, true);
  381.         $normalizedData = $this->prepareForDenormalization($data);
  382.         $extraAttributes = [];
  384.         $reflectionClass = new \ReflectionClass($type);
  385.         $object = $this->instantiateObject($normalizedData, $type, $context, $reflectionClass, $allowedAttributes, $format);
  386.         $resolvedClass = $this->objectClassResolver ? ($this->objectClassResolver)($object) : \get_class($object);
  388.         foreach ($normalizedData as $attribute => $value) {
  389.             if ($this->nameConverter) {
  390.                 $attribute = $this->nameConverter->denormalize($attribute, $resolvedClass, $format, $context);
  391.             }
  393.             $attributeContext = $this->getAttributeDenormalizationContext($resolvedClass, $attribute, $context);
  395.             if ((false !== $allowedAttributes && !\in_array($attribute, $allowedAttributes)) || !$this->isAllowedAttribute($resolvedClass, $attribute, $format, $context)) {
  396.                 if (!($context[self::ALLOW_EXTRA_ATTRIBUTES] ?? $this->defaultContext[self::ALLOW_EXTRA_ATTRIBUTES])) {
  397.                     $extraAttributes[] = $attribute;
  398.                 }
  400.                 continue;
  401.             }
  403.             if ($attributeContext[self::DEEP_OBJECT_TO_POPULATE] ?? $this->defaultContext[self::DEEP_OBJECT_TO_POPULATE] ?? false) {
  404.                 $discriminatorProperty = null;
  405.                 if (null !== $this->classDiscriminatorResolver && null !== $mapping = $this->classDiscriminatorResolver->getMappingForMappedObject($object)) {
  406.                     $discriminatorProperty = $mapping->getTypeProperty();
  407.                 }
  409.                 try {
  410.                     $attributeContext[self::OBJECT_TO_POPULATE] = $attribute === $discriminatorProperty
  411.                         ? $this->classDiscriminatorResolver->getTypeForMappedObject($object)
  412.                         : $this->getAttributeValue($object, $attribute, $format, $attributeContext);
  413.                 } catch (NoSuchPropertyException $e) {
  414.                 } catch (UninitializedPropertyException $e) {
  415.                     if (!($context[self::SKIP_UNINITIALIZED_VALUES] ?? $this->defaultContext[self::SKIP_UNINITIALIZED_VALUES] ?? true)) {
  416.                         throw $e;
  417.                     }
  418.                 } catch (\Error $e) {
  419.                     if (!(($context[self::SKIP_UNINITIALIZED_VALUES] ?? $this->defaultContext[self::SKIP_UNINITIALIZED_VALUES] ?? true) && $this->isUninitializedValueError($e))) {
  420.                         throw $e;
  421.                     }
  422.                 }
  423.             }
  425.             $types = $this->getTypes($resolvedClass, $attribute);
  427.             if (null !== $types) {
  428.                 try {
  429.                     $value = $this->validateAndDenormalize($types, $resolvedClass, $attribute, $value, $format, $attributeContext);
  430.                 } catch (NotNormalizableValueException $exception) {
  431.                     if (isset($context['not_normalizable_value_exceptions'])) {
  432.                         $context['not_normalizable_value_exceptions'][] = $exception;
  433.                         continue;
  434.                     }
  435.                     throw $exception;
  436.                 }
  437.             }
  439.             $value = $this->applyCallbacks($value, $resolvedClass, $attribute, $format, $attributeContext);
  441.             try {
  442.                 $this->setAttributeValue($object, $attribute, $value, $format, $attributeContext);
  443.             } catch (PropertyAccessInvalidArgumentException $e) {
  444.                 $exception = NotNormalizableValueException::createForUnexpectedDataType(
  445.                     sprintf('Failed to denormalize attribute "%s" value for class "%s": '.$e->getMessage(), $attribute, $type),
  446.                     $data,
  447.                     ['unknown'],
  448.                     $attributeContext['deserialization_path'] ?? null,
  449.                     false,
  450.                     $e->getCode(),
  451.                     $e
  452.                 );
  453.                 if (isset($context['not_normalizable_value_exceptions'])) {
  454.                     $context['not_normalizable_value_exceptions'][] = $exception;
  455.                     continue;
  456.                 }
  457.                 throw $exception;
  458.             }
  459.         }
  461.         if ($extraAttributes) {
  462.             throw new ExtraAttributesException($extraAttributes);
  463.         }
  465.         return $object;
  466.     }
  468.     /**
  469.      * Sets attribute value.
  470.      */
  471.     abstract protected function setAttributeValue(object $object, string $attribute, $value, ?string $format = null, array $context = []);
  473.     /**
  474.      * Validates the submitted data and denormalizes it.
  475.      *
  476.      * @param Type[] $types
  477.      * @param mixed  $data
  478.      *
  479.      * @return mixed
  480.      *
  481.      * @throws NotNormalizableValueException
  482.      * @throws ExtraAttributesException
  483.      * @throws MissingConstructorArgumentsException
  484.      * @throws LogicException
  485.      */
  486.     private function validateAndDenormalize(array $types, string $currentClass, string $attribute, $data, ?string $format, array $context)
  487.     {
  488.         $expectedTypes = [];
  489.         $isUnionType = \count($types) > 1;
  490.         $e = null;
  491.         $extraAttributesException = null;
  492.         $missingConstructorArgumentException = null;
  493.         $isNullable = false;
  494.         foreach ($types as $type) {
  495.             if (null === $data && $type->isNullable()) {
  496.                 return null;
  497.             }
  499.             $collectionValueType = $type->isCollection() ? $type->getCollectionValueTypes()[0] ?? null : null;
  501.             // Fix a collection that contains the only one element
  502.             // This is special to xml format only
  503.             if ('xml' === $format && null !== $collectionValueType && (!\is_array($data) || !\is_int(key($data)))) {
  504.                 $data = [$data];
  505.             }
  507.             // This try-catch should cover all NotNormalizableValueException (and all return branches after the first
  508.             // exception) so we could try denormalizing all types of an union type. If the target type is not an union
  509.             // type, we will just re-throw the catched exception.
  510.             // In the case of no denormalization succeeds with an union type, it will fall back to the default exception
  511.             // with the acceptable types list.
  512.             try {
  513.                 // In XML and CSV all basic datatypes are represented as strings, it is e.g. not possible to determine,
  514.                 // if a value is meant to be a string, float, int or a boolean value from the serialized representation.
  515.                 // That's why we have to transform the values, if one of these non-string basic datatypes is expected.
  516.                 $builtinType = $type->getBuiltinType();
  517.                 if (\is_string($data) && (XmlEncoder::FORMAT === $format || CsvEncoder::FORMAT === $format)) {
  518.                     if ('' === $data) {
  519.                         if (Type::BUILTIN_TYPE_ARRAY === $builtinType) {
  520.                             return [];
  521.                         }
  523.                         if (Type::BUILTIN_TYPE_STRING === $builtinType) {
  524.                             return '';
  525.                         }
  527.                         // Don't return null yet because Object-types that come first may accept empty-string too
  528.                         $isNullable = $isNullable ?: $type->isNullable();
  529.                     }
  531.                     switch ($builtinType) {
  532.                         case Type::BUILTIN_TYPE_BOOL:
  533.                             // according to https://www.w3.org/TR/xmlschema-2/#boolean, valid representations are "false", "true", "0" and "1"
  534.                             if ('false' === $data || '0' === $data) {
  535.                                 $data = false;
  536.                             } elseif ('true' === $data || '1' === $data) {
  537.                                 $data = true;
  538.                             } else {
  539.                                 throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the "%s" attribute for class "%s" must be bool ("%s" given).', $attribute, $currentClass, $data), $data, [Type::BUILTIN_TYPE_BOOL], $context['deserialization_path'] ?? null);
  540.                             }
  541.                             break;
  542.                         case Type::BUILTIN_TYPE_INT:
  543.                             if (ctype_digit($data) || isset($data[0]) && '-' === $data[0] && ctype_digit(substr($data, 1))) {
  544.                                 $data = (int) $data;
  545.                             } else {
  546.                                 throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the "%s" attribute for class "%s" must be int ("%s" given).', $attribute, $currentClass, $data), $data, [Type::BUILTIN_TYPE_INT], $context['deserialization_path'] ?? null);
  547.                             }
  548.                             break;
  549.                         case Type::BUILTIN_TYPE_FLOAT:
  550.                             if (is_numeric($data)) {
  551.                                 return (float) $data;
  552.                             }
  554.                             switch ($data) {
  555.                                 case 'NaN':
  556.                                     return \NAN;
  557.                                 case 'INF':
  558.                                     return \INF;
  559.                                 case '-INF':
  560.                                     return -\INF;
  561.                                 default:
  562.                                     throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the "%s" attribute for class "%s" must be float ("%s" given).', $attribute, $currentClass, $data), $data, [Type::BUILTIN_TYPE_FLOAT], $context['deserialization_path'] ?? null);
  563.                             }
  564.                     }
  565.                 }
  567.                 if (null !== $collectionValueType && Type::BUILTIN_TYPE_OBJECT === $collectionValueType->getBuiltinType()) {
  568.                     $builtinType = Type::BUILTIN_TYPE_OBJECT;
  569.                     $class = $collectionValueType->getClassName().'[]';
  571.                     if (\count($collectionKeyType = $type->getCollectionKeyTypes()) > 0) {
  572.                         $context['key_type'] = \count($collectionKeyType) > 1 ? $collectionKeyType : $collectionKeyType[0];
  573.                     }
  575.                     $context['value_type'] = $collectionValueType;
  576.                 } elseif ($type->isCollection() && \count($collectionValueType = $type->getCollectionValueTypes()) > 0 && Type::BUILTIN_TYPE_ARRAY === $collectionValueType[0]->getBuiltinType()) {
  577.                     // get inner type for any nested array
  578.                     [$innerType] = $collectionValueType;
  580.                     // note that it will break for any other builtinType
  581.                     $dimensions = '[]';
  582.                     while (\count($innerType->getCollectionValueTypes()) > 0 && Type::BUILTIN_TYPE_ARRAY === $innerType->getBuiltinType()) {
  583.                         $dimensions .= '[]';
  584.                         [$innerType] = $innerType->getCollectionValueTypes();
  585.                     }
  587.                     if (null !== $innerType->getClassName()) {
  588.                         // the builtinType is the inner one and the class is the class followed by []...[]
  589.                         $builtinType = $innerType->getBuiltinType();
  590.                         $class = $innerType->getClassName().$dimensions;
  591.                     } else {
  592.                         // default fallback (keep it as array)
  593.                         $builtinType = $type->getBuiltinType();
  594.                         $class = $type->getClassName();
  595.                     }
  596.                 } else {
  597.                     $builtinType = $type->getBuiltinType();
  598.                     $class = $type->getClassName();
  599.                 }
  601.                 $expectedTypes[Type::BUILTIN_TYPE_OBJECT === $builtinType && $class ? $class : $builtinType] = true;
  603.                 if (Type::BUILTIN_TYPE_OBJECT === $builtinType && null !== $class) {
  604.                     if (!$this->serializer instanceof DenormalizerInterface) {
  605.                         throw new LogicException(sprintf('Cannot denormalize attribute "%s" for class "%s" because injected serializer is not a denormalizer.', $attribute, $class));
  606.                     }
  608.                     $childContext = $this->createChildContext($context, $attribute, $format);
  609.                     if ($this->serializer->supportsDenormalization($data, $class, $format, $childContext)) {
  610.                         return $this->serializer->denormalize($data, $class, $format, $childContext);
  611.                     }
  612.                 }
  614.                 // JSON only has a Number type corresponding to both int and float PHP types.
  615.                 // PHP's json_encode, JavaScript's JSON.stringify, Go's json.Marshal as well as most other JSON encoders convert
  616.                 // floating-point numbers like 12.0 to 12 (the decimal part is dropped when possible).
  617.                 // PHP's json_decode automatically converts Numbers without a decimal part to integers.
  618.                 // To circumvent this behavior, integers are converted to floats when denormalizing JSON based formats and when
  619.                 // a float is expected.
  620.                 if (Type::BUILTIN_TYPE_FLOAT === $builtinType && \is_int($data) && null !== $format && str_contains($format, JsonEncoder::FORMAT)) {
  621.                     return (float) $data;
  622.                 }
  624.                 if (Type::BUILTIN_TYPE_FALSE === $builtinType && false === $data) {
  625.                     return $data;
  626.                 }
  628.                 if (('is_'.$builtinType)($data)) {
  629.                     return $data;
  630.                 }
  631.             } catch (NotNormalizableValueException $e) {
  632.                 if (!$isUnionType && !$isNullable) {
  633.                     throw $e;
  634.                 }
  635.             } catch (ExtraAttributesException $e) {
  636.                 if (!$isUnionType && !$isNullable) {
  637.                     throw $e;
  638.                 }
  640.                 if (!$extraAttributesException) {
  641.                     $extraAttributesException = $e;
  642.                 }
  643.             } catch (MissingConstructorArgumentsException $e) {
  644.                 if (!$isUnionType && !$isNullable) {
  645.                     throw $e;
  646.                 }
  648.                 if (!$missingConstructorArgumentException) {
  649.                     $missingConstructorArgumentException = $e;
  650.                 }
  651.             }
  652.         }
  654.         if ($isNullable) {
  655.             return null;
  656.         }
  658.         if ($extraAttributesException) {
  659.             throw $extraAttributesException;
  660.         }
  662.         if ($missingConstructorArgumentException) {
  663.             throw $missingConstructorArgumentException;
  664.         }
  666.         if (!$isUnionType && $e) {
  667.             throw $e;
  668.         }
  670.         if ($context[self::DISABLE_TYPE_ENFORCEMENT] ?? $this->defaultContext[self::DISABLE_TYPE_ENFORCEMENT] ?? false) {
  671.             return $data;
  672.         }
  674.         throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the "%s" attribute for class "%s" must be one of "%s" ("%s" given).', $attribute, $currentClass, implode('", "', array_keys($expectedTypes)), get_debug_type($data)), $data, array_keys($expectedTypes), $context['deserialization_path'] ?? $attribute);
  675.     }
  677.     /**
  678.      * @internal
  679.      */
  680.     protected function denormalizeParameter(\ReflectionClass $class, \ReflectionParameter $parameter, string $parameterName, $parameterData, array $context, ?string $format = null)
  681.     {
  682.         if ($parameter->isVariadic() || null === $this->propertyTypeExtractor || null === $types = $this->getTypes($class->getName(), $parameterName)) {
  683.             return parent::denormalizeParameter($class, $parameter, $parameterName, $parameterData, $context, $format);
  684.         }
  686.         $parameterData = $this->validateAndDenormalize($types, $class->getName(), $parameterName, $parameterData, $format, $context);
  688.         return $this->applyCallbacks($parameterData, $class->getName(), $parameterName, $format, $context);
  689.     }
  691.     /**
  692.      * @return Type[]|null
  693.      */
  694.     private function getTypes(string $currentClass, string $attribute): ?array
  695.     {
  696.         if (null === $this->propertyTypeExtractor) {
  697.             return null;
  698.         }
  700.         $key = $currentClass.'::'.$attribute;
  701.         if (isset($this->typesCache[$key])) {
  702.             return false === $this->typesCache[$key] ? null : $this->typesCache[$key];
  703.         }
  705.         if (null !== $types = $this->propertyTypeExtractor->getTypes($currentClass, $attribute)) {
  706.             return $this->typesCache[$key] = $types;
  707.         }
  709.         if (null !== $this->classDiscriminatorResolver && null !== $discriminatorMapping = $this->classDiscriminatorResolver->getMappingForClass($currentClass)) {
  710.             if ($discriminatorMapping->getTypeProperty() === $attribute) {
  711.                 return $this->typesCache[$key] = [
  712.                     new Type(Type::BUILTIN_TYPE_STRING),
  713.                 ];
  714.             }
  716.             foreach ($discriminatorMapping->getTypesMapping() as $mappedClass) {
  717.                 if (null !== $types = $this->propertyTypeExtractor->getTypes($mappedClass, $attribute)) {
  718.                     return $this->typesCache[$key] = $types;
  719.                 }
  720.             }
  721.         }
  723.         $this->typesCache[$key] = false;
  725.         return null;
  726.     }
  728.     /**
  729.      * Sets an attribute and apply the name converter if necessary.
  730.      *
  731.      * @param mixed $attributeValue
  732.      */
  733.     private function updateData(array $data, string $attribute, $attributeValue, string $class, ?string $format, array $context): array
  734.     {
  735.         if (null === $attributeValue && ($context[self::SKIP_NULL_VALUES] ?? $this->defaultContext[self::SKIP_NULL_VALUES] ?? false)) {
  736.             return $data;
  737.         }
  739.         if ($this->nameConverter) {
  740.             $attribute = $this->nameConverter->normalize($attribute, $class, $format, $context);
  741.         }
  743.         $data[$attribute] = $attributeValue;
  745.         return $data;
  746.     }
  748.     /**
  749.      * Is the max depth reached for the given attribute?
  750.      *
  751.      * @param AttributeMetadataInterface[] $attributesMetadata
  752.      */
  753.     private function isMaxDepthReached(array $attributesMetadata, string $class, string $attribute, array &$context): bool
  754.     {
  755.         $enableMaxDepth = $context[self::ENABLE_MAX_DEPTH] ?? $this->defaultContext[self::ENABLE_MAX_DEPTH] ?? false;
  756.         if (
  757.             !$enableMaxDepth ||
  758.             !isset($attributesMetadata[$attribute]) ||
  759.             null === $maxDepth = $attributesMetadata[$attribute]->getMaxDepth()
  760.         ) {
  761.             return false;
  762.         }
  764.         $key = sprintf(self::DEPTH_KEY_PATTERN, $class, $attribute);
  765.         if (!isset($context[$key])) {
  766.             $context[$key] = 1;
  768.             return false;
  769.         }
  771.         if ($context[$key] === $maxDepth) {
  772.             return true;
  773.         }
  775.         ++$context[$key];
  777.         return false;
  778.     }
  780.     /**
  781.      * Overwritten to update the cache key for the child.
  782.      *
  783.      * We must not mix up the attribute cache between parent and children.
  784.      *
  785.      * {@inheritdoc}
  786.      *
  787.      * @internal
  788.      */
  789.     protected function createChildContext(array $parentContext, string $attribute, ?string $format): array
  790.     {
  791.         $context = parent::createChildContext($parentContext, $attribute, $format);
  792.         if ($context['cache_key'] ?? false) {
  793.             $context['cache_key'] .= '-'.$attribute;
  794.         } elseif (false !== ($context['cache_key'] ?? null)) {
  795.             $context['cache_key'] = $this->getCacheKey($format, $context);
  796.         }
  798.         return $context;
  799.     }
  801.     /**
  802.      * Builds the cache key for the attributes cache.
  803.      *
  804.      * The key must be different for every option in the context that could change which attributes should be handled.
  805.      *
  806.      * @return bool|string
  807.      */
  808.     private function getCacheKey(?string $format, array $context)
  809.     {
  810.         foreach ($context[self::EXCLUDE_FROM_CACHE_KEY] ?? $this->defaultContext[self::EXCLUDE_FROM_CACHE_KEY] as $key) {
  811.             unset($context[$key]);
  812.         }
  813.         unset($context[self::EXCLUDE_FROM_CACHE_KEY]);
  814.         unset($context[self::OBJECT_TO_POPULATE]);
  815.         unset($context['cache_key']); // avoid artificially different keys
  817.         try {
  818.             return md5($format.serialize([
  819.                 'context' => $context,
  820.                 'ignored' => $context[self::IGNORED_ATTRIBUTES] ?? $this->defaultContext[self::IGNORED_ATTRIBUTES],
  821.             ]));
  822.         } catch (\Exception $e) {
  823.             // The context cannot be serialized, skip the cache
  824.             return false;
  825.         }
  826.     }
  828.     /**
  829.      * This error may occur when specific object normalizer implementation gets attribute value
  830.      * by accessing a public uninitialized property or by calling a method accessing such property.
  831.      */
  832.     private function isUninitializedValueError(\Error $e): bool
  833.     {
  834.         return \PHP_VERSION_ID >= 70400
  835.             && str_starts_with($e->getMessage(), 'Typed property')
  836.             && str_ends_with($e->getMessage(), 'must not be accessed before initialization');
  837.     }
  838. }