vendor/symfony/serializer/Normalizer/ObjectNormalizer.php line 146

  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\NoSuchPropertyException;
  15. use Symfony\Component\PropertyAccess\PropertyAccess;
  16. use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
  17. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  18. use Symfony\Component\Serializer\Exception\LogicException;
  19. use Symfony\Component\Serializer\Mapping\AttributeMetadata;
  20. use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface;
  21. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
  22. use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
  24. /**
  25.  * Converts between objects and arrays using the PropertyAccess component.
  26.  *
  27.  * @author Kévin Dunglas <dunglas@gmail.com>
  28.  */
  29. class ObjectNormalizer extends AbstractObjectNormalizer
  30. {
  31.     protected $propertyAccessor;
  33.     private $discriminatorCache = [];
  35.     private $objectClassResolver;
  37.     public function __construct(ClassMetadataFactoryInterface $classMetadataFactory = null, NameConverterInterface $nameConverter = null, PropertyAccessorInterface $propertyAccessor = null, PropertyTypeExtractorInterface $propertyTypeExtractor = null, ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null, callable $objectClassResolver = null, array $defaultContext = [])
  38.     {
  39.         if (!class_exists(PropertyAccess::class)) {
  40.             throw new LogicException('The ObjectNormalizer class requires the "PropertyAccess" component. Install "symfony/property-access" to use it.');
  41.         }
  43.         parent::__construct($classMetadataFactory, $nameConverter, $propertyTypeExtractor, $classDiscriminatorResolver, $objectClassResolver, $defaultContext);
  45.         $this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();
  47.         $this->objectClassResolver = $objectClassResolver ?? function ($class) {
  48.             return \is_object($class) ? $class::class : $class;
  49.         };
  50.     }
  52.     public function hasCacheableSupportsMethod(): bool
  53.     {
  54.         return __CLASS__ === static::class;
  55.     }
  57.     protected function extractAttributes(object $object, string $format = null, array $context = []): array
  58.     {
  59.         if (\stdClass::class === $object::class) {
  60.             return array_keys((array) $object);
  61.         }
  63.         // If not using groups, detect manually
  64.         $attributes = [];
  66.         // methods
  67.         $class = ($this->objectClassResolver)($object);
  68.         $reflClass = new \ReflectionClass($class);
  70.         foreach ($reflClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $reflMethod) {
  71.             if (
  72.                 0 !== $reflMethod->getNumberOfRequiredParameters() ||
  73.                 $reflMethod->isStatic() ||
  74.                 $reflMethod->isConstructor() ||
  75.                 $reflMethod->isDestructor()
  76.             ) {
  77.                 continue;
  78.             }
  80.             $name = $reflMethod->name;
  81.             $attributeName = null;
  83.             if (str_starts_with($name, 'get') || str_starts_with($name, 'has') || str_starts_with($name, 'can')) {
  84.                 // getters, hassers and canners
  85.                 $attributeName = substr($name, 3);
  87.                 if (!$reflClass->hasProperty($attributeName)) {
  88.                     $attributeName = lcfirst($attributeName);
  89.                 }
  90.             } elseif (str_starts_with($name, 'is')) {
  91.                 // issers
  92.                 $attributeName = substr($name, 2);
  94.                 if (!$reflClass->hasProperty($attributeName)) {
  95.                     $attributeName = lcfirst($attributeName);
  96.                 }
  97.             }
  99.             if (null !== $attributeName && $this->isAllowedAttribute($object, $attributeName, $format, $context)) {
  100.                 $attributes[$attributeName] = true;
  101.             }
  102.         }
  104.         // properties
  105.         foreach ($reflClass->getProperties() as $reflProperty) {
  106.             if (!$reflProperty->isPublic()) {
  107.                 continue;
  108.             }
  110.             if ($reflProperty->isStatic() || !$this->isAllowedAttribute($object, $reflProperty->name, $format, $context)) {
  111.                 continue;
  112.             }
  114.             $attributes[$reflProperty->name] = true;
  115.         }
  117.         return array_keys($attributes);
  118.     }
  120.     protected function getAttributeValue(object $object, string $attribute, string $format = null, array $context = []): mixed
  121.     {
  122.         $cacheKey = $object::class;
  123.         if (!\array_key_exists($cacheKey, $this->discriminatorCache)) {
  124.             $this->discriminatorCache[$cacheKey] = null;
  125.             if (null !== $this->classDiscriminatorResolver) {
  126.                 $mapping = $this->classDiscriminatorResolver->getMappingForMappedObject($object);
  127.                 $this->discriminatorCache[$cacheKey] = $mapping?->getTypeProperty();
  128.             }
  129.         }
  131.         return $attribute === $this->discriminatorCache[$cacheKey] ? $this->classDiscriminatorResolver->getTypeForMappedObject($object) : $this->propertyAccessor->getValue($object, $attribute);
  132.     }
  134.     protected function setAttributeValue(object $object, string $attribute, mixed $value, string $format = null, array $context = [])
  135.     {
  136.         try {
  137.             $this->propertyAccessor->setValue($object, $attribute, $value);
  138.         } catch (NoSuchPropertyException) {
  139.             // Properties not found are ignored
  140.         }
  141.     }
  143.     protected function getAllowedAttributes(string|object $classOrObject, array $context, bool $attributesAsString = false): array|bool
  144.     {
  145.         if (false === $allowedAttributes = parent::getAllowedAttributes($classOrObject, $context, $attributesAsString)) {
  146.             return false;
  147.         }
  149.         if (null !== $this->classDiscriminatorResolver) {
  150.             $class = \is_object($classOrObject) ? $classOrObject::class : $classOrObject;
  151.             if (null !== $discriminatorMapping = $this->classDiscriminatorResolver->getMappingForMappedObject($classOrObject)) {
  152.                 $allowedAttributes[] = $attributesAsString ? $discriminatorMapping->getTypeProperty() : new AttributeMetadata($discriminatorMapping->getTypeProperty());
  153.             }
  155.             if (null !== $discriminatorMapping = $this->classDiscriminatorResolver->getMappingForClass($class)) {
  156.                 $attributes = [];
  157.                 foreach ($discriminatorMapping->getTypesMapping() as $mappedClass) {
  158.                     $attributes[] = parent::getAllowedAttributes($mappedClass, $context, $attributesAsString);
  159.                 }
  160.                 $allowedAttributes = array_merge($allowedAttributes, ...$attributes);
  161.             }
  162.         }
  164.         return $allowedAttributes;
  165.     }
  166. }