vendor/symfony/var-exporter/LazyGhostTrait.php line 283

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;
  14. use Symfony\Component\Serializer\Attribute\Ignore;
  15. use Symfony\Component\VarExporter\Internal\Hydrator;
  16. use Symfony\Component\VarExporter\Internal\LazyObjectRegistry as Registry;
  17. use Symfony\Component\VarExporter\Internal\LazyObjectState;
  18. use Symfony\Component\VarExporter\Internal\LazyObjectTrait;
  20. trait LazyGhostTrait
  21. {
  22. use LazyObjectTrait;
  24. /**
  25. * Creates a lazy-loading ghost instance.
  26. *
  27. * Skipped properties should be indexed by their array-cast identifier, see
  28. * https://php.net/manual/language.types.array#language.types.array.casting
  29. *
  30. * @param (\Closure(static):void $initializer The closure should initialize the object it receives as argument
  31. * @param array<string, true>|null $skippedProperties An array indexed by the properties to skip, a.k.a. the ones
  32. * that the initializer doesn't initialize, if any
  33. * @param static|null $instance
  34. */
  35. public static function createLazyGhost(\Closure|array $initializer, ?array $skippedProperties = null, ?object $instance = null): static
  36. {
  37. if (\is_array($initializer)) {
  38. trigger_deprecation('symfony/var-exporter', '6.4', 'Per-property lazy-initializers are deprecated and won\'t be supported anymore in 7.0, use an object initializer instead.');
  39. }
  41. $onlyProperties = null === $skippedProperties && \is_array($initializer) ? $initializer : null;
  43. if (self::class !== $class = $instance ? $instance::class : static::class) {
  44. $skippedProperties["\0".self::class."\0lazyObjectState"] = true;
  45. } elseif (\defined($class.'::LAZY_OBJECT_PROPERTY_SCOPES')) {
  46. Hydrator::$propertyScopes[$class] ??= $class::LAZY_OBJECT_PROPERTY_SCOPES;
  47. }
  49. $instance ??= (Registry::$classReflectors[$class] ??= new \ReflectionClass($class))->newInstanceWithoutConstructor();
  50. Registry::$defaultProperties[$class] ??= (array) $instance;
  51. $instance->lazyObjectState = new LazyObjectState($initializer, $skippedProperties ??= []);
  53. foreach (Registry::$classResetters[$class] ??= Registry::getClassResetters($class) as $reset) {
  54. $reset($instance, $skippedProperties, $onlyProperties);
  55. }
  57. return $instance;
  58. }
  60. /**
  61. * Returns whether the object is initialized.
  62. *
  63. * @param $partial Whether partially initialized objects should be considered as initialized
  64. */
  65. #[Ignore]
  66. public function isLazyObjectInitialized(bool $partial = false): bool
  67. {
  68. if (!$state = $this->lazyObjectState ?? null) {
  69. return true;
  70. }
  72. if (!\is_array($state->initializer)) {
  73. return LazyObjectState::STATUS_INITIALIZED_FULL === $state->status;
  74. }
  76. $class = $this::class;
  77. $properties = (array) $this;
  79. if ($partial) {
  80. return (bool) array_intersect_key($state->initializer, $properties);
  81. }
  83. $propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
  84. foreach ($state->initializer as $key => $initializer) {
  85. if (!\array_key_exists($key, $properties) && isset($propertyScopes[$key])) {
  86. return false;
  87. }
  88. }
  90. return true;
  91. }
  93. /**
  94. * Forces initialization of a lazy object and returns it.
  95. */
  96. public function initializeLazyObject(): static
  97. {
  98. if (!$state = $this->lazyObjectState ?? null) {
  99. return $this;
  100. }
  102. if (!\is_array($state->initializer)) {
  103. if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  104. $state->initialize($this, '', null);
  105. }
  107. return $this;
  108. }
  110. $values = isset($state->initializer["\0"]) ? null : [];
  112. $class = $this::class;
  113. $properties = (array) $this;
  114. $propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
  115. foreach ($state->initializer as $key => $initializer) {
  116. if (\array_key_exists($key, $properties) || ![$scope, $name, $readonlyScope] = $propertyScopes[$key] ?? null) {
  117. continue;
  118. }
  119. $scope = $readonlyScope ?? ('*' !== $scope ? $scope : $class);
  121. if (null === $values) {
  122. if (!\is_array($values = ($state->initializer["\0"])($this, Registry::$defaultProperties[$class]))) {
  123. throw new \TypeError(sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
  124. }
  126. if (\array_key_exists($key, $properties = (array) $this)) {
  127. continue;
  128. }
  129. }
  131. if (\array_key_exists($key, $values)) {
  132. $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  133. $accessor['set']($this, $name, $properties[$key] = $values[$key]);
  134. } else {
  135. $state->initialize($this, $name, $scope);
  136. $properties = (array) $this;
  137. }
  138. }
  140. return $this;
  141. }
  143. /**
  144. * @return bool Returns false when the object cannot be reset, ie when it's not a lazy object
  145. */
  146. public function resetLazyObject(): bool
  147. {
  148. if (!$state = $this->lazyObjectState ?? null) {
  149. return false;
  150. }
  152. if (LazyObjectState::STATUS_UNINITIALIZED_FULL !== $state->status) {
  153. $state->reset($this);
  154. }
  156. return true;
  157. }
  159. public function &__get($name): mixed
  160. {
  161. $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  162. $scope = null;
  164. if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  165. $scope = Registry::getScope($propertyScopes, $class, $name);
  166. $state = $this->lazyObjectState ?? null;
  168. if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))) {
  169. if (LazyObjectState::STATUS_INITIALIZED_FULL === $state->status) {
  170. // Work around php/php-src#12695
  171. $property = null === $scope ? $name : "\0$scope\0$name";
  172. $property = $propertyScopes[$property][3]
  173. ?? Hydrator::$propertyScopes[$this::class][$property][3] = new \ReflectionProperty($scope ?? $class, $name);
  174. } else {
  175. $property = null;
  176. }
  178. if ($property?->isInitialized($this) ?? LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $readonlyScope ?? $scope)) {
  179. goto get_in_scope;
  180. }
  181. }
  182. }
  184. if ($parent = (Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['get']) {
  185. if (2 === $parent) {
  186. return parent::__get($name);
  187. }
  188. $value = parent::__get($name);
  190. return $value;
  191. }
  193. if (null === $class) {
  194. $frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
  195. trigger_error(sprintf('Undefined property: %s::$%s in %s on line %s', $this::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
  196. }
  198. get_in_scope:
  200. try {
  201. if (null === $scope) {
  202. if (null === $readonlyScope) {
  203. return $this->$name;
  204. }
  205. $value = $this->$name;
  207. return $value;
  208. }
  209. $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  211. return $accessor['get']($this, $name, null !== $readonlyScope);
  212. } catch (\Error $e) {
  213. if (\Error::class !== $e::class || !str_starts_with($e->getMessage(), 'Cannot access uninitialized non-nullable property')) {
  214. throw $e;
  215. }
  217. try {
  218. if (null === $scope) {
  219. $this->$name = [];
  221. return $this->$name;
  222. }
  224. $accessor['set']($this, $name, []);
  226. return $accessor['get']($this, $name, null !== $readonlyScope);
  227. } catch (\Error) {
  228. if (preg_match('/^Cannot access uninitialized non-nullable property ([^ ]++) by reference$/', $e->getMessage(), $matches)) {
  229. throw new \Error('Typed property '.$matches[1].' must not be accessed before initialization', $e->getCode(), $e->getPrevious());
  230. }
  232. throw $e;
  233. }
  234. }
  235. }
  237. public function __set($name, $value): void
  238. {
  239. $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  240. $scope = null;
  242. if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  243. $scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
  244. $state = $this->lazyObjectState ?? null;
  246. if ($state && ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"]))
  247. && LazyObjectState::STATUS_INITIALIZED_FULL !== $state->status
  248. ) {
  249. if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  250. $state->initialize($this, $name, $readonlyScope ?? $scope);
  251. }
  252. goto set_in_scope;
  253. }
  254. }
  256. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['set']) {
  257. parent::__set($name, $value);
  259. return;
  260. }
  262. set_in_scope:
  264. if (null === $scope) {
  265. $this->$name = $value;
  266. } else {
  267. $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  268. $accessor['set']($this, $name, $value);
  269. }
  270. }
  272. public function __isset($name): bool
  273. {
  274. $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  275. $scope = null;
  277. if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  278. $scope = Registry::getScope($propertyScopes, $class, $name);
  279. $state = $this->lazyObjectState ?? null;
  281. if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))
  282. && LazyObjectState::STATUS_INITIALIZED_FULL !== $state->status
  283. && LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $readonlyScope ?? $scope)
  284. ) {
  285. goto isset_in_scope;
  286. }
  287. }
  289. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['isset']) {
  290. return parent::__isset($name);
  291. }
  293. isset_in_scope:
  295. if (null === $scope) {
  296. return isset($this->$name);
  297. }
  298. $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  300. return $accessor['isset']($this, $name);
  301. }
  303. public function __unset($name): void
  304. {
  305. $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  306. $scope = null;
  308. if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  309. $scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
  310. $state = $this->lazyObjectState ?? null;
  312. if ($state && ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"]))
  313. && LazyObjectState::STATUS_INITIALIZED_FULL !== $state->status
  314. ) {
  315. if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  316. $state->initialize($this, $name, $readonlyScope ?? $scope);
  317. }
  318. goto unset_in_scope;
  319. }
  320. }
  322. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['unset']) {
  323. parent::__unset($name);
  325. return;
  326. }
  328. unset_in_scope:
  330. if (null === $scope) {
  331. unset($this->$name);
  332. } else {
  333. $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  334. $accessor['unset']($this, $name);
  335. }
  336. }
  338. public function __clone(): void
  339. {
  340. if ($state = $this->lazyObjectState ?? null) {
  341. $this->lazyObjectState = clone $state;
  342. }
  344. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['clone']) {
  345. parent::__clone();
  346. }
  347. }
  349. public function __serialize(): array
  350. {
  351. $class = self::class;
  353. if ((Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['serialize']) {
  354. $properties = parent::__serialize();
  355. } else {
  356. $this->initializeLazyObject();
  357. $properties = (array) $this;
  358. }
  359. unset($properties["\0$class\0lazyObjectState"]);
  361. if (Registry::$parentMethods[$class]['serialize'] || !Registry::$parentMethods[$class]['sleep']) {
  362. return $properties;
  363. }
  365. $scope = get_parent_class($class);
  366. $data = [];
  368. foreach (parent::__sleep() as $name) {
  369. $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$class\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;
  371. if (null === $k) {
  372. trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
  373. } else {
  374. $data[$k] = $value;
  375. }
  376. }
  378. return $data;
  379. }
  381. public function __destruct()
  382. {
  383. $state = $this->lazyObjectState ?? null;
  385. if ($state && \in_array($state->status, [LazyObjectState::STATUS_UNINITIALIZED_FULL, LazyObjectState::STATUS_UNINITIALIZED_PARTIAL], true)) {
  386. return;
  387. }
  389. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {
  390. parent::__destruct();
  391. }
  392. }
  394. #[Ignore]
  395. private function setLazyObjectAsInitialized(bool $initialized): void
  396. {
  397. $state = $this->lazyObjectState ?? null;
  399. if ($state && !\is_array($state->initializer)) {
  400. $state->status = $initialized ? LazyObjectState::STATUS_INITIALIZED_FULL : LazyObjectState::STATUS_UNINITIALIZED_FULL;
  401. }
  402. }
  403. }