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

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 array $reflectors = [];
  25. public static array $prototypes = [];
  26. public static array $factories = [];
  27. public static array $cloneable = [];
  28. public static array $instantiableWithoutConstructor = [];
  30. public function __construct(
  31. public readonly array $classes,
  32. ) {
  33. }
  35. public static function unserialize($objects, $serializables)
  36. {
  37. $unserializeCallback = ini_set('unserialize_callback_func', __CLASS__.'::getClassReflector');
  39. try {
  40. foreach ($serializables as $k => $v) {
  41. $objects[$k] = unserialize($v, ['allowed_classes' => true]);
  42. }
  43. } finally {
  44. ini_set('unserialize_callback_func', $unserializeCallback);
  45. }
  47. return $objects;
  48. }
  50. public static function p($class)
  51. {
  52. self::getClassReflector($class, true, true);
  54. return self::$prototypes[$class];
  55. }
  57. public static function f($class)
  58. {
  59. $reflector = self::$reflectors[$class] ??= self::getClassReflector($class, true, false);
  61. return self::$factories[$class] = $reflector->newInstanceWithoutConstructor(...);
  62. }
  64. public static function getClassReflector($class, $instantiableWithoutConstructor = false, $cloneable = null)
  65. {
  66. if (!($isClass = class_exists($class)) && !interface_exists($class, false) && !trait_exists($class, false)) {
  67. throw new ClassNotFoundException($class);
  68. }
  69. $reflector = new \ReflectionClass($class);
  71. if ($instantiableWithoutConstructor) {
  72. $proto = $reflector->newInstanceWithoutConstructor();
  73. } elseif (!$isClass || $reflector->isAbstract()) {
  74. throw new NotInstantiableTypeException($class);
  75. } elseif ($reflector->name !== $class) {
  76. $reflector = self::$reflectors[$name = $reflector->name] ??= self::getClassReflector($name, false, $cloneable);
  77. self::$cloneable[$class] = self::$cloneable[$name];
  78. self::$instantiableWithoutConstructor[$class] = self::$instantiableWithoutConstructor[$name];
  79. self::$prototypes[$class] = self::$prototypes[$name];
  81. return $reflector;
  82. } else {
  83. try {
  84. $proto = $reflector->newInstanceWithoutConstructor();
  85. $instantiableWithoutConstructor = true;
  86. } catch (\ReflectionException) {
  87. $proto = $reflector->implementsInterface('Serializable') && !method_exists($class, '__unserialize') ? 'C:' : 'O:';
  88. if ('C:' === $proto && !$reflector->getMethod('unserialize')->isInternal()) {
  89. $proto = null;
  90. } else {
  91. try {
  92. $proto = @unserialize($proto.\strlen($class).':"'.$class.'":0:{}', ['allowed_classes' => true]);
  93. } catch (\Exception $e) {
  94. if (method_exists($class, '__unserialize')) {
  95. // The class cannot be instantiated empty but defines __serialize()/__unserialize();
  96. // it'll be reconstructed by serializing the whole value.
  97. $proto = null;
  98. } elseif (__FILE__ !== $e->getFile()) {
  99. throw $e;
  100. } else {
  101. throw new NotInstantiableTypeException($class, $e);
  102. }
  103. }
  104. if (false === $proto) {
  105. if (!method_exists($class, '__unserialize')) {
  106. throw new NotInstantiableTypeException($class);
  107. }
  108. $proto = null;
  109. }
  110. }
  111. }
  112. if (null !== $proto && !$proto instanceof \Throwable && !$proto instanceof \Serializable && !method_exists($class, '__sleep') && !method_exists($class, '__serialize')) {
  113. try {
  114. serialize($proto);
  115. } catch (\Exception $e) {
  116. throw new NotInstantiableTypeException($class, $e);
  117. }
  118. }
  119. }
  121. if (null === $cloneable) {
  122. if (($proto instanceof \Reflector || $proto instanceof \ReflectionGenerator || $proto instanceof \ReflectionType || $proto instanceof \IteratorIterator || $proto instanceof \RecursiveIteratorIterator) && (!$proto instanceof \Serializable && !method_exists($proto, '__wakeup') && !method_exists($class, '__unserialize'))) {
  123. throw new NotInstantiableTypeException($class);
  124. }
  126. $cloneable = $reflector->isCloneable() && !$reflector->hasMethod('__clone');
  127. }
  129. self::$cloneable[$class] = $cloneable;
  130. self::$instantiableWithoutConstructor[$class] = $instantiableWithoutConstructor;
  131. self::$prototypes[$class] = $proto;
  133. if ($proto instanceof \Throwable) {
  134. static $setTrace;
  136. if (null === $setTrace) {
  137. $setTrace = [
  138. new \ReflectionProperty(\Error::class, 'trace'),
  139. new \ReflectionProperty(\Exception::class, 'trace'),
  140. ];
  141. $setTrace[0] = $setTrace[0]->setValue(...);
  142. $setTrace[1] = $setTrace[1]->setValue(...);
  143. }
  145. $setTrace[$proto instanceof \Exception]($proto, []);
  146. }
  148. return $reflector;
  149. }
  150. }