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

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;
  15. use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
  16. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  17. use Symfony\Component\PropertyInfo\Type;
  18. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  19. use Symfony\Component\Serializer\Exception\ExtraAttributesException;
  20. use Symfony\Component\Serializer\Exception\LogicException;
  21. use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
  22. use Symfony\Component\Serializer\Exception\RuntimeException;
  23. use Symfony\Component\Serializer\Mapping\AttributeMetadataInterface;
  24. use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata;
  25. use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface;
  26. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
  27. use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
  29. /**
  30.  * Base class for a normalizer dealing with objects.
  31.  *
  32.  * @author Kévin Dunglas <dunglas@gmail.com>
  33.  */
  34. abstract class AbstractObjectNormalizer extends AbstractNormalizer
  35. {
  36.     /**
  37.      * Set to true to respect the max depth metadata on fields.
  38.      */
  39.     public const ENABLE_MAX_DEPTH = 'enable_max_depth';
  41.     /**
  42.      * How to track the current depth in the context.
  43.      */
  44.     public const DEPTH_KEY_PATTERN = 'depth_%s::%s';
  46.     /**
  47.      * While denormalizing, we can verify that types match.
  48.      *
  49.      * You can disable this by setting this flag to true.
  50.      */
  51.     public const DISABLE_TYPE_ENFORCEMENT = 'disable_type_enforcement';
  53.     /**
  54.      * Flag to control whether fields with the value `null` should be output
  55.      * when normalizing or omitted.
  56.      */
  57.     public const SKIP_NULL_VALUES = 'skip_null_values';
  59.     /**
  60.      * Callback to allow to set a value for an attribute when the max depth has
  61.      * been reached.
  62.      *
  63.      * If no callback is given, the attribute is skipped. If a callable is
  64.      * given, its return value is used (even if null).
  65.      *
  66.      * The arguments are:
  67.      *
  68.      * - mixed  $attributeValue value of this field
  69.      * - object $object         the whole object being normalized
  70.      * - string $attributeName  name of the attribute being normalized
  71.      * - string $format         the requested format
  72.      * - array  $context        the serialization context
  73.      */
  74.     public const MAX_DEPTH_HANDLER = 'max_depth_handler';
  76.     /**
  77.      * Specify which context key are not relevant to determine which attributes
  78.      * of an object to (de)normalize.
  79.      */
  80.     public const EXCLUDE_FROM_CACHE_KEY = 'exclude_from_cache_key';
  82.     /**
  83.      * Flag to tell the denormalizer to also populate existing objects on
  84.      * attributes of the main object.
  85.      *
  86.      * Setting this to true is only useful if you also specify the root object
  87.      * in OBJECT_TO_POPULATE.
  88.      */
  89.     public const DEEP_OBJECT_TO_POPULATE = 'deep_object_to_populate';
  91.     public const PRESERVE_EMPTY_OBJECTS = 'preserve_empty_objects';
  93.     private $propertyTypeExtractor;
  94.     private $typesCache = [];
  95.     private $attributesCache = [];
  97.     /**
  98.      * @deprecated since Symfony 4.2
  99.      *
  100.      * @var callable|null
  101.      */
  102.     private $maxDepthHandler;
  103.     private $objectClassResolver;
  105.     /**
  106.      * @var ClassDiscriminatorResolverInterface|null
  107.      */
  108.     protected $classDiscriminatorResolver;
  110.     public function __construct(ClassMetadataFactoryInterface $classMetadataFactory = null, NameConverterInterface $nameConverter = null, PropertyTypeExtractorInterface $propertyTypeExtractor = null, ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null, callable $objectClassResolver = null, array $defaultContext = [])
  111.     {
  112.         parent::__construct($classMetadataFactory, $nameConverter, $defaultContext);
  114.         if (isset($this->defaultContext[self::MAX_DEPTH_HANDLER]) && !\is_callable($this->defaultContext[self::MAX_DEPTH_HANDLER])) {
  115.             throw new InvalidArgumentException(sprintf('The "%s" given in the default context is not callable.', self::MAX_DEPTH_HANDLER));
  116.         }
  118.         $this->defaultContext[self::EXCLUDE_FROM_CACHE_KEY] = [self::CIRCULAR_REFERENCE_LIMIT_COUNTERS];
  120.         $this->propertyTypeExtractor = $propertyTypeExtractor;
  122.         if (null === $classDiscriminatorResolver && null !== $classMetadataFactory) {
  123.             $classDiscriminatorResolver = new ClassDiscriminatorFromClassMetadata($classMetadataFactory);
  124.         }
  125.         $this->classDiscriminatorResolver = $classDiscriminatorResolver;
  126.         $this->objectClassResolver = $objectClassResolver;
  127.     }
  129.     /**
  130.      * {@inheritdoc}
  131.      */
  132.     public function supportsNormalization($data, $format = null)
  133.     {
  134.         return \is_object($data) && !$data instanceof \Traversable;
  135.     }
  137.     /**
  138.      * {@inheritdoc}
  139.      */
  140.     public function normalize($object, $format = null, array $context = [])
  141.     {
  142.         if (!isset($context['cache_key'])) {
  143.             $context['cache_key'] = $this->getCacheKey($format, $context);
  144.         }
  146.         if (isset($context[self::CALLBACKS])) {
  147.             if (!\is_array($context[self::CALLBACKS])) {
  148.                 throw new InvalidArgumentException(sprintf('The "%s" context option must be an array of callables.', self::CALLBACKS));
  149.             }
  151.             foreach ($context[self::CALLBACKS] as $attribute => $callback) {
  152.                 if (!\is_callable($callback)) {
  153.                     throw new InvalidArgumentException(sprintf('Invalid callback found for attribute "%s" in the "%s" context option.', $attribute, self::CALLBACKS));
  154.                 }
  155.             }
  156.         }
  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.             // already validated in constructor resp by type declaration of setMaxDepthHandler
  174.             $maxDepthHandler = $this->defaultContext[self::MAX_DEPTH_HANDLER] ?? $this->maxDepthHandler;
  175.         }
  177.         foreach ($attributes as $attribute) {
  178.             $maxDepthReached = false;
  179.             if (null !== $attributesMetadata && ($maxDepthReached = $this->isMaxDepthReached($attributesMetadata, $class, $attribute, $context)) && !$maxDepthHandler) {
  180.                 continue;
  181.             }
  183.             $attributeValue = $this->getAttributeValue($object, $attribute, $format, $context);
  184.             if ($maxDepthReached) {
  185.                 $attributeValue = $maxDepthHandler($attributeValue, $object, $attribute, $format, $context);
  186.             }
  188.             /**
  189.              * @var callable|null
  190.              */
  191.             $callback = $context[self::CALLBACKS][$attribute] ?? $this->defaultContext[self::CALLBACKS][$attribute] ?? $this->callbacks[$attribute] ?? null;
  192.             if ($callback) {
  193.                 $attributeValue = $callback($attributeValue, $object, $attribute, $format, $context);
  194.             }
  196.             if (null !== $attributeValue && !is_scalar($attributeValue)) {
  197.                 $stack[$attribute] = $attributeValue;
  198.             }
  200.             $data = $this->updateData($data, $attribute, $attributeValue, $class, $format, $context);
  201.         }
  203.         foreach ($stack as $attribute => $attributeValue) {
  204.             if (!$this->serializer instanceof NormalizerInterface) {
  205.                 throw new LogicException(sprintf('Cannot normalize attribute "%s" because the injected serializer is not a normalizer.', $attribute));
  206.             }
  208.             $data = $this->updateData($data, $attribute, $this->serializer->normalize($attributeValue, $format, $this->createChildContext($context, $attribute, $format)), $class, $format, $context);
  209.         }
  211.         if (isset($context[self::PRESERVE_EMPTY_OBJECTS]) && !\count($data)) {
  212.             return new \ArrayObject();
  213.         }
  215.         return $data;
  216.     }
  218.     /**
  219.      * {@inheritdoc}
  220.      */
  221.     protected function instantiateObject(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes, string $format = null)
  222.     {
  223.         if ($this->classDiscriminatorResolver && $mapping = $this->classDiscriminatorResolver->getMappingForClass($class)) {
  224.             if (!isset($data[$mapping->getTypeProperty()])) {
  225.                 throw new RuntimeException(sprintf('Type property "%s" not found for the abstract object "%s".', $mapping->getTypeProperty(), $class));
  226.             }
  228.             $type = $data[$mapping->getTypeProperty()];
  229.             if (null === ($mappedClass = $mapping->getClassForType($type))) {
  230.                 throw new RuntimeException(sprintf('The type "%s" has no mapped class for the abstract object "%s".', $type, $class));
  231.             }
  233.             $class = $mappedClass;
  234.             $reflectionClass = new \ReflectionClass($class);
  235.         }
  237.         return parent::instantiateObject($data, $class, $context, $reflectionClass, $allowedAttributes, $format);
  238.     }
  240.     /**
  241.      * Gets and caches attributes for the given object, format and context.
  242.      *
  243.      * @param object      $object
  244.      * @param string|null $format
  245.      *
  246.      * @return string[]
  247.      */
  248.     protected function getAttributes($object, $format = null, array $context)
  249.     {
  250.         $class = $this->objectClassResolver ? ($this->objectClassResolver)($object) : \get_class($object);
  251.         $key = $class.'-'.$context['cache_key'];
  253.         if (isset($this->attributesCache[$key])) {
  254.             return $this->attributesCache[$key];
  255.         }
  257.         $allowedAttributes = $this->getAllowedAttributes($object, $context, true);
  259.         if (false !== $allowedAttributes) {
  260.             if ($context['cache_key']) {
  261.                 $this->attributesCache[$key] = $allowedAttributes;
  262.             }
  264.             return $allowedAttributes;
  265.         }
  267.         $attributes = $this->extractAttributes($object, $format, $context);
  269.         if ($this->classDiscriminatorResolver && $mapping = $this->classDiscriminatorResolver->getMappingForMappedObject($object)) {
  270.             array_unshift($attributes, $mapping->getTypeProperty());
  271.         }
  273.         if ($context['cache_key']) {
  274.             $this->attributesCache[$key] = $attributes;
  275.         }
  277.         return $attributes;
  278.     }
  280.     /**
  281.      * Extracts attributes to normalize from the class of the given object, format and context.
  282.      *
  283.      * @param object      $object
  284.      * @param string|null $format
  285.      *
  286.      * @return string[]
  287.      */
  288.     abstract protected function extractAttributes($object, $format = null, array $context = []);
  290.     /**
  291.      * Gets the attribute value.
  292.      *
  293.      * @param object      $object
  294.      * @param string      $attribute
  295.      * @param string|null $format
  296.      *
  297.      * @return mixed
  298.      */
  299.     abstract protected function getAttributeValue($object, $attribute, $format = null, array $context = []);
  301.     /**
  302.      * Sets a handler function that will be called when the max depth is reached.
  303.      *
  304.      * @deprecated since Symfony 4.2
  305.      */
  306.     public function setMaxDepthHandler(?callable $handler): void
  307.     {
  308.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2, use the "max_depth_handler" key of the context instead.', __METHOD__), E_USER_DEPRECATED);
  310.         $this->maxDepthHandler = $handler;
  311.     }
  313.     /**
  314.      * {@inheritdoc}
  315.      */
  316.     public function supportsDenormalization($data, $type, $format = null)
  317.     {
  318.         return class_exists($type) || (interface_exists($type, false) && $this->classDiscriminatorResolver && null !== $this->classDiscriminatorResolver->getMappingForClass($type));
  319.     }
  321.     /**
  322.      * {@inheritdoc}
  323.      */
  324.     public function denormalize($data, $type, $format = null, array $context = [])
  325.     {
  326.         if (!isset($context['cache_key'])) {
  327.             $context['cache_key'] = $this->getCacheKey($format, $context);
  328.         }
  330.         $allowedAttributes = $this->getAllowedAttributes($type, $context, true);
  331.         $normalizedData = $this->prepareForDenormalization($data);
  332.         $extraAttributes = [];
  334.         $reflectionClass = new \ReflectionClass($type);
  335.         $object = $this->instantiateObject($normalizedData, $type, $context, $reflectionClass, $allowedAttributes, $format);
  336.         $resolvedClass = $this->objectClassResolver ? ($this->objectClassResolver)($object) : \get_class($object);
  338.         foreach ($normalizedData as $attribute => $value) {
  339.             if ($this->nameConverter) {
  340.                 $attribute = $this->nameConverter->denormalize($attribute, $resolvedClass, $format, $context);
  341.             }
  343.             if ((false !== $allowedAttributes && !\in_array($attribute, $allowedAttributes)) || !$this->isAllowedAttribute($resolvedClass, $attribute, $format, $context)) {
  344.                 if (!($context[self::ALLOW_EXTRA_ATTRIBUTES] ?? $this->defaultContext[self::ALLOW_EXTRA_ATTRIBUTES])) {
  345.                     $extraAttributes[] = $attribute;
  346.                 }
  348.                 continue;
  349.             }
  351.             if ($context[self::DEEP_OBJECT_TO_POPULATE] ?? $this->defaultContext[self::DEEP_OBJECT_TO_POPULATE] ?? false) {
  352.                 try {
  353.                     $context[self::OBJECT_TO_POPULATE] = $this->getAttributeValue($object, $attribute, $format, $context);
  354.                 } catch (NoSuchPropertyException $e) {
  355.                 }
  356.             }
  358.             $value = $this->validateAndDenormalize($resolvedClass, $attribute, $value, $format, $context);
  359.             try {
  360.                 $this->setAttributeValue($object, $attribute, $value, $format, $context);
  361.             } catch (InvalidArgumentException $e) {
  362.                 throw new NotNormalizableValueException(sprintf('Failed to denormalize attribute "%s" value for class "%s": '.$e->getMessage(), $attribute, $type), $e->getCode(), $e);
  363.             }
  364.         }
  366.         if (!empty($extraAttributes)) {
  367.             throw new ExtraAttributesException($extraAttributes);
  368.         }
  370.         return $object;
  371.     }
  373.     /**
  374.      * Sets attribute value.
  375.      *
  376.      * @param object      $object
  377.      * @param string      $attribute
  378.      * @param mixed       $value
  379.      * @param string|null $format
  380.      */
  381.     abstract protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = []);
  383.     /**
  384.      * Validates the submitted data and denormalizes it.
  385.      *
  386.      * @param mixed $data
  387.      *
  388.      * @return mixed
  389.      *
  390.      * @throws NotNormalizableValueException
  391.      * @throws LogicException
  392.      */
  393.     private function validateAndDenormalize(string $currentClass, string $attribute, $data, ?string $format, array $context)
  394.     {
  395.         if (null === $types = $this->getTypes($currentClass, $attribute)) {
  396.             return $data;
  397.         }
  399.         $expectedTypes = [];
  400.         foreach ($types as $type) {
  401.             if (null === $data && $type->isNullable()) {
  402.                 return null;
  403.             }
  405.             $collectionValueType = $type->isCollection() ? $type->getCollectionValueType() : null;
  407.             // Fix a collection that contains the only one element
  408.             // This is special to xml format only
  409.             if ('xml' === $format && null !== $collectionValueType && (!\is_array($data) || !\is_int(key($data)))) {
  410.                 $data = [$data];
  411.             }
  413.             if (null !== $collectionValueType && Type::BUILTIN_TYPE_OBJECT === $collectionValueType->getBuiltinType()) {
  414.                 $builtinType = Type::BUILTIN_TYPE_OBJECT;
  415.                 $class = $collectionValueType->getClassName().'[]';
  417.                 if (null !== $collectionKeyType = $type->getCollectionKeyType()) {
  418.                     $context['key_type'] = $collectionKeyType;
  419.                 }
  420.             } elseif ($type->isCollection() && null !== ($collectionValueType = $type->getCollectionValueType()) && Type::BUILTIN_TYPE_ARRAY === $collectionValueType->getBuiltinType()) {
  421.                 // get inner type for any nested array
  422.                 $innerType = $collectionValueType;
  424.                 // note that it will break for any other builtinType
  425.                 $dimensions = '[]';
  426.                 while (null !== $innerType->getCollectionValueType() && Type::BUILTIN_TYPE_ARRAY === $innerType->getBuiltinType()) {
  427.                     $dimensions .= '[]';
  428.                     $innerType = $innerType->getCollectionValueType();
  429.                 }
  431.                 if (null !== $innerType->getClassName()) {
  432.                     // the builtinType is the inner one and the class is the class followed by []...[]
  433.                     $builtinType = $innerType->getBuiltinType();
  434.                     $class = $innerType->getClassName().$dimensions;
  435.                 } else {
  436.                     // default fallback (keep it as array)
  437.                     $builtinType = $type->getBuiltinType();
  438.                     $class = $type->getClassName();
  439.                 }
  440.             } else {
  441.                 $builtinType = $type->getBuiltinType();
  442.                 $class = $type->getClassName();
  443.             }
  445.             $expectedTypes[Type::BUILTIN_TYPE_OBJECT === $builtinType && $class ? $class : $builtinType] = true;
  447.             if (Type::BUILTIN_TYPE_OBJECT === $builtinType) {
  448.                 if (!$this->serializer instanceof DenormalizerInterface) {
  449.                     throw new LogicException(sprintf('Cannot denormalize attribute "%s" for class "%s" because injected serializer is not a denormalizer.', $attribute, $class));
  450.                 }
  452.                 $childContext = $this->createChildContext($context, $attribute, $format);
  453.                 if ($this->serializer->supportsDenormalization($data, $class, $format, $childContext)) {
  454.                     return $this->serializer->denormalize($data, $class, $format, $childContext);
  455.                 }
  456.             }
  458.             // JSON only has a Number type corresponding to both int and float PHP types.
  459.             // PHP's json_encode, JavaScript's JSON.stringify, Go's json.Marshal as well as most other JSON encoders convert
  460.             // floating-point numbers like 12.0 to 12 (the decimal part is dropped when possible).
  461.             // PHP's json_decode automatically converts Numbers without a decimal part to integers.
  462.             // To circumvent this behavior, integers are converted to floats when denormalizing JSON based formats and when
  463.             // a float is expected.
  464.             if (Type::BUILTIN_TYPE_FLOAT === $builtinType && \is_int($data) && false !== strpos($format, JsonEncoder::FORMAT)) {
  465.                 return (float) $data;
  466.             }
  468.             if (('is_'.$builtinType)($data)) {
  469.                 return $data;
  470.             }
  471.         }
  473.         if ($context[self::DISABLE_TYPE_ENFORCEMENT] ?? $this->defaultContext[self::DISABLE_TYPE_ENFORCEMENT] ?? false) {
  474.             return $data;
  475.         }
  477.         throw new NotNormalizableValueException(sprintf('The type of the "%s" attribute for class "%s" must be one of "%s" ("%s" given).', $attribute, $currentClass, implode('", "', array_keys($expectedTypes)), \gettype($data)));
  478.     }
  480.     /**
  481.      * @internal
  482.      */
  483.     protected function denormalizeParameter(\ReflectionClass $class, \ReflectionParameter $parameter, $parameterName, $parameterData, array $context, $format = null)
  484.     {
  485.         if (null === $this->propertyTypeExtractor || null === $this->propertyTypeExtractor->getTypes($class->getName(), $parameterName)) {
  486.             return parent::denormalizeParameter($class, $parameter, $parameterName, $parameterData, $context, $format);
  487.         }
  489.         return $this->validateAndDenormalize($class->getName(), $parameterName, $parameterData, $format, $context);
  490.     }
  492.     /**
  493.      * @return Type[]|null
  494.      */
  495.     private function getTypes(string $currentClass, string $attribute): ?array
  496.     {
  497.         if (null === $this->propertyTypeExtractor) {
  498.             return null;
  499.         }
  501.         $key = $currentClass.'::'.$attribute;
  502.         if (isset($this->typesCache[$key])) {
  503.             return false === $this->typesCache[$key] ? null : $this->typesCache[$key];
  504.         }
  506.         if (null !== $types = $this->propertyTypeExtractor->getTypes($currentClass, $attribute)) {
  507.             return $this->typesCache[$key] = $types;
  508.         }
  510.         if (null !== $this->classDiscriminatorResolver && null !== $discriminatorMapping = $this->classDiscriminatorResolver->getMappingForClass($currentClass)) {
  511.             if ($discriminatorMapping->getTypeProperty() === $attribute) {
  512.                 return $this->typesCache[$key] = [
  513.                     new Type(Type::BUILTIN_TYPE_STRING),
  514.                 ];
  515.             }
  517.             foreach ($discriminatorMapping->getTypesMapping() as $mappedClass) {
  518.                 if (null !== $types = $this->propertyTypeExtractor->getTypes($mappedClass, $attribute)) {
  519.                     return $this->typesCache[$key] = $types;
  520.                 }
  521.             }
  522.         }
  524.         $this->typesCache[$key] = false;
  526.         return null;
  527.     }
  529.     /**
  530.      * Sets an attribute and apply the name converter if necessary.
  531.      *
  532.      * @param mixed $attributeValue
  533.      */
  534.     private function updateData(array $data, string $attribute, $attributeValue, string $class, ?string $format, array $context): array
  535.     {
  536.         if (null === $attributeValue && ($context[self::SKIP_NULL_VALUES] ?? $this->defaultContext[self::SKIP_NULL_VALUES] ?? false)) {
  537.             return $data;
  538.         }
  540.         if ($this->nameConverter) {
  541.             $attribute = $this->nameConverter->normalize($attribute, $class, $format, $context);
  542.         }
  544.         $data[$attribute] = $attributeValue;
  546.         return $data;
  547.     }
  549.     /**
  550.      * Is the max depth reached for the given attribute?
  551.      *
  552.      * @param AttributeMetadataInterface[] $attributesMetadata
  553.      */
  554.     private function isMaxDepthReached(array $attributesMetadata, string $class, string $attribute, array &$context): bool
  555.     {
  556.         $enableMaxDepth = $context[self::ENABLE_MAX_DEPTH] ?? $this->defaultContext[self::ENABLE_MAX_DEPTH] ?? false;
  557.         if (
  558.             !$enableMaxDepth ||
  559.             !isset($attributesMetadata[$attribute]) ||
  560.             null === $maxDepth = $attributesMetadata[$attribute]->getMaxDepth()
  561.         ) {
  562.             return false;
  563.         }
  565.         $key = sprintf(self::DEPTH_KEY_PATTERN, $class, $attribute);
  566.         if (!isset($context[$key])) {
  567.             $context[$key] = 1;
  569.             return false;
  570.         }
  572.         if ($context[$key] === $maxDepth) {
  573.             return true;
  574.         }
  576.         ++$context[$key];
  578.         return false;
  579.     }
  581.     /**
  582.      * Overwritten to update the cache key for the child.
  583.      *
  584.      * We must not mix up the attribute cache between parent and children.
  585.      *
  586.      * {@inheritdoc}
  587.      *
  588.      * @param string|null $format
  589.      *
  590.      * @internal
  591.      */
  592.     protected function createChildContext(array $parentContext, $attribute/*, ?string $format */): array
  593.     {
  594.         if (\func_num_args() >= 3) {
  595.             $format = func_get_arg(2);
  596.         } else {
  597.             @trigger_error(sprintf('Method "%s::%s()" will have a third "?string $format" argument in version 5.0; not defining it is deprecated since Symfony 4.3.', static::class, __FUNCTION__), E_USER_DEPRECATED);
  598.             $format = null;
  599.         }
  601.         $context = parent::createChildContext($parentContext, $attribute, $format);
  602.         $context['cache_key'] = $this->getCacheKey($format, $context);
  604.         return $context;
  605.     }
  607.     /**
  608.      * Builds the cache key for the attributes cache.
  609.      *
  610.      * The key must be different for every option in the context that could change which attributes should be handled.
  611.      *
  612.      * @return bool|string
  613.      */
  614.     private function getCacheKey(?string $format, array $context)
  615.     {
  616.         foreach ($context[self::EXCLUDE_FROM_CACHE_KEY] ?? $this->defaultContext[self::EXCLUDE_FROM_CACHE_KEY] as $key) {
  617.             unset($context[$key]);
  618.         }
  619.         unset($context[self::EXCLUDE_FROM_CACHE_KEY]);
  620.         unset($context[self::OBJECT_TO_POPULATE]);
  621.         unset($context['cache_key']); // avoid artificially different keys
  623.         try {
  624.             return md5($format.serialize([
  625.                 'context' => $context,
  626.                 'ignored' => $this->ignoredAttributes,
  627.                 'camelized' => $this->camelizedAttributes,
  628.             ]));
  629.         } catch (\Exception $exception) {
  630.             // The context cannot be serialized, skip the cache
  631.             return false;
  632.         }
  633.     }
  634. }