vendor/doctrine/persistence/lib/Doctrine/Persistence/Mapping/RuntimeReflectionService.php line 38

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