vendor/symfony/var-exporter/Internal/Registry.php line 54

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\VarExporter\Internal;
  14. use Symfony\Component\VarExporter\Exception\ClassNotFoundException;
  15. use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException;
  17. /**
  18.  * @author Nicolas Grekas <p@tchwork.com>
  19.  *
  20.  * @internal
  21.  */
  22. class Registry
  23. {
  24.     public static $reflectors = array();
  25.     public static $prototypes = array();
  26.     public static $factories = array();
  27.     public static $cloneable = array();
  28.     public static $instantiableWithoutConstructor = array();
  30.     public function __construct(array $classes)
  31.     {
  32.         foreach ($classes as $i => $class) {
  33.             $this->$i = $class;
  34.         }
  35.     }
  37.     public static function unserialize($objects, $serializables)
  38.     {
  39.         $unserializeCallback = ini_set('unserialize_callback_func', __CLASS__.'::getClassReflector');
  41.         try {
  42.             foreach ($serializables as $k => $v) {
  43.                 $objects[$k] = unserialize($v);
  44.             }
  45.         } finally {
  46.             ini_set('unserialize_callback_func', $unserializeCallback);
  47.         }
  49.         return $objects;
  50.     }
  52.     public static function p($class)
  53.     {
  54.         self::getClassReflector($class, true, true);
  56.         return self::$prototypes[$class];
  57.     }
  59.     public static function f($class)
  60.     {
  61.         $reflector = self::$reflectors[$class] ?? self::getClassReflector($class, true, false);
  63.         return self::$factories[$class] = \Closure::fromCallable(array($reflector, 'newInstanceWithoutConstructor'));
  64.     }
  66.     public static function getClassReflector($class, $instantiableWithoutConstructor = false, $cloneable = null)
  67.     {
  68.         if (!\class_exists($class) && !\interface_exists($class, false) && !\trait_exists($class, false)) {
  69.             throw new ClassNotFoundException($class);
  70.         }
  71.         $reflector = new \ReflectionClass($class);
  73.         if ($instantiableWithoutConstructor) {
  74.             $proto = $reflector->newInstanceWithoutConstructor();
  75.         } elseif (!$reflector->isInstantiable()) {
  76.             throw new NotInstantiableTypeException($class);
  77.         } elseif ($reflector->name !== $class) {
  78.             $reflector = self::$reflectors[$name = $reflector->name] ?? self::getClassReflector($name, $instantiableWithoutConstructor, $cloneable);
  79.             self::$cloneable[$class] = self::$cloneable[$name];
  80.             self::$instantiableWithoutConstructor[$class] = self::$instantiableWithoutConstructor[$name];
  81.             self::$prototypes[$class] = self::$prototypes[$name];
  83.             return self::$reflectors[$class] = $reflector;
  84.         } else {
  85.             try {
  86.                 $proto = $reflector->newInstanceWithoutConstructor();
  87.                 $instantiableWithoutConstructor = true;
  88.             } catch (\ReflectionException $e) {
  89.                 $proto = $reflector->implementsInterface('Serializable') ? 'C:' : 'O:';
  90.                 if ('C:' === $proto && !$reflector->getMethod('unserialize')->isInternal()) {
  91.                     $proto = null;
  92.                 } elseif (false === $proto = @unserialize($proto.\strlen($class).':"'.$class.'":0:{}')) {
  93.                     throw new NotInstantiableTypeException($class);
  94.                 }
  95.             }
  96.             if (null !== $proto && !$proto instanceof \Throwable && !$proto instanceof \Serializable && !\method_exists($class, '__sleep')) {
  97.                 try {
  98.                     serialize($proto);
  99.                 } catch (\Exception $e) {
  100.                     throw new NotInstantiableTypeException($class, $e);
  101.                 }
  102.             }
  103.         }
  105.         if (null === $cloneable) {
  106.             if (($proto instanceof \Reflector || $proto instanceof \ReflectionGenerator || $proto instanceof \ReflectionType || $proto instanceof \IteratorIterator || $proto instanceof \RecursiveIteratorIterator) && (!$proto instanceof \Serializable && !\method_exists($proto, '__wakeup'))) {
  107.                 throw new NotInstantiableTypeException($class);
  108.             }
  110.             $cloneable = $reflector->isCloneable() && !$reflector->hasMethod('__clone');
  111.         }
  113.         self::$cloneable[$class] = $cloneable;
  114.         self::$instantiableWithoutConstructor[$class] = $instantiableWithoutConstructor;
  115.         self::$prototypes[$class] = $proto;
  117.         if ($proto instanceof \Throwable) {
  118.             static $setTrace;
  120.             if (null === $setTrace) {
  121.                 $setTrace = array(
  122.                     new \ReflectionProperty(\Error::class, 'trace'),
  123.                     new \ReflectionProperty(\Exception::class, 'trace'),
  124.                 );
  125.                 $setTrace[0]->setAccessible(true);
  126.                 $setTrace[1]->setAccessible(true);
  127.                 $setTrace[0] = \Closure::fromCallable(array($setTrace[0], 'setValue'));
  128.                 $setTrace[1] = \Closure::fromCallable(array($setTrace[1], 'setValue'));
  129.             }
  131.             $setTrace[$proto instanceof \Exception]($proto, array());
  132.         }
  134.         return self::$reflectors[$class] = $reflector;
  135.     }
  136. }