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

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.             if ($mappedClass !== $class) {
  234.                 return $this->instantiateObject($data, $mappedClass, $context, new \ReflectionClass($mappedClass), $allowedAttributes, $format);
  235.             }
  236.         }
  238.         return parent::instantiateObject($data, $class, $context, $reflectionClass, $allowedAttributes, $format);
  239.     }
  241.     /**
  242.      * Gets and caches attributes for the given object, format and context.
  243.      *
  244.      * @param object      $object
  245.      * @param string|null $format
  246.      *
  247.      * @return string[]
  248.      */
  249.     protected function getAttributes($object, $format, array $context)
  250.     {
  251.         $class = $this->objectClassResolver ? ($this->objectClassResolver)($object) : \get_class($object);
  252.         $key = $class.'-'.$context['cache_key'];
  254.         if (isset($this->attributesCache[$key])) {
  255.             return $this->attributesCache[$key];
  256.         }
  258.         $allowedAttributes = $this->getAllowedAttributes($object, $context, true);
  260.         if (false !== $allowedAttributes) {
  261.             if ($context['cache_key']) {
  262.                 $this->attributesCache[$key] = $allowedAttributes;
  263.             }
  265.             return $allowedAttributes;
  266.         }
  268.         $attributes = $this->extractAttributes($object, $format, $context);
  270.         if ($this->classDiscriminatorResolver && $mapping = $this->classDiscriminatorResolver->getMappingForMappedObject($object)) {
  271.             array_unshift($attributes, $mapping->getTypeProperty());
  272.         }
  274.         if ($context['cache_key']) {
  275.             $this->attributesCache[$key] = $attributes;
  276.         }
  278.         return $attributes;
  279.     }
  281.     /**
  282.      * Extracts attributes to normalize from the class of the given object, format and context.
  283.      *
  284.      * @param object      $object
  285.      * @param string|null $format
  286.      *
  287.      * @return string[]
  288.      */
  289.     abstract protected function extractAttributes($object, $format = null, array $context = []);
  291.     /**
  292.      * Gets the attribute value.
  293.      *
  294.      * @param object      $object
  295.      * @param string      $attribute
  296.      * @param string|null $format
  297.      *
  298.      * @return mixed
  299.      */
  300.     abstract protected function getAttributeValue($object, $attribute, $format = null, array $context = []);
  302.     /**
  303.      * Sets a handler function that will be called when the max depth is reached.
  304.      *
  305.      * @deprecated since Symfony 4.2
  306.      */
  307.     public function setMaxDepthHandler(?callable $handler): void
  308.     {
  309.         @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);
  311.         $this->maxDepthHandler = $handler;
  312.     }
  314.     /**
  315.      * {@inheritdoc}
  316.      */
  317.     public function supportsDenormalization($data, $type, $format = null)
  318.     {
  319.         return class_exists($type) || (interface_exists($type, false) && $this->classDiscriminatorResolver && null !== $this->classDiscriminatorResolver->getMappingForClass($type));
  320.     }
  322.     /**
  323.      * {@inheritdoc}
  324.      */
  325.     public function denormalize($data, $type, $format = null, array $context = [])
  326.     {
  327.         if (!isset($context['cache_key'])) {
  328.             $context['cache_key'] = $this->getCacheKey($format, $context);
  329.         }
  331.         $allowedAttributes = $this->getAllowedAttributes($type, $context, true);
  332.         $normalizedData = $this->prepareForDenormalization($data);
  333.         $extraAttributes = [];
  335.         $reflectionClass = new \ReflectionClass($type);
  336.         $object = $this->instantiateObject($normalizedData, $type, $context, $reflectionClass, $allowedAttributes, $format);
  337.         $resolvedClass = $this->objectClassResolver ? ($this->objectClassResolver)($object) : \get_class($object);
  339.         foreach ($normalizedData as $attribute => $value) {
  340.             if ($this->nameConverter) {
  341.                 $attribute = $this->nameConverter->denormalize($attribute, $resolvedClass, $format, $context);
  342.             }
  344.             if ((false !== $allowedAttributes && !\in_array($attribute, $allowedAttributes)) || !$this->isAllowedAttribute($resolvedClass, $attribute, $format, $context)) {
  345.                 if (!($context[self::ALLOW_EXTRA_ATTRIBUTES] ?? $this->defaultContext[self::ALLOW_EXTRA_ATTRIBUTES])) {
  346.                     $extraAttributes[] = $attribute;
  347.                 }
  349.                 continue;
  350.             }
  352.             if ($context[self::DEEP_OBJECT_TO_POPULATE] ?? $this->defaultContext[self::DEEP_OBJECT_TO_POPULATE] ?? false) {
  353.                 try {
  354.                     $context[self::OBJECT_TO_POPULATE] = $this->getAttributeValue($object, $attribute, $format, $context);
  355.                 } catch (NoSuchPropertyException $e) {
  356.                 }
  357.             }
  359.             $value = $this->validateAndDenormalize($resolvedClass, $attribute, $value, $format, $context);
  360.             try {
  361.                 $this->setAttributeValue($object, $attribute, $value, $format, $context);
  362.             } catch (InvalidArgumentException $e) {
  363.                 throw new NotNormalizableValueException(sprintf('Failed to denormalize attribute "%s" value for class "%s": ', $attribute, $type).$e->getMessage(), $e->getCode(), $e);
  364.             }
  365.         }
  367.         if (!empty($extraAttributes)) {
  368.             throw new ExtraAttributesException($extraAttributes);
  369.         }
  371.         return $object;
  372.     }
  374.     /**
  375.      * Sets attribute value.
  376.      *
  377.      * @param object      $object
  378.      * @param string      $attribute
  379.      * @param mixed       $value
  380.      * @param string|null $format
  381.      */
  382.     abstract protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = []);
  384.     /**
  385.      * Validates the submitted data and denormalizes it.
  386.      *
  387.      * @param mixed $data
  388.      *
  389.      * @return mixed
  390.      *
  391.      * @throws NotNormalizableValueException
  392.      * @throws LogicException
  393.      */
  394.     private function validateAndDenormalize(string $currentClass, string $attribute, $data, ?string $format, array $context)
  395.     {
  396.         if (null === $types = $this->getTypes($currentClass, $attribute)) {
  397.             return $data;
  398.         }
  400.         $expectedTypes = [];
  401.         foreach ($types as $type) {
  402.             if (null === $data && $type->isNullable()) {
  403.                 return null;
  404.             }
  406.             $collectionValueType = $type->isCollection() ? $type->getCollectionValueType() : null;
  408.             // Fix a collection that contains the only one element
  409.             // This is special to xml format only
  410.             if ('xml' === $format && null !== $collectionValueType && (!\is_array($data) || !\is_int(key($data)))) {
  411.                 $data = [$data];
  412.             }
  414.             if (null !== $collectionValueType && Type::BUILTIN_TYPE_OBJECT === $collectionValueType->getBuiltinType()) {
  415.                 $builtinType = Type::BUILTIN_TYPE_OBJECT;
  416.                 $class = $collectionValueType->getClassName().'[]';
  418.                 if (null !== $collectionKeyType = $type->getCollectionKeyType()) {
  419.                     $context['key_type'] = $collectionKeyType;
  420.                 }
  421.             } elseif ($type->isCollection() && null !== ($collectionValueType = $type->getCollectionValueType()) && Type::BUILTIN_TYPE_ARRAY === $collectionValueType->getBuiltinType()) {
  422.                 // get inner type for any nested array
  423.                 $innerType = $collectionValueType;
  425.                 // note that it will break for any other builtinType
  426.                 $dimensions = '[]';
  427.                 while (null !== $innerType->getCollectionValueType() && Type::BUILTIN_TYPE_ARRAY === $innerType->getBuiltinType()) {
  428.                     $dimensions .= '[]';
  429.                     $innerType = $innerType->getCollectionValueType();
  430.                 }
  432.                 if (null !== $innerType->getClassName()) {
  433.                     // the builtinType is the inner one and the class is the class followed by []...[]
  434.                     $builtinType = $innerType->getBuiltinType();
  435.                     $class = $innerType->getClassName().$dimensions;
  436.                 } else {
  437.                     // default fallback (keep it as array)
  438.                     $builtinType = $type->getBuiltinType();
  439.                     $class = $type->getClassName();
  440.                 }
  441.             } else {
  442.                 $builtinType = $type->getBuiltinType();
  443.                 $class = $type->getClassName();
  444.             }
  446.             $expectedTypes[Type::BUILTIN_TYPE_OBJECT === $builtinType && $class ? $class : $builtinType] = true;
  448.             if (Type::BUILTIN_TYPE_OBJECT === $builtinType) {
  449.                 if (!$this->serializer instanceof DenormalizerInterface) {
  450.                     throw new LogicException(sprintf('Cannot denormalize attribute "%s" for class "%s" because injected serializer is not a denormalizer.', $attribute, $class));
  451.                 }
  453.                 $childContext = $this->createChildContext($context, $attribute, $format);
  454.                 if ($this->serializer->supportsDenormalization($data, $class, $format, $childContext)) {
  455.                     return $this->serializer->denormalize($data, $class, $format, $childContext);
  456.                 }
  457.             }
  459.             // JSON only has a Number type corresponding to both int and float PHP types.
  460.             // PHP's json_encode, JavaScript's JSON.stringify, Go's json.Marshal as well as most other JSON encoders convert
  461.             // floating-point numbers like 12.0 to 12 (the decimal part is dropped when possible).
  462.             // PHP's json_decode automatically converts Numbers without a decimal part to integers.
  463.             // To circumvent this behavior, integers are converted to floats when denormalizing JSON based formats and when
  464.             // a float is expected.
  465.             if (Type::BUILTIN_TYPE_FLOAT === $builtinType && \is_int($data) && false !== strpos($format, JsonEncoder::FORMAT)) {
  466.                 return (float) $data;
  467.             }
  469.             if (('is_'.$builtinType)($data)) {
  470.                 return $data;
  471.             }
  472.         }
  474.         if ($context[self::DISABLE_TYPE_ENFORCEMENT] ?? $this->defaultContext[self::DISABLE_TYPE_ENFORCEMENT] ?? false) {
  475.             return $data;
  476.         }
  478.         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)));
  479.     }
  481.     /**
  482.      * @internal
  483.      */
  484.     protected function denormalizeParameter(\ReflectionClass $class, \ReflectionParameter $parameter, $parameterName, $parameterData, array $context, $format = null)
  485.     {
  486.         if (null === $this->propertyTypeExtractor || null === $this->propertyTypeExtractor->getTypes($class->getName(), $parameterName)) {
  487.             return parent::denormalizeParameter($class, $parameter, $parameterName, $parameterData, $context, $format);
  488.         }
  490.         return $this->validateAndDenormalize($class->getName(), $parameterName, $parameterData, $format, $context);
  491.     }
  493.     /**
  494.      * @return Type[]|null
  495.      */
  496.     private function getTypes(string $currentClass, string $attribute): ?array
  497.     {
  498.         if (null === $this->propertyTypeExtractor) {
  499.             return null;
  500.         }
  502.         $key = $currentClass.'::'.$attribute;
  503.         if (isset($this->typesCache[$key])) {
  504.             return false === $this->typesCache[$key] ? null : $this->typesCache[$key];
  505.         }
  507.         if (null !== $types = $this->propertyTypeExtractor->getTypes($currentClass, $attribute)) {
  508.             return $this->typesCache[$key] = $types;
  509.         }
  511.         if (null !== $this->classDiscriminatorResolver && null !== $discriminatorMapping = $this->classDiscriminatorResolver->getMappingForClass($currentClass)) {
  512.             if ($discriminatorMapping->getTypeProperty() === $attribute) {
  513.                 return $this->typesCache[$key] = [
  514.                     new Type(Type::BUILTIN_TYPE_STRING),
  515.                 ];
  516.             }
  518.             foreach ($discriminatorMapping->getTypesMapping() as $mappedClass) {
  519.                 if (null !== $types = $this->propertyTypeExtractor->getTypes($mappedClass, $attribute)) {
  520.                     return $this->typesCache[$key] = $types;
  521.                 }
  522.             }
  523.         }
  525.         $this->typesCache[$key] = false;
  527.         return null;
  528.     }
  530.     /**
  531.      * Sets an attribute and apply the name converter if necessary.
  532.      *
  533.      * @param mixed $attributeValue
  534.      */
  535.     private function updateData(array $data, string $attribute, $attributeValue, string $class, ?string $format, array $context): array
  536.     {
  537.         if (null === $attributeValue && ($context[self::SKIP_NULL_VALUES] ?? $this->defaultContext[self::SKIP_NULL_VALUES] ?? false)) {
  538.             return $data;
  539.         }
  541.         if ($this->nameConverter) {
  542.             $attribute = $this->nameConverter->normalize($attribute, $class, $format, $context);
  543.         }
  545.         $data[$attribute] = $attributeValue;
  547.         return $data;
  548.     }
  550.     /**
  551.      * Is the max depth reached for the given attribute?
  552.      *
  553.      * @param AttributeMetadataInterface[] $attributesMetadata
  554.      */
  555.     private function isMaxDepthReached(array $attributesMetadata, string $class, string $attribute, array &$context): bool
  556.     {
  557.         $enableMaxDepth = $context[self::ENABLE_MAX_DEPTH] ?? $this->defaultContext[self::ENABLE_MAX_DEPTH] ?? false;
  558.         if (
  559.             !$enableMaxDepth ||
  560.             !isset($attributesMetadata[$attribute]) ||
  561.             null === $maxDepth = $attributesMetadata[$attribute]->getMaxDepth()
  562.         ) {
  563.             return false;
  564.         }
  566.         $key = sprintf(self::DEPTH_KEY_PATTERN, $class, $attribute);
  567.         if (!isset($context[$key])) {
  568.             $context[$key] = 1;
  570.             return false;
  571.         }
  573.         if ($context[$key] === $maxDepth) {
  574.             return true;
  575.         }
  577.         ++$context[$key];
  579.         return false;
  580.     }
  582.     /**
  583.      * Overwritten to update the cache key for the child.
  584.      *
  585.      * We must not mix up the attribute cache between parent and children.
  586.      *
  587.      * {@inheritdoc}
  588.      *
  589.      * @param string|null $format
  590.      *
  591.      * @internal
  592.      */
  593.     protected function createChildContext(array $parentContext, $attribute/*, ?string $format */): array
  594.     {
  595.         if (\func_num_args() >= 3) {
  596.             $format = func_get_arg(2);
  597.         } else {
  598.             @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);
  599.             $format = null;
  600.         }
  602.         $context = parent::createChildContext($parentContext, $attribute, $format);
  603.         $context['cache_key'] = $this->getCacheKey($format, $context);
  605.         return $context;
  606.     }
  608.     /**
  609.      * Builds the cache key for the attributes cache.
  610.      *
  611.      * The key must be different for every option in the context that could change which attributes should be handled.
  612.      *
  613.      * @return bool|string
  614.      */
  615.     private function getCacheKey(?string $format, array $context)
  616.     {
  617.         foreach ($context[self::EXCLUDE_FROM_CACHE_KEY] ?? $this->defaultContext[self::EXCLUDE_FROM_CACHE_KEY] as $key) {
  618.             unset($context[$key]);
  619.         }
  620.         unset($context[self::EXCLUDE_FROM_CACHE_KEY]);
  621.         unset($context[self::OBJECT_TO_POPULATE]);
  622.         unset($context['cache_key']); // avoid artificially different keys
  624.         try {
  625.             return md5($format.serialize([
  626.                 'context' => $context,
  627.                 'ignored' => $this->ignoredAttributes,
  628.                 'camelized' => $this->camelizedAttributes,
  629.             ]));
  630.         } catch (\Exception $exception) {
  631.             // The context cannot be serialized, skip the cache
  632.             return false;
  633.         }
  634.     }
  635. }