vendor/doctrine/annotations/lib/Doctrine/Common/Annotations/AnnotationRegistry.php line 136

  1. <?php
  3. namespace Doctrine\Common\Annotations;
  5. use function array_key_exists;
  6. use function array_merge;
  7. use function class_exists;
  8. use function in_array;
  9. use function is_file;
  10. use function str_replace;
  11. use function stream_resolve_include_path;
  12. use function strpos;
  14. use const DIRECTORY_SEPARATOR;
  16. final class AnnotationRegistry
  17. {
  18.     /**
  19.      * A map of namespaces to use for autoloading purposes based on a PSR-0 convention.
  20.      *
  21.      * Contains the namespace as key and an array of directories as value. If the value is NULL
  22.      * the include path is used for checking for the corresponding file.
  23.      *
  24.      * This autoloading mechanism does not utilize the PHP autoloading but implements autoloading on its own.
  25.      *
  26.      * @var string[][]|string[]|null[]
  27.      */
  28.     private static $autoloadNamespaces = [];
  30.     /**
  31.      * A map of autoloader callables.
  32.      *
  33.      * @var callable[]
  34.      */
  35.     private static $loaders = [];
  37.     /**
  38.      * An array of classes which cannot be found
  39.      *
  40.      * @var null[] indexed by class name
  41.      */
  42.     private static $failedToAutoload = [];
  44.     /**
  45.      * Whenever registerFile() was used. Disables use of standard autoloader.
  46.      *
  47.      * @var bool
  48.      */
  49.     private static $registerFileUsed = false;
  51.     public static function reset(): void
  52.     {
  53.         self::$autoloadNamespaces = [];
  54.         self::$loaders            = [];
  55.         self::$failedToAutoload   = [];
  56.         self::$registerFileUsed   = false;
  57.     }
  59.     /**
  60.      * Registers file.
  61.      *
  62.      * @deprecated This method is deprecated and will be removed in
  63.      *             doctrine/annotations 2.0. Annotations will be autoloaded in 2.0.
  64.      */
  65.     public static function registerFile(string $file): void
  66.     {
  67.         self::$registerFileUsed = true;
  69.         require_once $file;
  70.     }
  72.     /**
  73.      * Adds a namespace with one or many directories to look for files or null for the include path.
  74.      *
  75.      * Loading of this namespaces will be done with a PSR-0 namespace loading algorithm.
  76.      *
  77.      * @deprecated This method is deprecated and will be removed in
  78.      *             doctrine/annotations 2.0. Annotations will be autoloaded in 2.0.
  79.      *
  80.      * @phpstan-param string|list<string>|null $dirs
  81.      */
  82.     public static function registerAutoloadNamespace(string $namespace, $dirs = null): void
  83.     {
  84.         self::$autoloadNamespaces[$namespace] = $dirs;
  85.     }
  87.     /**
  88.      * Registers multiple namespaces.
  89.      *
  90.      * Loading of this namespaces will be done with a PSR-0 namespace loading algorithm.
  91.      *
  92.      * @deprecated This method is deprecated and will be removed in
  93.      *             doctrine/annotations 2.0. Annotations will be autoloaded in 2.0.
  94.      *
  95.      * @param string[][]|string[]|null[] $namespaces indexed by namespace name
  96.      */
  97.     public static function registerAutoloadNamespaces(array $namespaces): void
  98.     {
  99.         self::$autoloadNamespaces = array_merge(self::$autoloadNamespaces, $namespaces);
  100.     }
  102.     /**
  103.      * Registers an autoloading callable for annotations, much like spl_autoload_register().
  104.      *
  105.      * NOTE: These class loaders HAVE to be silent when a class was not found!
  106.      * IMPORTANT: Loaders have to return true if they loaded a class that could contain the searched annotation class.
  107.      *
  108.      * @deprecated This method is deprecated and will be removed in
  109.      *             doctrine/annotations 2.0. Annotations will be autoloaded in 2.0.
  110.      */
  111.     public static function registerLoader(callable $callable): void
  112.     {
  113.         // Reset our static cache now that we have a new loader to work with
  114.         self::$failedToAutoload = [];
  115.         self::$loaders[]        = $callable;
  116.     }
  118.     /**
  119.      * Registers an autoloading callable for annotations, if it is not already registered
  120.      *
  121.      * @deprecated This method is deprecated and will be removed in
  122.      *             doctrine/annotations 2.0. Annotations will be autoloaded in 2.0.
  123.      */
  124.     public static function registerUniqueLoader(callable $callable): void
  125.     {
  126.         if (in_array($callable, self::$loaders, true)) {
  127.             return;
  128.         }
  130.         self::registerLoader($callable);
  131.     }
  133.     /**
  134.      * Autoloads an annotation class silently.
  135.      */
  136.     public static function loadAnnotationClass(string $class): bool
  137.     {
  138.         if (class_exists($class, false)) {
  139.             return true;
  140.         }
  142.         if (array_key_exists($class, self::$failedToAutoload)) {
  143.             return false;
  144.         }
  146.         foreach (self::$autoloadNamespaces as $namespace => $dirs) {
  147.             if (strpos($class, $namespace) !== 0) {
  148.                 continue;
  149.             }
  151.             $file = str_replace('\\', DIRECTORY_SEPARATOR, $class) . '.php';
  153.             if ($dirs === null) {
  154.                 $path = stream_resolve_include_path($file);
  155.                 if ($path) {
  156.                     require $path;
  158.                     return true;
  159.                 }
  160.             } else {
  161.                 foreach ((array) $dirs as $dir) {
  162.                     if (is_file($dir . DIRECTORY_SEPARATOR . $file)) {
  163.                         require $dir . DIRECTORY_SEPARATOR . $file;
  165.                         return true;
  166.                     }
  167.                 }
  168.             }
  169.         }
  171.         foreach (self::$loaders as $loader) {
  172.             if ($loader($class) === true) {
  173.                 return true;
  174.             }
  175.         }
  177.         if (
  178.             self::$loaders === [] &&
  179.             self::$autoloadNamespaces === [] &&
  180.             self::$registerFileUsed === false &&
  181.             class_exists($class)
  182.         ) {
  183.             return true;
  184.         }
  186.         self::$failedToAutoload[$class] = null;
  188.         return false;
  189.     }
  190. }