vendor/symfony/serializer/Normalizer/AbstractNormalizer.php line 187

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\Serializer\Exception\CircularReferenceException;
  15. use Symfony\Component\Serializer\Exception\InvalidArgumentException;
  16. use Symfony\Component\Serializer\Exception\LogicException;
  17. use Symfony\Component\Serializer\Exception\MissingConstructorArgumentsException;
  18. use Symfony\Component\Serializer\Exception\RuntimeException;
  19. use Symfony\Component\Serializer\Mapping\AttributeMetadataInterface;
  20. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
  21. use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
  22. use Symfony\Component\Serializer\SerializerAwareInterface;
  23. use Symfony\Component\Serializer\SerializerAwareTrait;
  25. /**
  26.  * Normalizer implementation.
  27.  *
  28.  * @author Kévin Dunglas <dunglas@gmail.com>
  29.  */
  30. abstract class AbstractNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
  31. {
  32.     use ObjectToPopulateTrait;
  33.     use SerializerAwareTrait;
  35.     /* constants to configure the context */
  37.     /**
  38.      * How many loops of circular reference to allow while normalizing.
  39.      *
  40.      * The default value of 1 means that when we encounter the same object a
  41.      * second time, we consider that a circular reference.
  42.      *
  43.      * You can raise this value for special cases, e.g. in combination with the
  44.      * max depth setting of the object normalizer.
  45.      */
  46.     public const CIRCULAR_REFERENCE_LIMIT = 'circular_reference_limit';
  48.     /**
  49.      * Instead of creating a new instance of an object, update the specified object.
  50.      *
  51.      * If you have a nested structure, child objects will be overwritten with
  52.      * new instances unless you set DEEP_OBJECT_TO_POPULATE to true.
  53.      */
  54.     public const OBJECT_TO_POPULATE = 'object_to_populate';
  56.     /**
  57.      * Only (de)normalize attributes that are in the specified groups.
  58.      */
  59.     public const GROUPS = 'groups';
  61.     /**
  62.      * Limit (de)normalize to the specified names.
  63.      *
  64.      * For nested structures, this list needs to reflect the object tree.
  65.      */
  66.     public const ATTRIBUTES = 'attributes';
  68.     /**
  69.      * If ATTRIBUTES are specified, and the source has fields that are not part of that list,
  70.      * either ignore those attributes (true) or throw an ExtraAttributesException (false).
  71.      */
  72.     public const ALLOW_EXTRA_ATTRIBUTES = 'allow_extra_attributes';
  74.     /**
  75.      * Hashmap of default values for constructor arguments.
  76.      *
  77.      * The names need to match the parameter names in the constructor arguments.
  78.      */
  79.     public const DEFAULT_CONSTRUCTOR_ARGUMENTS = 'default_constructor_arguments';
  81.     /**
  82.      * Hashmap of field name => callable to (de)normalize this field.
  83.      *
  84.      * The callable is called if the field is encountered with the arguments:
  85.      *
  86.      * - mixed         $attributeValue value of this field
  87.      * - object|string $object         the whole object being normalized or the object's class being denormalized
  88.      * - string        $attributeName  name of the attribute being (de)normalized
  89.      * - string        $format         the requested format
  90.      * - array         $context        the serialization context
  91.      */
  92.     public const CALLBACKS = 'callbacks';
  94.     /**
  95.      * Handler to call when a circular reference has been detected.
  96.      *
  97.      * If you specify no handler, a CircularReferenceException is thrown.
  98.      *
  99.      * The method will be called with ($object, $format, $context) and its
  100.      * return value is returned as the result of the normalize call.
  101.      */
  102.     public const CIRCULAR_REFERENCE_HANDLER = 'circular_reference_handler';
  104.     /**
  105.      * Skip the specified attributes when normalizing an object tree.
  106.      *
  107.      * This list is applied to each element of nested structures.
  108.      *
  109.      * Note: The behaviour for nested structures is different from ATTRIBUTES
  110.      * for historical reason. Aligning the behaviour would be a BC break.
  111.      */
  112.     public const IGNORED_ATTRIBUTES = 'ignored_attributes';
  114.     /**
  115.      * @internal
  116.      */
  117.     protected const CIRCULAR_REFERENCE_LIMIT_COUNTERS = 'circular_reference_limit_counters';
  119.     protected $defaultContext = [
  120.         self::ALLOW_EXTRA_ATTRIBUTES => true,
  121.         self::CIRCULAR_REFERENCE_LIMIT => 1,
  122.         self::IGNORED_ATTRIBUTES => [],
  123.     ];
  125.     /**
  126.      * @deprecated since Symfony 4.2
  127.      */
  128.     protected $circularReferenceLimit = 1;
  130.     /**
  131.      * @deprecated since Symfony 4.2
  132.      *
  133.      * @var callable|null
  134.      */
  135.     protected $circularReferenceHandler;
  137.     /**
  138.      * @var ClassMetadataFactoryInterface|null
  139.      */
  140.     protected $classMetadataFactory;
  142.     /**
  143.      * @var NameConverterInterface|null
  144.      */
  145.     protected $nameConverter;
  147.     /**
  148.      * @deprecated since Symfony 4.2
  149.      */
  150.     protected $callbacks = [];
  152.     /**
  153.      * @deprecated since Symfony 4.2
  154.      */
  155.     protected $ignoredAttributes = [];
  157.     /**
  158.      * @deprecated since Symfony 4.2
  159.      */
  160.     protected $camelizedAttributes = [];
  162.     /**
  163.      * Sets the {@link ClassMetadataFactoryInterface} to use.
  164.      */
  165.     public function __construct(ClassMetadataFactoryInterface $classMetadataFactory = null, NameConverterInterface $nameConverter = null, array $defaultContext = [])
  166.     {
  167.         $this->classMetadataFactory = $classMetadataFactory;
  168.         $this->nameConverter = $nameConverter;
  169.         $this->defaultContext = array_merge($this->defaultContext, $defaultContext);
  171.         $this->validateCallbackContext($this->defaultContext, 'default');
  173.         if (isset($this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER]) && !\is_callable($this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER])) {
  174.             throw new InvalidArgumentException(sprintf('Invalid callback found in the "%s" default context option.', self::CIRCULAR_REFERENCE_HANDLER));
  175.         }
  176.     }
  178.     /**
  179.      * Sets circular reference limit.
  180.      *
  181.      * @deprecated since Symfony 4.2
  182.      *
  183.      * @param int $circularReferenceLimit Limit of iterations for the same object
  184.      *
  185.      * @return self
  186.      */
  187.     public function setCircularReferenceLimit($circularReferenceLimit)
  188.     {
  189.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2, use the "circular_reference_limit" key of the context instead.', __METHOD__), \E_USER_DEPRECATED);
  191.         $this->defaultContext[self::CIRCULAR_REFERENCE_LIMIT] = $this->circularReferenceLimit = $circularReferenceLimit;
  193.         return $this;
  194.     }
  196.     /**
  197.      * Sets circular reference handler.
  198.      *
  199.      * @deprecated since Symfony 4.2
  200.      *
  201.      * @return self
  202.      */
  203.     public function setCircularReferenceHandler(callable $circularReferenceHandler)
  204.     {
  205.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2, use the "circular_reference_handler" key of the context instead.', __METHOD__), \E_USER_DEPRECATED);
  207.         $this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER] = $this->circularReferenceHandler = $circularReferenceHandler;
  209.         return $this;
  210.     }
  212.     /**
  213.      * Sets (de)normalization callbacks.
  214.      *
  215.      * @deprecated since Symfony 4.2
  216.      *
  217.      * @param callable[] $callbacks Help (de)normalize the result
  218.      *
  219.      * @return self
  220.      *
  221.      * @throws InvalidArgumentException if a non-callable callback is set
  222.      */
  223.     public function setCallbacks(array $callbacks)
  224.     {
  225.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2, use the "callbacks" key of the context instead.', __METHOD__), \E_USER_DEPRECATED);
  227.         foreach ($callbacks as $attribute => $callback) {
  228.             if (!\is_callable($callback)) {
  229.                 throw new InvalidArgumentException(sprintf('The given callback for attribute "%s" is not callable.', $attribute));
  230.             }
  231.         }
  232.         $this->defaultContext[self::CALLBACKS] = $this->callbacks = $callbacks;
  234.         return $this;
  235.     }
  237.     /**
  238.      * Sets ignored attributes for normalization and denormalization.
  239.      *
  240.      * @deprecated since Symfony 4.2
  241.      *
  242.      * @return self
  243.      */
  244.     public function setIgnoredAttributes(array $ignoredAttributes)
  245.     {
  246.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2, use the "ignored_attributes" key of the context instead.', __METHOD__), \E_USER_DEPRECATED);
  248.         $this->defaultContext[self::IGNORED_ATTRIBUTES] = $this->ignoredAttributes = $ignoredAttributes;
  250.         return $this;
  251.     }
  253.     /**
  254.      * {@inheritdoc}
  255.      */
  256.     public function hasCacheableSupportsMethod(): bool
  257.     {
  258.         return false;
  259.     }
  261.     /**
  262.      * Detects if the configured circular reference limit is reached.
  263.      *
  264.      * @param object $object
  265.      * @param array  $context
  266.      *
  267.      * @return bool
  268.      *
  269.      * @throws CircularReferenceException
  270.      */
  271.     protected function isCircularReference($object, &$context)
  272.     {
  273.         $objectHash = spl_object_hash($object);
  275.         $circularReferenceLimit = $context[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->defaultContext[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->circularReferenceLimit;
  276.         if (isset($context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash])) {
  277.             if ($context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash] >= $circularReferenceLimit) {
  278.                 unset($context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash]);
  280.                 return true;
  281.             }
  283.             ++$context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash];
  284.         } else {
  285.             $context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash] = 1;
  286.         }
  288.         return false;
  289.     }
  291.     /**
  292.      * Handles a circular reference.
  293.      *
  294.      * If a circular reference handler is set, it will be called. Otherwise, a
  295.      * {@class CircularReferenceException} will be thrown.
  296.      *
  297.      * @final since Symfony 4.2
  298.      *
  299.      * @param object      $object
  300.      * @param string|null $format
  301.      * @param array       $context
  302.      *
  303.      * @return mixed
  304.      *
  305.      * @throws CircularReferenceException
  306.      */
  307.     protected function handleCircularReference($object/*, string $format = null, array $context = []*/)
  308.     {
  309.         if (\func_num_args() < 2 && __CLASS__ !== static::class && __CLASS__ !== (new \ReflectionMethod($this, __FUNCTION__))->getDeclaringClass()->getName() && !$this instanceof \PHPUnit\Framework\MockObject\MockObject && !$this instanceof \Prophecy\Prophecy\ProphecySubjectInterface && !$this instanceof \Mockery\MockInterface) {
  310.             @trigger_error(sprintf('The "%s()" method will have two new "string $format = null" and "array $context = []" arguments in version 5.0, not defining it is deprecated since Symfony 4.2.', __METHOD__), \E_USER_DEPRECATED);
  311.         }
  312.         $format = \func_num_args() > 1 ? func_get_arg(1) : null;
  313.         $context = \func_num_args() > 2 ? func_get_arg(2) : [];
  315.         $circularReferenceHandler = $context[self::CIRCULAR_REFERENCE_HANDLER] ?? $this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER] ?? $this->circularReferenceHandler;
  316.         if ($circularReferenceHandler) {
  317.             return $circularReferenceHandler($object, $format, $context);
  318.         }
  320.         throw new CircularReferenceException(sprintf('A circular reference has been detected when serializing the object of class "%s" (configured limit: %d).', \get_class($object), $context[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->defaultContext[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->circularReferenceLimit));
  321.     }
  323.     /**
  324.      * Gets attributes to normalize using groups.
  325.      *
  326.      * @param string|object $classOrObject
  327.      * @param bool          $attributesAsString If false, return an array of {@link AttributeMetadataInterface}
  328.      *
  329.      * @throws LogicException if the 'allow_extra_attributes' context variable is false and no class metadata factory is provided
  330.      *
  331.      * @return string[]|AttributeMetadataInterface[]|bool
  332.      */
  333.     protected function getAllowedAttributes($classOrObject, array $context, $attributesAsString = false)
  334.     {
  335.         $allowExtraAttributes = $context[self::ALLOW_EXTRA_ATTRIBUTES] ?? $this->defaultContext[self::ALLOW_EXTRA_ATTRIBUTES];
  336.         if (!$this->classMetadataFactory) {
  337.             if (!$allowExtraAttributes) {
  338.                 throw new LogicException(sprintf('A class metadata factory must be provided in the constructor when setting "%s" to false.', self::ALLOW_EXTRA_ATTRIBUTES));
  339.             }
  341.             return false;
  342.         }
  344.         $tmpGroups = $context[self::GROUPS] ?? $this->defaultContext[self::GROUPS] ?? null;
  345.         $groups = (\is_array($tmpGroups) || is_scalar($tmpGroups)) ? (array) $tmpGroups : false;
  346.         if (false === $groups && $allowExtraAttributes) {
  347.             return false;
  348.         }
  350.         $allowedAttributes = [];
  351.         foreach ($this->classMetadataFactory->getMetadataFor($classOrObject)->getAttributesMetadata() as $attributeMetadata) {
  352.             $name = $attributeMetadata->getName();
  354.             if (
  355.                 (false === $groups || array_intersect($attributeMetadata->getGroups(), $groups)) &&
  356.                 $this->isAllowedAttribute($classOrObject, $name, null, $context)
  357.             ) {
  358.                 $allowedAttributes[] = $attributesAsString ? $name : $attributeMetadata;
  359.             }
  360.         }
  362.         return $allowedAttributes;
  363.     }
  365.     /**
  366.      * Is this attribute allowed?
  367.      *
  368.      * @param object|string $classOrObject
  369.      * @param string        $attribute
  370.      * @param string|null   $format
  371.      *
  372.      * @return bool
  373.      */
  374.     protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = [])
  375.     {
  376.         $ignoredAttributes = $context[self::IGNORED_ATTRIBUTES] ?? $this->defaultContext[self::IGNORED_ATTRIBUTES] ?? $this->ignoredAttributes;
  377.         if (\in_array($attribute, $ignoredAttributes)) {
  378.             return false;
  379.         }
  381.         $attributes = $context[self::ATTRIBUTES] ?? $this->defaultContext[self::ATTRIBUTES] ?? null;
  382.         if (isset($attributes[$attribute])) {
  383.             // Nested attributes
  384.             return true;
  385.         }
  387.         if (\is_array($attributes)) {
  388.             return \in_array($attribute, $attributes, true);
  389.         }
  391.         return true;
  392.     }
  394.     /**
  395.      * Normalizes the given data to an array. It's particularly useful during
  396.      * the denormalization process.
  397.      *
  398.      * @param object|array $data
  399.      *
  400.      * @return array
  401.      */
  402.     protected function prepareForDenormalization($data)
  403.     {
  404.         return (array) $data;
  405.     }
  407.     /**
  408.      * Returns the method to use to construct an object. This method must be either
  409.      * the object constructor or static.
  410.      *
  411.      * @param string     $class
  412.      * @param array|bool $allowedAttributes
  413.      *
  414.      * @return \ReflectionMethod|null
  415.      */
  416.     protected function getConstructor(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes)
  417.     {
  418.         return $reflectionClass->getConstructor();
  419.     }
  421.     /**
  422.      * Instantiates an object using constructor parameters when needed.
  423.      *
  424.      * This method also allows to denormalize data into an existing object if
  425.      * it is present in the context with the object_to_populate. This object
  426.      * is removed from the context before being returned to avoid side effects
  427.      * when recursively normalizing an object graph.
  428.      *
  429.      * @param string     $class
  430.      * @param array|bool $allowedAttributes
  431.      *
  432.      * @return object
  433.      *
  434.      * @throws RuntimeException
  435.      * @throws MissingConstructorArgumentsException
  436.      */
  437.     protected function instantiateObject(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes, string $format = null)
  438.     {
  439.         if (null !== $object = $this->extractObjectToPopulate($class, $context, self::OBJECT_TO_POPULATE)) {
  440.             unset($context[self::OBJECT_TO_POPULATE]);
  442.             return $object;
  443.         }
  444.         // clean up even if no match
  445.         unset($context[static::OBJECT_TO_POPULATE]);
  447.         $constructor = $this->getConstructor($data, $class, $context, $reflectionClass, $allowedAttributes);
  448.         if ($constructor) {
  449.             if (true !== $constructor->isPublic()) {
  450.                 return $reflectionClass->newInstanceWithoutConstructor();
  451.             }
  453.             $constructorParameters = $constructor->getParameters();
  455.             $params = [];
  456.             foreach ($constructorParameters as $constructorParameter) {
  457.                 $paramName = $constructorParameter->name;
  458.                 $key = $this->nameConverter ? $this->nameConverter->normalize($paramName, $class, $format, $context) : $paramName;
  460.                 $allowed = false === $allowedAttributes || \in_array($paramName, $allowedAttributes);
  461.                 $ignored = !$this->isAllowedAttribute($class, $paramName, $format, $context);
  462.                 if ($constructorParameter->isVariadic()) {
  463.                     if ($allowed && !$ignored && (isset($data[$key]) || \array_key_exists($key, $data))) {
  464.                         if (!\is_array($data[$paramName])) {
  465.                             throw new RuntimeException(sprintf('Cannot create an instance of "%s" from serialized data because the variadic parameter "%s" can only accept an array.', $class, $constructorParameter->name));
  466.                         }
  468.                         $variadicParameters = [];
  469.                         foreach ($data[$paramName] as $parameterData) {
  470.                             $variadicParameters[] = $this->denormalizeParameter($reflectionClass, $constructorParameter, $paramName, $parameterData, $context, $format);
  471.                         }
  473.                         $params = array_merge($params, $variadicParameters);
  474.                         unset($data[$key]);
  475.                     }
  476.                 } elseif ($allowed && !$ignored && (isset($data[$key]) || \array_key_exists($key, $data))) {
  477.                     $parameterData = $data[$key];
  478.                     if (null === $parameterData && $constructorParameter->allowsNull()) {
  479.                         $params[] = null;
  480.                         // Don't run set for a parameter passed to the constructor
  481.                         unset($data[$key]);
  482.                         continue;
  483.                     }
  485.                     // Don't run set for a parameter passed to the constructor
  486.                     $params[] = $this->denormalizeParameter($reflectionClass, $constructorParameter, $paramName, $parameterData, $context, $format);
  487.                     unset($data[$key]);
  488.                 } elseif (\array_key_exists($key, $context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class] ?? [])) {
  489.                     $params[] = $context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key];
  490.                 } elseif (\array_key_exists($key, $this->defaultContext[self::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class] ?? [])) {
  491.                     $params[] = $this->defaultContext[self::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key];
  492.                 } elseif ($constructorParameter->isDefaultValueAvailable()) {
  493.                     $params[] = $constructorParameter->getDefaultValue();
  494.                 } elseif ($constructorParameter->hasType() && $constructorParameter->getType()->allowsNull()) {
  495.                     $params[] = null;
  496.                 } else {
  497.                     throw new MissingConstructorArgumentsException(sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires parameter "%s" to be present.', $class, $constructorParameter->name));
  498.                 }
  499.             }
  501.             if ($constructor->isConstructor()) {
  502.                 return $reflectionClass->newInstanceArgs($params);
  503.             } else {
  504.                 return $constructor->invokeArgs(null, $params);
  505.             }
  506.         }
  508.         return new $class();
  509.     }
  511.     /**
  512.      * @internal
  513.      */
  514.     protected function denormalizeParameter(\ReflectionClass $class, \ReflectionParameter $parameter, $parameterName, $parameterData, array $context, $format = null)
  515.     {
  516.         try {
  517.             if (($parameterType = $parameter->getType()) instanceof \ReflectionNamedType && !$parameterType->isBuiltin()) {
  518.                 $parameterClass = $parameterType->getName();
  519.                 new \ReflectionClass($parameterClass); // throws a \ReflectionException if the class doesn't exist
  521.                 if (!$this->serializer instanceof DenormalizerInterface) {
  522.                     throw new LogicException(sprintf('Cannot create an instance of "%s" from serialized data because the serializer inject in "%s" is not a denormalizer.', $parameterClass, static::class));
  523.                 }
  525.                 $parameterData = $this->serializer->denormalize($parameterData, $parameterClass, $format, $this->createChildContext($context, $parameterName, $format));
  526.             }
  527.         } catch (\ReflectionException $e) {
  528.             throw new RuntimeException(sprintf('Could not determine the class of the parameter "%s".', $parameterName), 0, $e);
  529.         } catch (MissingConstructorArgumentsException $e) {
  530.             if (!$parameter->getType()->allowsNull()) {
  531.                 throw $e;
  532.             }
  534.             return null;
  535.         }
  537.         return $this->applyCallbacks($parameterData, $class->getName(), $parameterName, $format, $context);
  538.     }
  540.     /**
  541.      * @param string $attribute Attribute name
  542.      *
  543.      * @internal
  544.      */
  545.     protected function createChildContext(array $parentContext, $attribute/*, ?string $format */): array
  546.     {
  547.         if (\func_num_args() < 3) {
  548.             @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);
  549.         }
  550.         if (isset($parentContext[self::ATTRIBUTES][$attribute])) {
  551.             $parentContext[self::ATTRIBUTES] = $parentContext[self::ATTRIBUTES][$attribute];
  552.         } else {
  553.             unset($parentContext[self::ATTRIBUTES]);
  554.         }
  556.         return $parentContext;
  557.     }
  559.     /**
  560.      * Validate callbacks set in context.
  561.      *
  562.      * @param string $contextType Used to specify which context is invalid in exceptions
  563.      *
  564.      * @throws InvalidArgumentException
  565.      */
  566.     final protected function validateCallbackContext(array $context, string $contextType = ''): void
  567.     {
  568.         if (!isset($context[self::CALLBACKS])) {
  569.             return;
  570.         }
  572.         if (!\is_array($context[self::CALLBACKS])) {
  573.             throw new InvalidArgumentException(sprintf('The "%s"%s context option must be an array of callables.', self::CALLBACKS, '' !== $contextType ? " $contextType" : ''));
  574.         }
  576.         foreach ($context[self::CALLBACKS] as $attribute => $callback) {
  577.             if (!\is_callable($callback)) {
  578.                 throw new InvalidArgumentException(sprintf('Invalid callback found for attribute "%s" in the "%s"%s context option.', $attribute, self::CALLBACKS, '' !== $contextType ? " $contextType" : ''));
  579.             }
  580.         }
  581.     }
  583.     /**
  584.      * Apply callbacks set in context.
  585.      *
  586.      * @param mixed         $value
  587.      * @param object|string $object Can be either the object being normalizing or the object's class being denormalized
  588.      *
  589.      * @return mixed
  590.      */
  591.     final protected function applyCallbacks($value, $object, string $attribute, ?string $format, array $context)
  592.     {
  593.         /**
  594.          * @var callable|null
  595.          */
  596.         $callback = $context[self::CALLBACKS][$attribute] ?? $this->defaultContext[self::CALLBACKS][$attribute] ?? $this->callbacks[$attribute] ?? null;
  598.         return $callback ? $callback($value, $object, $attribute, $format, $context) : $value;
  599.     }
  600. }