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

Open in your IDE?
  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. }