vendor/doctrine/persistence/src/Persistence/Mapping/RuntimeReflectionService.php line 41

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\Persistence\Mapping;
  7. use Doctrine\Persistence\Reflection\RuntimePublicReflectionProperty;
  8. use Doctrine\Persistence\Reflection\TypedNoDefaultReflectionProperty;
  9. use Doctrine\Persistence\Reflection\TypedNoDefaultRuntimePublicReflectionProperty;
  10. use ReflectionClass;
  11. use ReflectionException;
  12. use ReflectionMethod;
  13. use ReflectionProperty;
  15. use function array_key_exists;
  16. use function assert;
  17. use function class_exists;
  18. use function class_parents;
  19. use function phpversion;
  20. use function version_compare;
  22. /**
  23.  * PHP Runtime Reflection Service.
  24.  */
  25. class RuntimeReflectionService implements ReflectionService
  26. {
  27.     /** @var bool */
  28.     private $supportsTypedPropertiesWorkaround;
  30.     public function __construct()
  31.     {
  32.         $this->supportsTypedPropertiesWorkaround = version_compare(phpversion(), '7.4.0') >= 0;
  33.     }
  35.     /**
  36.      * {@inheritDoc}
  37.      */
  38.     public function getParentClasses(string $class)
  39.     {
  40.         if (! class_exists($class)) {
  41.             throw MappingException::nonExistingClass($class);
  42.         }
  44.         $parents = class_parents($class);
  46.         assert($parents !== false);
  48.         return $parents;
  49.     }
  51.     /**
  52.      * {@inheritDoc}
  53.      */
  54.     public function getClassShortName(string $class)
  55.     {
  56.         $reflectionClass = new ReflectionClass($class);
  58.         return $reflectionClass->getShortName();
  59.     }
  61.     /**
  62.      * {@inheritDoc}
  63.      */
  64.     public function getClassNamespace(string $class)
  65.     {
  66.         $reflectionClass = new ReflectionClass($class);
  68.         return $reflectionClass->getNamespaceName();
  69.     }
  71.     /**
  72.      * @psalm-param class-string<T> $class
  73.      *
  74.      * @return ReflectionClass
  75.      * @psalm-return ReflectionClass<T>
  76.      *
  77.      * @template T of object
  78.      */
  79.     public function getClass(string $class)
  80.     {
  81.         return new ReflectionClass($class);
  82.     }
  84.     /**
  85.      * {@inheritDoc}
  86.      */
  87.     public function getAccessibleProperty(string $class, string $property)
  88.     {
  89.         $reflectionProperty = new ReflectionProperty($class, $property);
  91.         if ($this->supportsTypedPropertiesWorkaround && ! array_key_exists($property, $this->getClass($class)->getDefaultProperties())) {
  92.             if ($reflectionProperty->isPublic()) {
  93.                 $reflectionProperty = new TypedNoDefaultRuntimePublicReflectionProperty($class, $property);
  94.             } else {
  95.                 $reflectionProperty = new TypedNoDefaultReflectionProperty($class, $property);
  96.             }
  97.         } elseif ($reflectionProperty->isPublic()) {
  98.             $reflectionProperty = new RuntimePublicReflectionProperty($class, $property);
  99.         }
  101.         $reflectionProperty->setAccessible(true);
  103.         return $reflectionProperty;
  104.     }
  106.     /**
  107.      * {@inheritDoc}
  108.      */
  109.     public function hasPublicMethod(string $class, string $method)
  110.     {
  111.         try {
  112.             $reflectionMethod = new ReflectionMethod($class, $method);
  113.         } catch (ReflectionException $e) {
  114.             return false;
  115.         }
  117.         return $reflectionMethod->isPublic();
  118.     }
  119. }