vendor/jms/metadata/src/MetadataFactory.php line 145

  1. <?php
  3. declare(strict_types=1);
  5. namespace Metadata;
  7. use Metadata\Cache\CacheInterface;
  8. use Metadata\Driver\AdvancedDriverInterface;
  9. use Metadata\Driver\DriverInterface;
  11. class MetadataFactory implements AdvancedMetadataFactoryInterface
  12. {
  13.     /**
  14.      * @var DriverInterface
  15.      */
  16.     private $driver;
  18.     /**
  19.      * @var CacheInterface
  20.      */
  21.     private $cache;
  23.     /**
  24.      * @var ClassMetadata[]
  25.      */
  26.     private $loadedMetadata = [];
  28.     /**
  29.      * @var ClassMetadata[]
  30.      */
  31.     private $loadedClassMetadata = [];
  33.     /**
  34.      * @var string|null
  35.      */
  36.     private $hierarchyMetadataClass;
  38.     /**
  39.      * @var bool
  40.      */
  41.     private $includeInterfaces = false;
  43.     /**
  44.      * @var bool
  45.      */
  46.     private $debug = false;
  48.     public function __construct(DriverInterface $driver, ?string $hierarchyMetadataClass = 'Metadata\ClassHierarchyMetadata', bool $debug = false)
  49.     {
  50.         $this->driver = $driver;
  51.         $this->hierarchyMetadataClass = $hierarchyMetadataClass;
  52.         $this->debug = $debug;
  53.     }
  55.     public function setIncludeInterfaces(bool $include): void
  56.     {
  57.         $this->includeInterfaces = $include;
  58.     }
  60.     public function setCache(CacheInterface $cache): void
  61.     {
  62.         $this->cache = $cache;
  63.     }
  65.     /**
  66.      * {@inheritDoc}
  67.      */
  68.     public function getMetadataForClass(string $className)
  69.     {
  70.         if (isset($this->loadedMetadata[$className])) {
  71.             return $this->filterNullMetadata($this->loadedMetadata[$className]);
  72.         }
  74.         $metadata = null;
  75.         foreach ($this->getClassHierarchy($className) as $class) {
  76.             if (isset($this->loadedClassMetadata[$name = $class->getName()])) {
  77.                 if (null !== $classMetadata = $this->filterNullMetadata($this->loadedClassMetadata[$name])) {
  78.                     $this->addClassMetadata($metadata, $classMetadata);
  79.                 }
  81.                 continue;
  82.             }
  84.             // check the cache
  85.             if (null !== $this->cache) {
  86.                 if (($classMetadata = $this->cache->load($class->getName())) instanceof NullMetadata) {
  87.                     $this->loadedClassMetadata[$name] = $classMetadata;
  88.                     continue;
  89.                 }
  91.                 if (null !== $classMetadata) {
  92.                     if (!$classMetadata instanceof ClassMetadata) {
  93.                         throw new \LogicException(sprintf(
  94.                             'The cache must return instances of ClassMetadata for class %s, but got %s.',
  95.                             $className,
  96.                             var_export($classMetadata, true)
  97.                         ));
  98.                     }
  100.                     if ($this->debug && !$classMetadata->isFresh()) {
  101.                         $this->cache->evict($classMetadata->name);
  102.                     } else {
  103.                         $this->loadedClassMetadata[$name] = $classMetadata;
  104.                         $this->addClassMetadata($metadata, $classMetadata);
  105.                         continue;
  106.                     }
  107.                 }
  108.             }
  110.             // load from source
  111.             if (null !== $classMetadata = $this->driver->loadMetadataForClass($class)) {
  112.                 $this->loadedClassMetadata[$name] = $classMetadata;
  113.                 $this->addClassMetadata($metadata, $classMetadata);
  115.                 if (null !== $this->cache) {
  116.                     $this->cache->put($classMetadata);
  117.                 }
  119.                 continue;
  120.             }
  122.             if (null !== $this->cache && !$this->debug) {
  123.                 $this->cache->put(new NullMetadata($class->getName()));
  124.             }
  125.         }
  127.         if (null === $metadata) {
  128.             $metadata = new NullMetadata($className);
  129.         }
  131.         return $this->filterNullMetadata($this->loadedMetadata[$className] = $metadata);
  132.     }
  134.     /**
  135.      * {@inheritDoc}
  136.      */
  137.     public function getAllClassNames(): array
  138.     {
  139.         if (!$this->driver instanceof AdvancedDriverInterface) {
  140.             throw new \RuntimeException(
  141.                 sprintf('Driver "%s" must be an instance of "AdvancedDriverInterface".', get_class($this->driver))
  142.             );
  143.         }
  145.         return $this->driver->getAllClassNames();
  146.     }
  148.     /**
  149.      * @param MergeableInterface|ClassHierarchyMetadata $metadata
  150.      */
  151.     private function addClassMetadata(&$metadata, ClassMetadata $toAdd): void
  152.     {
  153.         if ($toAdd instanceof MergeableInterface) {
  154.             if (null === $metadata) {
  155.                 $metadata = clone $toAdd;
  156.             } else {
  157.                 $metadata->merge($toAdd);
  158.             }
  159.         } else {
  160.             if (null === $metadata) {
  161.                 $class = $this->hierarchyMetadataClass;
  162.                 $metadata = new $class();
  163.             }
  165.             $metadata->addClassMetadata($toAdd);
  166.         }
  167.     }
  169.     /**
  170.      * @return \ReflectionClass[]
  171.      */
  172.     private function getClassHierarchy(string $class): array
  173.     {
  174.         $classes = [];
  175.         $refl = new \ReflectionClass($class);
  177.         do {
  178.             $classes[] = $refl;
  179.             $refl = $refl->getParentClass();
  180.         } while (false !== $refl);
  182.         $classes = array_reverse($classes, false);
  184.         if (!$this->includeInterfaces) {
  185.             return $classes;
  186.         }
  188.         $addedInterfaces = [];
  189.         $newHierarchy = [];
  191.         foreach ($classes as $class) {
  192.             foreach ($class->getInterfaces() as $interface) {
  193.                 if (isset($addedInterfaces[$interface->getName()])) {
  194.                     continue;
  195.                 }
  197.                 $addedInterfaces[$interface->getName()] = true;
  199.                 $newHierarchy[] = $interface;
  200.             }
  202.             $newHierarchy[] = $class;
  203.         }
  205.         return $newHierarchy;
  206.     }
  208.     /**
  209.      * @param ClassMetadata|ClassHierarchyMetadata|MergeableInterface $metadata
  210.      *
  211.      * @return ClassMetadata|ClassHierarchyMetadata|MergeableInterface
  212.      */
  213.     private function filterNullMetadata($metadata = null)
  214.     {
  215.         return !$metadata instanceof NullMetadata ? $metadata : null;
  216.     }
  217. }