vendor/symfony/config/Resource/ClassExistenceResource.php line 76

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\Config\Resource;
  11. /**
  12.  * ClassExistenceResource represents a class existence.
  13.  * Freshness is only evaluated against resource existence.
  14.  *
  15.  * The resource must be a fully-qualified class name.
  16.  *
  17.  * @author Fabien Potencier <fabien@symfony.com>
  18.  *
  19.  * @final
  20.  */
  21. class ClassExistenceResource implements SelfCheckingResourceInterface
  22. {
  23.     private string $resource;
  24.     private ?array $exists null;
  25.     private static int $autoloadLevel 0;
  26.     private static ?string $autoloadedClass null;
  27.     private static array $existsCache = [];
  28.     /**
  29.      * @param string    $resource The fully-qualified class name
  30.      * @param bool|null $exists   Boolean when the existence check has already been done
  31.      */
  32.     public function __construct(string $resourcebool $exists null)
  33.     {
  34.         $this->resource $resource;
  35.         if (null !== $exists) {
  36.             $this->exists = [$existsnull];
  37.         }
  38.     }
  39.     public function __toString(): string
  40.     {
  41.         return $this->resource;
  42.     }
  43.     public function getResource(): string
  44.     {
  45.         return $this->resource;
  46.     }
  47.     /**
  48.      * @throws \ReflectionException when a parent class/interface/trait is not found
  49.      */
  50.     public function isFresh(int $timestamp): bool
  51.     {
  52.         $loaded class_exists($this->resourcefalse) || interface_exists($this->resourcefalse) || trait_exists($this->resourcefalse);
  53.         if (null !== $exists = &self::$existsCache[$this->resource]) {
  54.             if ($loaded) {
  55.                 $exists = [truenull];
  56.             } elseif (>= $timestamp && !$exists[0] && null !== $exists[1]) {
  57.                 throw new \ReflectionException($exists[1]);
  58.             }
  59.         } elseif ([falsenull] === $exists = [$loadednull]) {
  60.             if (!self::$autoloadLevel++) {
  61.                 spl_autoload_register(__CLASS__.'::throwOnRequiredClass');
  62.             }
  63.             $autoloadedClass self::$autoloadedClass;
  64.             self::$autoloadedClass ltrim($this->resource'\\');
  65.             try {
  66.                 $exists[0] = class_exists($this->resource) || interface_exists($this->resourcefalse) || trait_exists($this->resourcefalse);
  67.             } catch (\Exception $e) {
  68.                 $exists[1] = $e->getMessage();
  69.                 try {
  70.                     self::throwOnRequiredClass($this->resource$e);
  71.                 } catch (\ReflectionException $e) {
  72.                     if (>= $timestamp) {
  73.                         throw $e;
  74.                     }
  75.                 }
  76.             } catch (\Throwable $e) {
  77.                 $exists[1] = $e->getMessage();
  78.                 throw $e;
  79.             } finally {
  80.                 self::$autoloadedClass $autoloadedClass;
  81.                 if (!--self::$autoloadLevel) {
  82.                     spl_autoload_unregister(__CLASS__.'::throwOnRequiredClass');
  83.                 }
  84.             }
  85.         }
  86.         $this->exists ??= $exists;
  87.         return $this->exists[0] xor !$exists[0];
  88.     }
  89.     /**
  90.      * @internal
  91.      */
  92.     public function __sleep(): array
  93.     {
  94.         if (null === $this->exists) {
  95.             $this->isFresh(0);
  96.         }
  97.         return ['resource''exists'];
  98.     }
  99.     /**
  100.      * @internal
  101.      */
  102.     public function __wakeup()
  103.     {
  104.         if (\is_bool($this->exists)) {
  105.             $this->exists = [$this->existsnull];
  106.         }
  107.     }
  108.     /**
  109.      * Throws a reflection exception when the passed class does not exist but is required.
  110.      *
  111.      * A class is considered "not required" when it's loaded as part of a "class_exists" or similar check.
  112.      *
  113.      * This function can be used as an autoload function to throw a reflection
  114.      * exception if the class was not found by previous autoload functions.
  115.      *
  116.      * A previous exception can be passed. In this case, the class is considered as being
  117.      * required totally, so if it doesn't exist, a reflection exception is always thrown.
  118.      * If it exists, the previous exception is rethrown.
  119.      *
  120.      * @throws \ReflectionException
  121.      *
  122.      * @internal
  123.      */
  124.     public static function throwOnRequiredClass(string $class\Exception $previous null)
  125.     {
  126.         // If the passed class is the resource being checked, we shouldn't throw.
  127.         if (null === $previous && self::$autoloadedClass === $class) {
  128.             return;
  129.         }
  130.         if (class_exists($classfalse) || interface_exists($classfalse) || trait_exists($classfalse)) {
  131.             if (null !== $previous) {
  132.                 throw $previous;
  133.             }
  134.             return;
  135.         }
  136.         if ($previous instanceof \ReflectionException) {
  137.             throw $previous;
  138.         }
  139.         $message sprintf('Class "%s" not found.'$class);
  140.         if (self::$autoloadedClass !== $class) {
  141.             $message substr_replace($messagesprintf(' while loading "%s"'self::$autoloadedClass), -10);
  142.         }
  143.         if (null !== $previous) {
  144.             $message $previous->getMessage();
  145.         }
  146.         $e = new \ReflectionException($message0$previous);
  147.         if (null !== $previous) {
  148.             throw $e;
  149.         }
  150.         $trace debug_backtrace();
  151.         $autoloadFrame = [
  152.             'function' => 'spl_autoload_call',
  153.             'args' => [$class],
  154.         ];
  155.         if (isset($trace[1])) {
  156.             $callerFrame $trace[1];
  157.             $i 2;
  158.         } elseif (false !== $i array_search($autoloadFrame$tracetrue)) {
  159.             $callerFrame $trace[++$i];
  160.         } else {
  161.             throw $e;
  162.         }
  163.         if (isset($callerFrame['function']) && !isset($callerFrame['class'])) {
  164.             switch ($callerFrame['function']) {
  165.                 case 'get_class_methods':
  166.                 case 'get_class_vars':
  167.                 case 'get_parent_class':
  168.                 case 'is_a':
  169.                 case 'is_subclass_of':
  170.                 case 'class_exists':
  171.                 case 'class_implements':
  172.                 case 'class_parents':
  173.                 case 'trait_exists':
  174.                 case 'defined':
  175.                 case 'interface_exists':
  176.                 case 'method_exists':
  177.                 case 'property_exists':
  178.                 case 'is_callable':
  179.                     return;
  180.             }
  181.             $props = [
  182.                 'file' => $callerFrame['file'] ?? null,
  183.                 'line' => $callerFrame['line'] ?? null,
  184.                 'trace' => \array_slice($trace$i),
  185.             ];
  186.             foreach ($props as $p => $v) {
  187.                 if (null !== $v) {
  188.                     $r = new \ReflectionProperty(\Exception::class, $p);
  189.                     $r->setValue($e$v);
  190.                 }
  191.             }
  192.         }
  193.         throw $e;
  194.     }
  195. }