Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/validator/Mapping/Loader/AnnotationLoader.php line 32

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\Validator\Mapping\Loader;
  14. use Doctrine\Common\Annotations\Reader;
  15. use Symfony\Component\Validator\Constraint;
  16. use Symfony\Component\Validator\Constraints\Callback;
  17. use Symfony\Component\Validator\Constraints\GroupSequence;
  18. use Symfony\Component\Validator\Constraints\GroupSequenceProvider;
  19. use Symfony\Component\Validator\Exception\MappingException;
  20. use Symfony\Component\Validator\Mapping\ClassMetadata;
  22. /**
  23.  * Loads validation metadata using a Doctrine annotation {@link Reader} or using PHP 8 attributes.
  24.  *
  25.  * @author Bernhard Schussek <bschussek@gmail.com>
  26.  * @author Alexander M. Turek <me@derrabus.de>
  27.  */
  28. class AnnotationLoader implements LoaderInterface
  29. {
  30.     protected $reader;
  32.     public function __construct(Reader $reader = null)
  33.     {
  34.         $this->reader = $reader;
  35.     }
  37.     /**
  38.      * {@inheritdoc}
  39.      */
  40.     public function loadClassMetadata(ClassMetadata $metadata)
  41.     {
  42.         $reflClass = $metadata->getReflectionClass();
  43.         $className = $reflClass->name;
  44.         $success = false;
  46.         foreach ($this->getAnnotations($reflClass) as $constraint) {
  47.             if ($constraint instanceof GroupSequence) {
  48.                 $metadata->setGroupSequence($constraint->groups);
  49.             } elseif ($constraint instanceof GroupSequenceProvider) {
  50.                 $metadata->setGroupSequenceProvider(true);
  51.             } elseif ($constraint instanceof Constraint) {
  52.                 $metadata->addConstraint($constraint);
  53.             }
  55.             $success = true;
  56.         }
  58.         foreach ($reflClass->getProperties() as $property) {
  59.             if ($property->getDeclaringClass()->name === $className) {
  60.                 foreach ($this->getAnnotations($property) as $constraint) {
  61.                     if ($constraint instanceof Constraint) {
  62.                         $metadata->addPropertyConstraint($property->name, $constraint);
  63.                     }
  65.                     $success = true;
  66.                 }
  67.             }
  68.         }
  70.         foreach ($reflClass->getMethods() as $method) {
  71.             if ($method->getDeclaringClass()->name === $className) {
  72.                 foreach ($this->getAnnotations($method) as $constraint) {
  73.                     if ($constraint instanceof Callback) {
  74.                         $constraint->callback = $method->getName();
  76.                         $metadata->addConstraint($constraint);
  77.                     } elseif ($constraint instanceof Constraint) {
  78.                         if (preg_match('/^(get|is|has)(.+)$/i', $method->name, $matches)) {
  79.                             $metadata->addGetterMethodConstraint(lcfirst($matches[2]), $matches[0], $constraint);
  80.                         } else {
  81.                             throw new MappingException(sprintf('The constraint on "%s::%s()" cannot be added. Constraints can only be added on methods beginning with "get", "is" or "has".', $className, $method->name));
  82.                         }
  83.                     }
  85.                     $success = true;
  86.                 }
  87.             }
  88.         }
  90.         return $success;
  91.     }
  93.     /**
  94.      * @param \ReflectionClass|\ReflectionMethod|\ReflectionProperty $reflection
  95.      */
  96.     private function getAnnotations(object $reflection): iterable
  97.     {
  98.         $dedup = [];
  100.         if (\PHP_VERSION_ID >= 80000) {
  101.             foreach ($reflection->getAttributes(GroupSequence::class) as $attribute) {
  102.                 $dedup[] = $attribute->newInstance();
  103.                 yield $attribute->newInstance();
  104.             }
  105.             foreach ($reflection->getAttributes(GroupSequenceProvider::class) as $attribute) {
  106.                 $dedup[] = $attribute->newInstance();
  107.                 yield $attribute->newInstance();
  108.             }
  109.             foreach ($reflection->getAttributes(Constraint::class, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
  110.                 $dedup[] = $attribute->newInstance();
  111.                 yield $attribute->newInstance();
  112.             }
  113.         }
  114.         if (!$this->reader) {
  115.             return;
  116.         }
  118.         $annotations = [];
  120.         if ($reflection instanceof \ReflectionClass) {
  121.             $annotations = $this->reader->getClassAnnotations($reflection);
  122.         }
  123.         if ($reflection instanceof \ReflectionMethod) {
  124.             $annotations = $this->reader->getMethodAnnotations($reflection);
  125.         }
  126.         if ($reflection instanceof \ReflectionProperty) {
  127.             $annotations = $this->reader->getPropertyAnnotations($reflection);
  128.         }
  130.         foreach ($dedup as $annotation) {
  131.             if ($annotation instanceof Constraint) {
  132.                 $annotation->groups; // trigger initialization of the "groups" property
  133.             }
  134.         }
  136.         foreach ($annotations as $annotation) {
  137.             if ($annotation instanceof Constraint) {
  138.                 $annotation->groups; // trigger initialization of the "groups" property
  139.             }
  140.             if (!\in_array($annotation, $dedup, false)) {
  141.                 yield $annotation;
  142.             }
  143.         }
  144.     }
  145. }