Deprecated: Constant E_STRICT is deprecated in /home/normanv/www/annuairepro/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/normanv/www/annuairepro/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/serializer/Normalizer/PropertyNormalizer.php line 157

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\UninitializedPropertyException;
  16. /**
  17.  * Converts between objects and arrays by mapping properties.
  18.  *
  19.  * The normalization process looks for all the object's properties (public and private).
  20.  * The result is a map from property names to property values. Property values
  21.  * are normalized through the serializer.
  22.  *
  23.  * The denormalization first looks at the constructor of the given class to see
  24.  * if any of the parameters have the same name as one of the properties. The
  25.  * constructor is then called with all parameters or an exception is thrown if
  26.  * any required parameters were not present as properties. Then the denormalizer
  27.  * walks through the given map of property names to property values to see if a
  28.  * property with the corresponding name exists. If found, the property gets the value.
  29.  *
  30.  * @author Matthieu Napoli <matthieu@mnapoli.fr>
  31.  * @author Kévin Dunglas <dunglas@gmail.com>
  32.  */
  33. class PropertyNormalizer extends AbstractObjectNormalizer
  34. {
  35.     /**
  36.      * {@inheritdoc}
  37.      */
  38.     public function supportsNormalization($data, string $format = null)
  39.     {
  40.         return parent::supportsNormalization($data, $format) && $this->supports(\get_class($data));
  41.     }
  43.     /**
  44.      * {@inheritdoc}
  45.      */
  46.     public function supportsDenormalization($data, string $type, string $format = null)
  47.     {
  48.         return parent::supportsDenormalization($data, $type, $format) && $this->supports($type);
  49.     }
  51.     /**
  52.      * {@inheritdoc}
  53.      */
  54.     public function hasCacheableSupportsMethod(): bool
  55.     {
  56.         return __CLASS__ === static::class;
  57.     }
  59.     /**
  60.      * Checks if the given class has any non-static property.
  61.      */
  62.     private function supports(string $class): bool
  63.     {
  64.         $class = new \ReflectionClass($class);
  66.         // We look for at least one non-static property
  67.         do {
  68.             foreach ($class->getProperties() as $property) {
  69.                 if (!$property->isStatic()) {
  70.                     return true;
  71.                 }
  72.             }
  73.         } while ($class = $class->getParentClass());
  75.         return false;
  76.     }
  78.     /**
  79.      * {@inheritdoc}
  80.      */
  81.     protected function isAllowedAttribute($classOrObject, string $attribute, string $format = null, array $context = [])
  82.     {
  83.         if (!parent::isAllowedAttribute($classOrObject, $attribute, $format, $context)) {
  84.             return false;
  85.         }
  87.         try {
  88.             $reflectionProperty = $this->getReflectionProperty($classOrObject, $attribute);
  89.             if ($reflectionProperty->isStatic()) {
  90.                 return false;
  91.             }
  92.         } catch (\ReflectionException $reflectionException) {
  93.             return false;
  94.         }
  96.         return true;
  97.     }
  99.     /**
  100.      * {@inheritdoc}
  101.      */
  102.     protected function extractAttributes(object $object, string $format = null, array $context = [])
  103.     {
  104.         $reflectionObject = new \ReflectionObject($object);
  105.         $attributes = [];
  107.         do {
  108.             foreach ($reflectionObject->getProperties() as $property) {
  109.                 if (!$this->isAllowedAttribute($reflectionObject->getName(), $property->name, $format, $context)) {
  110.                     continue;
  111.                 }
  113.                 $attributes[] = $property->name;
  114.             }
  115.         } while ($reflectionObject = $reflectionObject->getParentClass());
  117.         return array_unique($attributes);
  118.     }
  120.     /**
  121.      * {@inheritdoc}
  122.      */
  123.     protected function getAttributeValue(object $object, string $attribute, string $format = null, array $context = [])
  124.     {
  125.         try {
  126.             $reflectionProperty = $this->getReflectionProperty($object, $attribute);
  127.         } catch (\ReflectionException $reflectionException) {
  128.             return null;
  129.         }
  131.         // Override visibility
  132.         if (!$reflectionProperty->isPublic()) {
  133.             $reflectionProperty->setAccessible(true);
  134.         }
  136.         if (\PHP_VERSION_ID >= 70400 && $reflectionProperty->hasType()) {
  137.             return $reflectionProperty->getValue($object);
  138.         }
  140.         if (!method_exists($object, '__get') && !isset($object->$attribute)) {
  141.             $propertyValues = (array) $object;
  143.             if (($reflectionProperty->isPublic() && !\array_key_exists($reflectionProperty->name, $propertyValues))
  144.                 || ($reflectionProperty->isProtected() && !\array_key_exists("\0*\0{$reflectionProperty->name}", $propertyValues))
  145.                 || ($reflectionProperty->isPrivate() && !\array_key_exists("\0{$reflectionProperty->class}\0{$reflectionProperty->name}", $propertyValues))
  146.             ) {
  147.                 throw new UninitializedPropertyException(sprintf('The property "%s::$%s" is not initialized.', \get_class($object), $reflectionProperty->name));
  148.             }
  149.         }
  151.         return $reflectionProperty->getValue($object);
  152.     }
  154.     /**
  155.      * {@inheritdoc}
  156.      */
  157.     protected function setAttributeValue(object $object, string $attribute, $value, string $format = null, array $context = [])
  158.     {
  159.         try {
  160.             $reflectionProperty = $this->getReflectionProperty($object, $attribute);
  161.         } catch (\ReflectionException $reflectionException) {
  162.             return;
  163.         }
  165.         if ($reflectionProperty->isStatic()) {
  166.             return;
  167.         }
  169.         // Override visibility
  170.         if (!$reflectionProperty->isPublic()) {
  171.             $reflectionProperty->setAccessible(true);
  172.         }
  174.         $reflectionProperty->setValue($object, $value);
  175.     }
  177.     /**
  178.      * @param string|object $classOrObject
  179.      *
  180.      * @throws \ReflectionException
  181.      */
  182.     private function getReflectionProperty($classOrObject, string $attribute): \ReflectionProperty
  183.     {
  184.         $reflectionClass = new \ReflectionClass($classOrObject);
  185.         while (true) {
  186.             try {
  187.                 return $reflectionClass->getProperty($attribute);
  188.             } catch (\ReflectionException $e) {
  189.                 if (!$reflectionClass = $reflectionClass->getParentClass()) {
  190.                     throw $e;
  191.                 }
  192.             }
  193.         }
  194.     }
  195. }