vendor/api-platform/core/src/Serializer/AbstractItemNormalizer.php line 123

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the API Platform project.
  5.  *
  6.  * (c) Kévin Dunglas <dunglas@gmail.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. declare(strict_types=1);
  14. namespace ApiPlatform\Serializer;
  16. use ApiPlatform\Api\IriConverterInterface;
  17. use ApiPlatform\Api\UrlGeneratorInterface;
  18. use ApiPlatform\Core\Api\IriConverterInterface as LegacyIriConverterInterface;
  19. use ApiPlatform\Core\Bridge\Symfony\Messenger\DataTransformer as MessengerDataTransformer;
  20. use ApiPlatform\Core\DataProvider\ItemDataProviderInterface;
  21. use ApiPlatform\Core\DataTransformer\DataTransformerInitializerInterface;
  22. use ApiPlatform\Core\DataTransformer\DataTransformerInterface;
  23. use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface as LegacyPropertyMetadataFactoryInterface;
  24. use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
  25. use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
  26. use ApiPlatform\Exception\InvalidArgumentException;
  27. use ApiPlatform\Exception\InvalidValueException;
  28. use ApiPlatform\Exception\ItemNotFoundException;
  29. use ApiPlatform\Metadata\ApiProperty;
  30. use ApiPlatform\Metadata\CollectionOperationInterface;
  31. use ApiPlatform\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
  32. use ApiPlatform\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
  33. use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
  34. use ApiPlatform\Symfony\Security\ResourceAccessCheckerInterface;
  35. use ApiPlatform\Util\ClassInfoTrait;
  36. use ApiPlatform\Util\CloneTrait;
  37. use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
  38. use Symfony\Component\PropertyAccess\PropertyAccess;
  39. use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
  40. use Symfony\Component\PropertyInfo\Type;
  41. use Symfony\Component\Serializer\Encoder\CsvEncoder;
  42. use Symfony\Component\Serializer\Encoder\XmlEncoder;
  43. use Symfony\Component\Serializer\Exception\LogicException;
  44. use Symfony\Component\Serializer\Exception\MissingConstructorArgumentsException;
  45. use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
  46. use Symfony\Component\Serializer\Exception\RuntimeException;
  47. use Symfony\Component\Serializer\Exception\UnexpectedValueException;
  48. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
  49. use Symfony\Component\Serializer\NameConverter\AdvancedNameConverterInterface;
  50. use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
  51. use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
  52. use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
  53. use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
  55. /**
  56.  * Base item normalizer.
  57.  *
  58.  * @author Kévin Dunglas <dunglas@gmail.com>
  59.  */
  60. abstract class AbstractItemNormalizer extends AbstractObjectNormalizer
  61. {
  62.     use ClassInfoTrait;
  63.     use CloneTrait;
  64.     use ContextTrait;
  65.     use InputOutputMetadataTrait;
  67.     public const IS_TRANSFORMED_TO_SAME_CLASS = 'is_transformed_to_same_class';
  69.     /**
  70.      * @var PropertyNameCollectionFactoryInterface
  71.      */
  72.     protected $propertyNameCollectionFactory;
  73.     /**
  74.      * @var LegacyPropertyMetadataFactoryInterface|PropertyMetadataFactoryInterface
  75.      */
  76.     protected $propertyMetadataFactory;
  77.     protected $resourceMetadataFactory;
  78.     /**
  79.      * @var LegacyIriConverterInterface|IriConverterInterface
  80.      */
  81.     protected $iriConverter;
  82.     protected $resourceClassResolver;
  83.     protected $resourceAccessChecker;
  84.     protected $propertyAccessor;
  85.     protected $itemDataProvider;
  86.     protected $allowPlainIdentifiers;
  87.     protected $dataTransformers = [];
  88.     protected $localCache = [];
  90.     public function __construct(PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, $propertyMetadataFactory, $iriConverter, $resourceClassResolver, PropertyAccessorInterface $propertyAccessor = null, NameConverterInterface $nameConverter = null, ClassMetadataFactoryInterface $classMetadataFactory = null, ItemDataProviderInterface $itemDataProvider = null, bool $allowPlainIdentifiers = false, array $defaultContext = [], iterable $dataTransformers = [], $resourceMetadataFactory = null, ResourceAccessCheckerInterface $resourceAccessChecker = null)
  91.     {
  92.         if (!isset($defaultContext['circular_reference_handler'])) {
  93.             $defaultContext['circular_reference_handler'] = function ($object) {
  94.                 return $this->iriConverter instanceof LegacyIriConverterInterface ? $this->iriConverter->getIriFromItem($object) : $this->iriConverter->getIriFromResource($object);
  95.             };
  96.         }
  97.         if (!interface_exists(AdvancedNameConverterInterface::class) && method_exists($this, 'setCircularReferenceHandler')) {
  98.             $this->setCircularReferenceHandler($defaultContext['circular_reference_handler']);
  99.         }
  101.         parent::__construct($classMetadataFactory, $nameConverter, null, null, \Closure::fromCallable([$this, 'getObjectClass']), $defaultContext);
  103.         $this->propertyNameCollectionFactory = $propertyNameCollectionFactory;
  104.         $this->propertyMetadataFactory = $propertyMetadataFactory;
  106.         if ($iriConverter instanceof LegacyIriConverterInterface) {
  107.             trigger_deprecation('api-platform/core', '2.7', sprintf('Use an implementation of "%s" instead of "%s".', IriConverterInterface::class, LegacyIriConverterInterface::class));
  108.         }
  110.         $this->iriConverter = $iriConverter;
  111.         $this->resourceClassResolver = $resourceClassResolver;
  112.         $this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();
  113.         $this->itemDataProvider = $itemDataProvider;
  115.         if (true === $allowPlainIdentifiers) {
  116.             @trigger_error(sprintf('Allowing plain identifiers as argument of "%s" is deprecated since API Platform 2.7 and will not be possible anymore in API Platform 3.', self::class), \E_USER_DEPRECATED);
  117.         }
  118.         $this->allowPlainIdentifiers = $allowPlainIdentifiers;
  120.         $this->dataTransformers = $dataTransformers;
  122.         // Just skip our data transformer to trigger a proper deprecation
  123.         $customDataTransformers = array_filter(\is_array($dataTransformers) ? $dataTransformers : iterator_to_array($dataTransformers), function ($dataTransformer) {
  124.             return !$dataTransformer instanceof MessengerDataTransformer;
  125.         });
  127.         if (\count($customDataTransformers)) {
  128.             trigger_deprecation('api-platform/core', '2.7', 'The DataTransformer pattern is deprecated, use a Provider or a Processor and either use your input or return a new output there.');
  129.         }
  131.         if ($resourceMetadataFactory && !$resourceMetadataFactory instanceof ResourceMetadataCollectionFactoryInterface) {
  132.             trigger_deprecation('api-platform/core', '2.7', sprintf('Use "%s" instead of "%s".', ResourceMetadataCollectionFactoryInterface::class, ResourceMetadataFactoryInterface::class));
  133.         }
  135.         $this->resourceMetadataFactory = $resourceMetadataFactory;
  136.         $this->resourceAccessChecker = $resourceAccessChecker;
  137.     }
  139.     /**
  140.      * {@inheritdoc}
  141.      */
  142.     public function supportsNormalization($data, $format = null, array $context = []): bool
  143.     {
  144.         if (!\is_object($data) || is_iterable($data)) {
  145.             return false;
  146.         }
  148.         $class = $this->getObjectClass($data);
  149.         if (($context['output']['class'] ?? null) === $class) {
  150.             return true;
  151.         }
  153.         return $this->resourceClassResolver->isResourceClass($class);
  154.     }
  156.     /**
  157.      * {@inheritdoc}
  158.      */
  159.     public function hasCacheableSupportsMethod(): bool
  160.     {
  161.         return true;
  162.     }
  164.     /**
  165.      * {@inheritdoc}
  166.      *
  167.      * @throws LogicException
  168.      *
  169.      * @return array|string|int|float|bool|\ArrayObject|null
  170.      */
  171.     public function normalize($object, $format = null, array $context = [])
  172.     {
  173.         $resourceClass = $this->getObjectClass($object);
  174.         if (!($isTransformed = isset($context[self::IS_TRANSFORMED_TO_SAME_CLASS])) && $outputClass = $this->getOutputClass($resourceClass, $context)) {
  175.             if (!$this->serializer instanceof NormalizerInterface) {
  176.                 throw new LogicException('Cannot normalize the output because the injected serializer is not a normalizer');
  177.             }
  179.             // Data transformers are deprecated, this is removed from 3.0
  180.             if ($dataTransformer = $this->getDataTransformer($object, $outputClass, $context)) {
  181.                 $transformed = $dataTransformer->transform($object, $outputClass, $context);
  183.                 if ($object === $transformed) {
  184.                     $context[self::IS_TRANSFORMED_TO_SAME_CLASS] = true;
  185.                 } else {
  186.                     $context['api_normalize'] = true;
  187.                     $context['api_resource'] = $object;
  188.                     unset($context['output'], $context['resource_class']);
  189.                 }
  191.                 return $this->serializer->normalize($transformed, $format, $context);
  192.             }
  194.             unset($context['output'], $context['operation_name']);
  195.             if ($this->resourceMetadataFactory instanceof ResourceMetadataCollectionFactoryInterface && !isset($context['operation'])) {
  196.                 $context['operation'] = $this->resourceMetadataFactory->create($context['resource_class'])->getOperation();
  197.             }
  198.             $context['resource_class'] = $outputClass;
  199.             $context['api_sub_level'] = true;
  200.             $context[self::ALLOW_EXTRA_ATTRIBUTES] = false;
  202.             return $this->serializer->normalize($object, $format, $context);
  203.         }
  205.         if ($isTransformed) {
  206.             unset($context[self::IS_TRANSFORMED_TO_SAME_CLASS]);
  207.         }
  209.         if ($isResourceClass = $this->resourceClassResolver->isResourceClass($resourceClass)) {
  210.             $context = $this->initContext($resourceClass, $context);
  211.         }
  213.         if (isset($context['operation']) && $context['operation'] instanceof CollectionOperationInterface) {
  214.             unset($context['operation_name']);
  215.             unset($context['operation']);
  216.             unset($context['iri']);
  217.         }
  219.         $iri = null;
  220.         if (isset($context['iri'])) {
  221.             $iri = $context['iri'];
  222.         } elseif ($this->iriConverter instanceof LegacyIriConverterInterface && $isResourceClass) {
  223.             $iri = $this->iriConverter->getIriFromItem($object);
  224.         } elseif ($this->iriConverter instanceof IriConverterInterface) {
  225.             $iri = $this->iriConverter->getIriFromResource($object, UrlGeneratorInterface::ABS_URL, $context['operation'] ?? null, $context);
  226.         }
  228.         $context['iri'] = $iri;
  229.         $context['api_normalize'] = true;
  231.         /*
  232.          * When true, converts the normalized data array of a resource into an
  233.          * IRI, if the normalized data array is empty.
  234.          *
  235.          * This is useful when traversing from a non-resource towards an attribute
  236.          * which is a resource, as we do not have the benefit of {@see PropertyMetadata::isReadableLink}.
  237.          *
  238.          * It must not be propagated to subresources, as {@see PropertyMetadata::isReadableLink}
  239.          * should take effect.
  240.          */
  241.         $emptyResourceAsIri = $context['api_empty_resource_as_iri'] ?? false;
  242.         unset($context['api_empty_resource_as_iri']);
  244.         if (isset($context['resources'])) {
  245.             $context['resources'][$iri] = $iri;
  246.         }
  248.         $data = parent::normalize($object, $format, $context);
  249.         if ($emptyResourceAsIri && \is_array($data) && 0 === \count($data)) {
  250.             return $iri;
  251.         }
  253.         return $data;
  254.     }
  256.     /**
  257.      * {@inheritdoc}
  258.      *
  259.      * @return bool
  260.      */
  261.     public function supportsDenormalization($data, $type, $format = null, array $context = [])
  262.     {
  263.         if (($context['input']['class'] ?? null) === $type) {
  264.             return true;
  265.         }
  267.         return $this->localCache[$type] ?? $this->localCache[$type] = $this->resourceClassResolver->isResourceClass($type);
  268.     }
  270.     /**
  271.      * {@inheritdoc}
  272.      *
  273.      * @return mixed
  274.      */
  275.     public function denormalize($data, $class, $format = null, array $context = [])
  276.     {
  277.         $resourceClass = $class;
  279.         if (null !== $inputClass = $this->getInputClass($resourceClass, $context)) {
  280.             if (null !== $dataTransformer = $this->getDataTransformer($data, $resourceClass, $context)) {
  281.                 $dataTransformerContext = $context;
  283.                 unset($context['input']);
  284.                 unset($context['resource_class']);
  286.                 if (!$this->serializer instanceof DenormalizerInterface) {
  287.                     throw new LogicException('Cannot denormalize the input because the injected serializer is not a denormalizer');
  288.                 }
  290.                 if ($dataTransformer instanceof DataTransformerInitializerInterface) {
  291.                     $context[AbstractObjectNormalizer::OBJECT_TO_POPULATE] = $dataTransformer->initialize($inputClass, $context);
  292.                     $context[AbstractObjectNormalizer::DEEP_OBJECT_TO_POPULATE] = true;
  293.                 }
  295.                 try {
  296.                     $denormalizedInput = $this->serializer->denormalize($data, $inputClass, $format, $context);
  297.                 } catch (NotNormalizableValueException $e) {
  298.                     throw new UnexpectedValueException('The input data is misformatted.', $e->getCode(), $e);
  299.                 }
  301.                 if (!\is_object($denormalizedInput)) {
  302.                     throw new UnexpectedValueException('Expected denormalized input to be an object.');
  303.                 }
  305.                 return $dataTransformer->transform($denormalizedInput, $resourceClass, $dataTransformerContext);
  306.             }
  308.             unset($context['input']);
  309.             unset($context['operation']);
  310.             unset($context['operation_name']);
  311.             $context['resource_class'] = $inputClass;
  313.             if (!$this->serializer instanceof DenormalizerInterface) {
  314.                 throw new LogicException('Cannot denormalize the input because the injected serializer is not a denormalizer');
  315.             }
  317.             try {
  318.                 return $this->serializer->denormalize($data, $inputClass, $format, $context);
  319.             } catch (NotNormalizableValueException $e) {
  320.                 throw new UnexpectedValueException('The input data is misformatted.', $e->getCode(), $e);
  321.             }
  322.         }
  324.         if (null === $objectToPopulate = $this->extractObjectToPopulate($class, $context, static::OBJECT_TO_POPULATE)) {
  325.             $normalizedData = \is_scalar($data) ? [$data] : $this->prepareForDenormalization($data);
  326.             $class = $this->getClassDiscriminatorResolvedClass($normalizedData, $class);
  327.         }
  329.         $context['api_denormalize'] = true;
  331.         if ($this->resourceClassResolver->isResourceClass($class)) {
  332.             $resourceClass = $this->resourceClassResolver->getResourceClass($objectToPopulate, $class);
  333.             $context['resource_class'] = $resourceClass;
  334.         }
  336.         $supportsPlainIdentifiers = $this->supportsPlainIdentifiers();
  338.         if (\is_string($data)) {
  339.             try {
  340.                 return $this->iriConverter instanceof LegacyIriConverterInterface ? $this->iriConverter->getItemFromIri($data, $context + ['fetch_data' => true]) : $this->iriConverter->getResourceFromIri($data, $context + ['fetch_data' => true]);
  341.             } catch (ItemNotFoundException $e) {
  342.                 if (!$supportsPlainIdentifiers) {
  343.                     throw new UnexpectedValueException($e->getMessage(), $e->getCode(), $e);
  344.                 }
  345.             } catch (InvalidArgumentException $e) {
  346.                 if (!$supportsPlainIdentifiers) {
  347.                     throw new UnexpectedValueException(sprintf('Invalid IRI "%s".', $data), $e->getCode(), $e);
  348.                 }
  349.             }
  350.         }
  352.         if (!\is_array($data)) {
  353.             if (!$supportsPlainIdentifiers) {
  354.                 throw new UnexpectedValueException(sprintf('Expected IRI or document for resource "%s", "%s" given.', $resourceClass, \gettype($data)));
  355.             }
  357.             $item = $this->itemDataProvider->getItem($resourceClass, $data, null, $context + ['fetch_data' => true]);
  358.             if (null === $item) {
  359.                 throw new ItemNotFoundException(sprintf('Item not found for resource "%s" with id "%s".', $resourceClass, $data));
  360.             }
  362.             return $item;
  363.         }
  365.         $previousObject = $this->clone($objectToPopulate);
  366.         $object = parent::denormalize($data, $resourceClass, $format, $context);
  368.         if (!$this->resourceClassResolver->isResourceClass($context['resource_class'])) {
  369.             return $object;
  370.         }
  372.         // Bypass the post-denormalize attribute revert logic if the object could not be
  373.         // cloned since we cannot possibly revert any changes made to it.
  374.         if (null !== $objectToPopulate && null === $previousObject) {
  375.             return $object;
  376.         }
  378.         $options = $this->getFactoryOptions($context);
  379.         $propertyNames = iterator_to_array($this->propertyNameCollectionFactory->create($resourceClass, $options));
  381.         // Revert attributes that aren't allowed to be changed after a post-denormalize check
  382.         foreach (array_keys($data) as $attribute) {
  383.             $attribute = $this->nameConverter ? $this->nameConverter->denormalize((string) $attribute) : $attribute;
  384.             if (!\in_array($attribute, $propertyNames, true)) {
  385.                 continue;
  386.             }
  388.             if (!$this->canAccessAttributePostDenormalize($object, $previousObject, $attribute, $context)) {
  389.                 if (null !== $previousObject) {
  390.                     $this->setValue($object, $attribute, $this->propertyAccessor->getValue($previousObject, $attribute));
  391.                 } else {
  392.                     $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $attribute, $options);
  393.                     $this->setValue($object, $attribute, $propertyMetadata->getDefault());
  394.                 }
  395.             }
  396.         }
  398.         return $object;
  399.     }
  401.     /**
  402.      * Method copy-pasted from symfony/serializer.
  403.      * Remove it after symfony/serializer version update @see https://github.com/symfony/symfony/pull/28263.
  404.      *
  405.      * {@inheritdoc}
  406.      *
  407.      * @internal
  408.      *
  409.      * @return object
  410.      */
  411.     protected function instantiateObject(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes, string $format = null)
  412.     {
  413.         if (null !== $object = $this->extractObjectToPopulate($class, $context, static::OBJECT_TO_POPULATE)) {
  414.             unset($context[static::OBJECT_TO_POPULATE]);
  416.             return $object;
  417.         }
  419.         $class = $this->getClassDiscriminatorResolvedClass($data, $class);
  420.         $reflectionClass = new \ReflectionClass($class);
  422.         $constructor = $this->getConstructor($data, $class, $context, $reflectionClass, $allowedAttributes);
  423.         if ($constructor) {
  424.             $constructorParameters = $constructor->getParameters();
  426.             $params = [];
  427.             foreach ($constructorParameters as $constructorParameter) {
  428.                 $paramName = $constructorParameter->name;
  429.                 $key = $this->nameConverter ? $this->nameConverter->normalize($paramName, $class, $format, $context) : $paramName;
  431.                 $allowed = false === $allowedAttributes || (\is_array($allowedAttributes) && \in_array($paramName, $allowedAttributes, true));
  432.                 $ignored = !$this->isAllowedAttribute($class, $paramName, $format, $context);
  433.                 if ($constructorParameter->isVariadic()) {
  434.                     if ($allowed && !$ignored && (isset($data[$key]) || \array_key_exists($key, $data))) {
  435.                         if (!\is_array($data[$paramName])) {
  436.                             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));
  437.                         }
  439.                         $params = array_merge($params, $data[$paramName]);
  440.                     }
  441.                 } elseif ($allowed && !$ignored && (isset($data[$key]) || \array_key_exists($key, $data))) {
  442.                     $params[] = $this->createConstructorArgument($data[$key], $key, $constructorParameter, $context, $format);
  444.                     // Don't run set for a parameter passed to the constructor
  445.                     unset($data[$key]);
  446.                 } elseif (isset($context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key])) {
  447.                     $params[] = $context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key];
  448.                 } elseif ($constructorParameter->isDefaultValueAvailable()) {
  449.                     $params[] = $constructorParameter->getDefaultValue();
  450.                 } else {
  451.                     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));
  452.                 }
  453.             }
  455.             if ($constructor->isConstructor()) {
  456.                 return $reflectionClass->newInstanceArgs($params);
  457.             }
  459.             return $constructor->invokeArgs(null, $params);
  460.         }
  462.         return new $class();
  463.     }
  465.     protected function getClassDiscriminatorResolvedClass(array &$data, string $class): string
  466.     {
  467.         if (null === $this->classDiscriminatorResolver || (null === $mapping = $this->classDiscriminatorResolver->getMappingForClass($class))) {
  468.             return $class;
  469.         }
  471.         if (!isset($data[$mapping->getTypeProperty()])) {
  472.             throw new RuntimeException(sprintf('Type property "%s" not found for the abstract object "%s"', $mapping->getTypeProperty(), $class));
  473.         }
  475.         $type = $data[$mapping->getTypeProperty()];
  476.         if (null === ($mappedClass = $mapping->getClassForType($type))) {
  477.             throw new RuntimeException(sprintf('The type "%s" has no mapped class for the abstract object "%s"', $type, $class));
  478.         }
  480.         return $mappedClass;
  481.     }
  483.     /**
  484.      * {@inheritdoc}
  485.      */
  486.     protected function createConstructorArgument($parameterData, string $key, \ReflectionParameter $constructorParameter, array &$context, string $format = null)
  487.     {
  488.         return $this->createAttributeValue($constructorParameter->name, $parameterData, $format, $context);
  489.     }
  491.     /**
  492.      * {@inheritdoc}
  493.      *
  494.      * Unused in this context.
  495.      *
  496.      * @return string[]
  497.      */
  498.     protected function extractAttributes($object, $format = null, array $context = [])
  499.     {
  500.         return [];
  501.     }
  503.     /**
  504.      * {@inheritdoc}
  505.      *
  506.      * @return array|bool
  507.      */
  508.     protected function getAllowedAttributes($classOrObject, array $context, $attributesAsString = false)
  509.     {
  510.         if (!$this->resourceClassResolver->isResourceClass($context['resource_class'])) {
  511.             return parent::getAllowedAttributes($classOrObject, $context, $attributesAsString);
  512.         }
  514.         $resourceClass = $this->resourceClassResolver->getResourceClass(null, $context['resource_class']); // fix for abstract classes and interfaces
  515.         $options = $this->getFactoryOptions($context);
  516.         $propertyNames = $this->propertyNameCollectionFactory->create($resourceClass, $options);
  518.         $allowedAttributes = [];
  519.         foreach ($propertyNames as $propertyName) {
  520.             $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $propertyName, $options);
  522.             if (
  523.                 $this->isAllowedAttribute($classOrObject, $propertyName, null, $context) &&
  524.                 (
  525.                     isset($context['api_normalize']) && $propertyMetadata->isReadable() ||
  526.                     isset($context['api_denormalize']) && ($propertyMetadata->isWritable() || !\is_object($classOrObject) && $propertyMetadata->isInitializable())
  527.                 )
  528.             ) {
  529.                 $allowedAttributes[] = $propertyName;
  530.             }
  531.         }
  533.         return $allowedAttributes;
  534.     }
  536.     /**
  537.      * {@inheritdoc}
  538.      *
  539.      * @return bool
  540.      */
  541.     protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = [])
  542.     {
  543.         if (!parent::isAllowedAttribute($classOrObject, $attribute, $format, $context)) {
  544.             return false;
  545.         }
  547.         return $this->canAccessAttribute(\is_object($classOrObject) ? $classOrObject : null, $attribute, $context);
  548.     }
  550.     /**
  551.      * Check if access to the attribute is granted.
  552.      *
  553.      * @param object $object
  554.      */
  555.     protected function canAccessAttribute($object, string $attribute, array $context = []): bool
  556.     {
  557.         if (!$this->resourceClassResolver->isResourceClass($context['resource_class'])) {
  558.             return true;
  559.         }
  561.         $options = $this->getFactoryOptions($context);
  562.         /** @var PropertyMetadata|ApiProperty */
  563.         $propertyMetadata = $this->propertyMetadataFactory->create($context['resource_class'], $attribute, $options);
  564.         $security = $propertyMetadata instanceof PropertyMetadata ? $propertyMetadata->getAttribute('security') : $propertyMetadata->getSecurity();
  565.         if ($this->resourceAccessChecker && $security) {
  566.             return $this->resourceAccessChecker->isGranted($context['resource_class'], $security, [
  567.                 'object' => $object,
  568.             ]);
  569.         }
  571.         return true;
  572.     }
  574.     /**
  575.      * Check if access to the attribute is granted.
  576.      *
  577.      * @param object      $object
  578.      * @param object|null $previousObject
  579.      */
  580.     protected function canAccessAttributePostDenormalize($object, $previousObject, string $attribute, array $context = []): bool
  581.     {
  582.         $options = $this->getFactoryOptions($context);
  583.         /** @var PropertyMetadata|ApiProperty */
  584.         $propertyMetadata = $this->propertyMetadataFactory->create($context['resource_class'], $attribute, $options);
  585.         $security = $propertyMetadata instanceof PropertyMetadata ? $propertyMetadata->getAttribute('security_post_denormalize') : $propertyMetadata->getSecurityPostDenormalize();
  586.         if ($this->resourceAccessChecker && $security) {
  587.             return $this->resourceAccessChecker->isGranted($context['resource_class'], $security, [
  588.                 'object' => $object,
  589.                 'previous_object' => $previousObject,
  590.             ]);
  591.         }
  593.         return true;
  594.     }
  596.     /**
  597.      * {@inheritdoc}
  598.      */
  599.     protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = [])
  600.     {
  601.         $this->setValue($object, $attribute, $this->createAttributeValue($attribute, $value, $format, $context));
  602.     }
  604.     /**
  605.      * Validates the type of the value. Allows using integers as floats for JSON formats.
  606.      *
  607.      * @param mixed $value
  608.      *
  609.      * @throws InvalidArgumentException
  610.      */
  611.     protected function validateType(string $attribute, Type $type, $value, string $format = null)
  612.     {
  613.         $builtinType = $type->getBuiltinType();
  614.         if (Type::BUILTIN_TYPE_FLOAT === $builtinType && null !== $format && false !== strpos($format, 'json')) {
  615.             $isValid = \is_float($value) || \is_int($value);
  616.         } else {
  617.             $isValid = \call_user_func('is_'.$builtinType, $value);
  618.         }
  620.         if (!$isValid) {
  621.             throw new UnexpectedValueException(sprintf('The type of the "%s" attribute must be "%s", "%s" given.', $attribute, $builtinType, \gettype($value)));
  622.         }
  623.     }
  625.     /**
  626.      * Denormalizes a collection of objects.
  627.      *
  628.      * @param ApiProperty|PropertyMetadata $propertyMetadata
  629.      * @param mixed                        $value
  630.      *
  631.      * @throws InvalidArgumentException
  632.      */
  633.     protected function denormalizeCollection(string $attribute, $propertyMetadata, Type $type, string $className, $value, ?string $format, array $context): array
  634.     {
  635.         if (!\is_array($value)) {
  636.             throw new InvalidArgumentException(sprintf('The type of the "%s" attribute must be "array", "%s" given.', $attribute, \gettype($value)));
  637.         }
  639.         $collectionKeyType = method_exists(Type::class, 'getCollectionKeyTypes') ? ($type->getCollectionKeyTypes()[0] ?? null) : $type->getCollectionKeyType();
  640.         $collectionKeyBuiltinType = null === $collectionKeyType ? null : $collectionKeyType->getBuiltinType();
  642.         $values = [];
  643.         foreach ($value as $index => $obj) {
  644.             if (null !== $collectionKeyBuiltinType && !\call_user_func('is_'.$collectionKeyBuiltinType, $index)) {
  645.                 throw new InvalidArgumentException(sprintf('The type of the key "%s" must be "%s", "%s" given.', $index, $collectionKeyBuiltinType, \gettype($index)));
  646.             }
  648.             $values[$index] = $this->denormalizeRelation($attribute, $propertyMetadata, $className, $obj, $format, $this->createChildContext($context, $attribute, $format));
  649.         }
  651.         return $values;
  652.     }
  654.     /**
  655.      * Denormalizes a relation.
  656.      *
  657.      * @param ApiProperty|PropertyMetadata $propertyMetadata
  658.      * @param mixed                        $value
  659.      *
  660.      * @throws LogicException
  661.      * @throws UnexpectedValueException
  662.      * @throws ItemNotFoundException
  663.      *
  664.      * @return object|null
  665.      */
  666.     protected function denormalizeRelation(string $attributeName, $propertyMetadata, string $className, $value, ?string $format, array $context)
  667.     {
  668.         $supportsPlainIdentifiers = $this->supportsPlainIdentifiers();
  670.         if (\is_string($value)) {
  671.             try {
  672.                 return $this->iriConverter instanceof LegacyIriConverterInterface ? $this->iriConverter->getItemFromIri($value, $context + ['fetch_data' => true]) : $this->iriConverter->getResourceFromIri($value, $context + ['fetch_data' => true]);
  673.             } catch (ItemNotFoundException $e) {
  674.                 if (!$supportsPlainIdentifiers) {
  675.                     throw new UnexpectedValueException($e->getMessage(), $e->getCode(), $e);
  676.                 }
  677.             } catch (InvalidArgumentException $e) {
  678.                 if (!$supportsPlainIdentifiers) {
  679.                     throw new UnexpectedValueException(sprintf('Invalid IRI "%s".', $value), $e->getCode(), $e);
  680.                 }
  681.             }
  682.         }
  684.         if ($propertyMetadata->isWritableLink()) {
  685.             $context['api_allow_update'] = true;
  687.             if (!$this->serializer instanceof DenormalizerInterface) {
  688.                 throw new LogicException(sprintf('The injected serializer must be an instance of "%s".', DenormalizerInterface::class));
  689.             }
  691.             try {
  692.                 $item = $this->serializer->denormalize($value, $className, $format, $context);
  693.                 if (!\is_object($item) && null !== $item) {
  694.                     throw new \UnexpectedValueException('Expected item to be an object or null.');
  695.                 }
  697.                 return $item;
  698.             } catch (InvalidValueException $e) {
  699.                 if (!$supportsPlainIdentifiers) {
  700.                     throw $e;
  701.                 }
  702.             }
  703.         }
  705.         if (!\is_array($value)) {
  706.             if (!$supportsPlainIdentifiers) {
  707.                 throw new UnexpectedValueException(sprintf('Expected IRI or nested document for attribute "%s", "%s" given.', $attributeName, \gettype($value)));
  708.             }
  710.             $item = $this->itemDataProvider->getItem($className, $value, null, $context + ['fetch_data' => true]);
  711.             if (null === $item) {
  712.                 throw new ItemNotFoundException(sprintf('Item not found for resource "%s" with id "%s".', $className, $value));
  713.             }
  715.             return $item;
  716.         }
  718.         throw new UnexpectedValueException(sprintf('Nested documents for attribute "%s" are not allowed. Use IRIs instead.', $attributeName));
  719.     }
  721.     /**
  722.      * Gets the options for the property name collection / property metadata factories.
  723.      */
  724.     protected function getFactoryOptions(array $context): array
  725.     {
  726.         $options = [];
  728.         if (isset($context[self::GROUPS])) {
  729.             /* @see https://github.com/symfony/symfony/blob/v4.2.6/src/Symfony/Component/PropertyInfo/Extractor/SerializerExtractor.php */
  730.             $options['serializer_groups'] = (array) $context[self::GROUPS];
  731.         }
  733.         if (isset($context['resource_class']) && $this->resourceClassResolver->isResourceClass($context['resource_class']) && $this->resourceMetadataFactory instanceof ResourceMetadataCollectionFactoryInterface) {
  734.             $resourceClass = $this->resourceClassResolver->getResourceClass(null, $context['resource_class']); // fix for abstract classes and interfaces
  735.             // This is a hot spot, we should avoid calling this here but in many cases we can't
  736.             $operation = $context['root_operation'] ?? $context['operation'] ?? $this->resourceMetadataFactory->create($resourceClass)->getOperation($context['root_operation_name'] ?? $context['operation_name'] ?? null);
  737.             $options['normalization_groups'] = $operation->getNormalizationContext()['groups'] ?? null;
  738.             $options['denormalization_groups'] = $operation->getDenormalizationContext()['groups'] ?? null;
  739.         }
  741.         if (isset($context['operation_name'])) {
  742.             $options['operation_name'] = $context['operation_name'];
  743.         }
  745.         if (isset($context['collection_operation_name'])) {
  746.             $options['collection_operation_name'] = $context['collection_operation_name'];
  747.         }
  749.         if (isset($context['item_operation_name'])) {
  750.             $options['item_operation_name'] = $context['item_operation_name'];
  751.         }
  753.         return $options;
  754.     }
  756.     /**
  757.      * Creates the context to use when serializing a relation.
  758.      *
  759.      * @deprecated since version 2.1, to be removed in 3.0.
  760.      */
  761.     protected function createRelationSerializationContext(string $resourceClass, array $context): array
  762.     {
  763.         @trigger_error(sprintf('The method %s() is deprecated since 2.1 and will be removed in 3.0.', __METHOD__), \E_USER_DEPRECATED);
  765.         return $context;
  766.     }
  768.     /**
  769.      * {@inheritdoc}
  770.      *
  771.      * @throws UnexpectedValueException
  772.      * @throws LogicException
  773.      *
  774.      * @return mixed
  775.      */
  776.     protected function getAttributeValue($object, $attribute, $format = null, array $context = [])
  777.     {
  778.         $context['api_attribute'] = $attribute;
  779.         /** @var ApiProperty|PropertyMetadata */
  780.         $propertyMetadata = $this->propertyMetadataFactory->create($context['resource_class'], $attribute, $this->getFactoryOptions($context));
  782.         try {
  783.             $attributeValue = $this->propertyAccessor->getValue($object, $attribute);
  784.         } catch (NoSuchPropertyException $e) {
  785.             // BC to be removed in 3.0
  786.             if ($propertyMetadata instanceof PropertyMetadata && !$propertyMetadata->hasChildInherited()) {
  787.                 throw $e;
  788.             }
  789.             if ($propertyMetadata instanceof ApiProperty) {
  790.                 throw $e;
  791.             }
  793.             $attributeValue = null;
  794.         }
  796.         if ($context['api_denormalize'] ?? false) {
  797.             return $attributeValue;
  798.         }
  800.         $type = $propertyMetadata instanceof PropertyMetadata ? $propertyMetadata->getType() : ($propertyMetadata->getBuiltinTypes()[0] ?? null);
  802.         if (
  803.             $type &&
  804.             $type->isCollection() &&
  805.             ($collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType()) &&
  806.             ($className = $collectionValueType->getClassName()) &&
  807.             $this->resourceClassResolver->isResourceClass($className)
  808.         ) {
  809.             if (!is_iterable($attributeValue)) {
  810.                 throw new UnexpectedValueException('Unexpected non-iterable value for to-many relation.');
  811.             }
  813.             $resourceClass = $this->resourceClassResolver->getResourceClass($attributeValue, $className);
  814.             $childContext = $this->createChildContext($context, $attribute, $format);
  815.             $childContext['resource_class'] = $resourceClass;
  816.             if ($this->resourceMetadataFactory instanceof ResourceMetadataCollectionFactoryInterface) {
  817.                 $childContext['operation'] = $this->resourceMetadataFactory->create($resourceClass)->getOperation();
  818.             }
  819.             unset($childContext['iri'], $childContext['uri_variables']);
  821.             return $this->normalizeCollectionOfRelations($propertyMetadata, $attributeValue, $resourceClass, $format, $childContext);
  822.         }
  824.         if (
  825.             $type &&
  826.             ($className = $type->getClassName()) &&
  827.             $this->resourceClassResolver->isResourceClass($className)
  828.         ) {
  829.             if (!\is_object($attributeValue) && null !== $attributeValue) {
  830.                 throw new UnexpectedValueException('Unexpected non-object value for to-one relation.');
  831.             }
  833.             $resourceClass = $this->resourceClassResolver->getResourceClass($attributeValue, $className);
  834.             $childContext = $this->createChildContext($context, $attribute, $format);
  835.             $childContext['resource_class'] = $resourceClass;
  836.             if ($this->resourceMetadataFactory instanceof ResourceMetadataCollectionFactoryInterface) {
  837.                 $childContext['operation'] = $this->resourceMetadataFactory->create($resourceClass)->getOperation();
  838.             }
  839.             unset($childContext['iri'], $childContext['uri_variables']);
  841.             return $this->normalizeRelation($propertyMetadata, $attributeValue, $resourceClass, $format, $childContext);
  842.         }
  844.         if (!$this->serializer instanceof NormalizerInterface) {
  845.             throw new LogicException(sprintf('The injected serializer must be an instance of "%s".', NormalizerInterface::class));
  846.         }
  848.         unset($context['resource_class']);
  850.         if ($type && $type->getClassName()) {
  851.             $childContext = $this->createChildContext($context, $attribute, $format);
  852.             unset($childContext['iri'], $childContext['uri_variables']);
  854.             if ($propertyMetadata instanceof PropertyMetadata) {
  855.                 $childContext['output']['iri'] = $propertyMetadata->getIri() ?? false;
  856.             } else {
  857.                 $childContext['output']['gen_id'] = $propertyMetadata->getGenId() ?? false;
  858.             }
  860.             return $this->serializer->normalize($attributeValue, $format, $childContext);
  861.         }
  863.         return $this->serializer->normalize($attributeValue, $format, $context);
  864.     }
  866.     /**
  867.      * Normalizes a collection of relations (to-many).
  868.      *
  869.      * @param ApiProperty|PropertyMetadata $propertyMetadata
  870.      * @param iterable                     $attributeValue
  871.      *
  872.      * @throws UnexpectedValueException
  873.      */
  874.     protected function normalizeCollectionOfRelations($propertyMetadata, $attributeValue, string $resourceClass, ?string $format, array $context): array
  875.     {
  876.         $value = [];
  877.         foreach ($attributeValue as $index => $obj) {
  878.             if (!\is_object($obj) && null !== $obj) {
  879.                 throw new UnexpectedValueException('Unexpected non-object element in to-many relation.');
  880.             }
  882.             $value[$index] = $this->normalizeRelation($propertyMetadata, $obj, $resourceClass, $format, $context);
  883.         }
  885.         return $value;
  886.     }
  888.     /**
  889.      * Normalizes a relation.
  890.      *
  891.      * @param ApiProperty|PropertyMetadata $propertyMetadata
  892.      * @param object|null                  $relatedObject
  893.      *
  894.      * @throws LogicException
  895.      * @throws UnexpectedValueException
  896.      *
  897.      * @return string|array|\ArrayObject|null IRI or normalized object data
  898.      */
  899.     protected function normalizeRelation($propertyMetadata, $relatedObject, string $resourceClass, ?string $format, array $context)
  900.     {
  901.         if (null === $relatedObject || !empty($context['attributes']) || $propertyMetadata->isReadableLink()) {
  902.             if (!$this->serializer instanceof NormalizerInterface) {
  903.                 throw new LogicException(sprintf('The injected serializer must be an instance of "%s".', NormalizerInterface::class));
  904.             }
  906.             $normalizedRelatedObject = $this->serializer->normalize($relatedObject, $format, $context);
  907.             if (!\is_string($normalizedRelatedObject) && !\is_array($normalizedRelatedObject) && !$normalizedRelatedObject instanceof \ArrayObject && null !== $normalizedRelatedObject) {
  908.                 throw new UnexpectedValueException('Expected normalized relation to be an IRI, array, \ArrayObject or null');
  909.             }
  911.             return $normalizedRelatedObject;
  912.         }
  914.         $iri = $this->iriConverter instanceof LegacyIriConverterInterface ? $this->iriConverter->getIriFromItem($relatedObject) : $this->iriConverter->getIriFromResource($relatedObject);
  916.         if (isset($context['resources'])) {
  917.             $context['resources'][$iri] = $iri;
  918.         }
  920.         $push = $propertyMetadata instanceof PropertyMetadata ? $propertyMetadata->getAttribute('push', false) : ($propertyMetadata->getPush() ?? false);
  921.         if (isset($context['resources_to_push']) && $push) {
  922.             $context['resources_to_push'][$iri] = $iri;
  923.         }
  925.         return $iri;
  926.     }
  928.     /**
  929.      * Finds the first supported data transformer if any.
  930.      *
  931.      * @param object|array $data object on normalize / array on denormalize
  932.      */
  933.     protected function getDataTransformer($data, string $to, array $context = []): ?DataTransformerInterface
  934.     {
  935.         foreach ($this->dataTransformers as $dataTransformer) {
  936.             if ($dataTransformer->supportsTransformation($data, $to, $context)) {
  937.                 return $dataTransformer;
  938.             }
  939.         }
  941.         return null;
  942.     }
  944.     /**
  945.      * For a given resource, it returns an output representation if any
  946.      * If not, the resource is returned.
  947.      *
  948.      * @param mixed $object
  949.      */
  950.     protected function transformOutput($object, array $context = [], string $outputClass = null)
  951.     {
  952.     }
  954.     private function createAttributeValue($attribute, $value, $format = null, array $context = [])
  955.     {
  956.         if (!$this->resourceClassResolver->isResourceClass($context['resource_class'])) {
  957.             return $value;
  958.         }
  960.         /** @var ApiProperty|PropertyMetadata */
  961.         $propertyMetadata = $this->propertyMetadataFactory->create($context['resource_class'], $attribute, $this->getFactoryOptions($context));
  962.         $type = $propertyMetadata instanceof PropertyMetadata ? $propertyMetadata->getType() : ($propertyMetadata->getBuiltinTypes()[0] ?? null);
  964.         if (null === $type) {
  965.             // No type provided, blindly return the value
  966.             return $value;
  967.         }
  969.         if (null === $value && $type->isNullable()) {
  970.             return $value;
  971.         }
  973.         $collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType();
  975.         /* From @see AbstractObjectNormalizer::validateAndDenormalize() */
  976.         // Fix a collection that contains the only one element
  977.         // This is special to xml format only
  978.         if ('xml' === $format && null !== $collectionValueType && (!\is_array($value) || !\is_int(key($value)))) {
  979.             $value = [$value];
  980.         }
  982.         if (
  983.             $type->isCollection() &&
  984.             null !== $collectionValueType &&
  985.             null !== ($className = $collectionValueType->getClassName()) &&
  986.             $this->resourceClassResolver->isResourceClass($className)
  987.         ) {
  988.             $resourceClass = $this->resourceClassResolver->getResourceClass(null, $className);
  989.             $context['resource_class'] = $resourceClass;
  991.             return $this->denormalizeCollection($attribute, $propertyMetadata, $type, $resourceClass, $value, $format, $context);
  992.         }
  994.         if (
  995.             null !== ($className = $type->getClassName()) &&
  996.             $this->resourceClassResolver->isResourceClass($className)
  997.         ) {
  998.             $resourceClass = $this->resourceClassResolver->getResourceClass(null, $className);
  999.             $childContext = $this->createChildContext($context, $attribute, $format);
  1000.             $childContext['resource_class'] = $resourceClass;
  1001.             if ($this->resourceMetadataFactory instanceof ResourceMetadataCollectionFactoryInterface) {
  1002.                 $childContext['operation'] = $this->resourceMetadataFactory->create($resourceClass)->getOperation();
  1003.             }
  1005.             return $this->denormalizeRelation($attribute, $propertyMetadata, $resourceClass, $value, $format, $childContext);
  1006.         }
  1008.         if (
  1009.             $type->isCollection() &&
  1010.             null !== $collectionValueType &&
  1011.             null !== ($className = $collectionValueType->getClassName())
  1012.         ) {
  1013.             if (!$this->serializer instanceof DenormalizerInterface) {
  1014.                 throw new LogicException(sprintf('The injected serializer must be an instance of "%s".', DenormalizerInterface::class));
  1015.             }
  1017.             unset($context['resource_class']);
  1019.             return $this->serializer->denormalize($value, $className.'[]', $format, $context);
  1020.         }
  1022.         if (null !== $className = $type->getClassName()) {
  1023.             if (!$this->serializer instanceof DenormalizerInterface) {
  1024.                 throw new LogicException(sprintf('The injected serializer must be an instance of "%s".', DenormalizerInterface::class));
  1025.             }
  1027.             unset($context['resource_class']);
  1029.             return $this->serializer->denormalize($value, $className, $format, $context);
  1030.         }
  1032.         /* From @see AbstractObjectNormalizer::validateAndDenormalize() */
  1033.         // In XML and CSV all basic datatypes are represented as strings, it is e.g. not possible to determine,
  1034.         // if a value is meant to be a string, float, int or a boolean value from the serialized representation.
  1035.         // That's why we have to transform the values, if one of these non-string basic datatypes is expected.
  1036.         if (\is_string($value) && (XmlEncoder::FORMAT === $format || CsvEncoder::FORMAT === $format)) {
  1037.             if ('' === $value && $type->isNullable() && \in_array($type->getBuiltinType(), [Type::BUILTIN_TYPE_BOOL, Type::BUILTIN_TYPE_INT, Type::BUILTIN_TYPE_FLOAT], true)) {
  1038.                 return null;
  1039.             }
  1041.             switch ($type->getBuiltinType()) {
  1042.                 case Type::BUILTIN_TYPE_BOOL:
  1043.                     // according to https://www.w3.org/TR/xmlschema-2/#boolean, valid representations are "false", "true", "0" and "1"
  1044.                     if ('false' === $value || '0' === $value) {
  1045.                         $value = false;
  1046.                     } elseif ('true' === $value || '1' === $value) {
  1047.                         $value = true;
  1048.                     } else {
  1049.                         throw new NotNormalizableValueException(sprintf('The type of the "%s" attribute for class "%s" must be bool ("%s" given).', $attribute, $className, $value));
  1050.                     }
  1051.                     break;
  1052.                 case Type::BUILTIN_TYPE_INT:
  1053.                     if (ctype_digit($value) || ('-' === $value[0] && ctype_digit(substr($value, 1)))) {
  1054.                         $value = (int) $value;
  1055.                     } else {
  1056.                         throw new NotNormalizableValueException(sprintf('The type of the "%s" attribute for class "%s" must be int ("%s" given).', $attribute, $className, $value));
  1057.                     }
  1058.                     break;
  1059.                 case Type::BUILTIN_TYPE_FLOAT:
  1060.                     if (is_numeric($value)) {
  1061.                         return (float) $value;
  1062.                     }
  1064.                     switch ($value) {
  1065.                         case 'NaN':
  1066.                             return \NAN;
  1067.                         case 'INF':
  1068.                             return \INF;
  1069.                         case '-INF':
  1070.                             return -\INF;
  1071.                         default:
  1072.                             throw new NotNormalizableValueException(sprintf('The type of the "%s" attribute for class "%s" must be float ("%s" given).', $attribute, $className, $value));
  1073.                     }
  1074.             }
  1075.         }
  1077.         if ($context[static::DISABLE_TYPE_ENFORCEMENT] ?? false) {
  1078.             return $value;
  1079.         }
  1081.         $this->validateType($attribute, $type, $value, $format);
  1083.         return $value;
  1084.     }
  1086.     /**
  1087.      * Sets a value of the object using the PropertyAccess component.
  1088.      *
  1089.      * @param object $object
  1090.      * @param mixed  $value
  1091.      */
  1092.     private function setValue($object, string $attributeName, $value)
  1093.     {
  1094.         try {
  1095.             $this->propertyAccessor->setValue($object, $attributeName, $value);
  1096.         } catch (NoSuchPropertyException $exception) {
  1097.             // Properties not found are ignored
  1098.         }
  1099.     }
  1101.     /**
  1102.      * TODO: to remove in 3.0.
  1103.      *
  1104.      * @deprecated since 2.7
  1105.      */
  1106.     private function supportsPlainIdentifiers(): bool
  1107.     {
  1108.         return $this->allowPlainIdentifiers && null !== $this->itemDataProvider;
  1109.     }
  1110. }
  1112. class_alias(AbstractItemNormalizer::class, \ApiPlatform\Core\Serializer\AbstractItemNormalizer::class);