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

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, $writeScope] = $propertyScopes[$key] ?? null) {
  117. continue;
  118. }
  119. $scope = $writeScope ?? $scope;
  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;
  163. $notByRef = 0;
  165. if ([$class, , $writeScope, $access] = $propertyScopes[$name] ?? null) {
  166. $scope = Registry::getScopeForRead($propertyScopes, $class, $name);
  167. $state = $this->lazyObjectState ?? null;
  169. if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))) {
  170. $notByRef = $access & Hydrator::PROPERTY_NOT_BY_REF;
  172. if (LazyObjectState::STATUS_INITIALIZED_FULL === $state->status) {
  173. // Work around php/php-src#12695
  174. $property = null === $scope ? $name : "\0$scope\0$name";
  175. $property = $propertyScopes[$property][4]
  176. ?? Hydrator::$propertyScopes[$this::class][$property][4] = new \ReflectionProperty($scope ?? $class, $name);
  177. } else {
  178. $property = null;
  179. }
  180. if (\PHP_VERSION_ID >= 80400 && !$notByRef && ($access >> 2) & \ReflectionProperty::IS_PRIVATE_SET) {
  181. $scope ??= $writeScope;
  182. }
  184. if ($property?->isInitialized($this) ?? LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $writeScope ?? $scope)) {
  185. goto get_in_scope;
  186. }
  187. }
  188. }
  190. if ($parent = (Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['get']) {
  191. if (2 === $parent) {
  192. return parent::__get($name);
  193. }
  194. $value = parent::__get($name);
  196. return $value;
  197. }
  199. if (null === $class) {
  200. $frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
  201. trigger_error(\sprintf('Undefined property: %s::$%s in %s on line %s', $this::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
  202. }
  204. get_in_scope:
  206. try {
  207. if (null === $scope) {
  208. if (!$notByRef) {
  209. return $this->$name;
  210. }
  211. $value = $this->$name;
  213. return $value;
  214. }
  215. $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  217. return $accessor['get']($this, $name, $notByRef);
  218. } catch (\Error $e) {
  219. if (\Error::class !== $e::class || !str_starts_with($e->getMessage(), 'Cannot access uninitialized non-nullable property')) {
  220. throw $e;
  221. }
  223. try {
  224. if (null === $scope) {
  225. $this->$name = [];
  227. return $this->$name;
  228. }
  230. $accessor['set']($this, $name, []);
  232. return $accessor['get']($this, $name, $notByRef);
  233. } catch (\Error) {
  234. if (preg_match('/^Cannot access uninitialized non-nullable property ([^ ]++) by reference$/', $e->getMessage(), $matches)) {
  235. throw new \Error('Typed property '.$matches[1].' must not be accessed before initialization', $e->getCode(), $e->getPrevious());
  236. }
  238. throw $e;
  239. }
  240. }
  241. }
  243. public function __set($name, $value): void
  244. {
  245. $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  246. $scope = null;
  248. if ([$class, , $writeScope, $access] = $propertyScopes[$name] ?? null) {
  249. $scope = Registry::getScopeForWrite($propertyScopes, $class, $name, $access >> 2);
  250. $state = $this->lazyObjectState ?? null;
  252. if ($state && ($writeScope === $scope || isset($propertyScopes["\0$scope\0$name"]))
  253. && LazyObjectState::STATUS_INITIALIZED_FULL !== $state->status
  254. ) {
  255. if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  256. $state->initialize($this, $name, $writeScope ?? $scope);
  257. }
  258. goto set_in_scope;
  259. }
  260. }
  262. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['set']) {
  263. parent::__set($name, $value);
  265. return;
  266. }
  268. set_in_scope:
  270. if (null === $scope) {
  271. $this->$name = $value;
  272. } else {
  273. $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  274. $accessor['set']($this, $name, $value);
  275. }
  276. }
  278. public function __isset($name): bool
  279. {
  280. $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  281. $scope = null;
  283. if ([$class, , $writeScope] = $propertyScopes[$name] ?? null) {
  284. $scope = Registry::getScopeForRead($propertyScopes, $class, $name);
  285. $state = $this->lazyObjectState ?? null;
  287. if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))
  288. && LazyObjectState::STATUS_INITIALIZED_FULL !== $state->status
  289. && LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $writeScope ?? $scope)
  290. ) {
  291. goto isset_in_scope;
  292. }
  293. }
  295. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['isset']) {
  296. return parent::__isset($name);
  297. }
  299. isset_in_scope:
  301. if (null === $scope) {
  302. return isset($this->$name);
  303. }
  304. $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  306. return $accessor['isset']($this, $name);
  307. }
  309. public function __unset($name): void
  310. {
  311. $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  312. $scope = null;
  314. if ([$class, , $writeScope, $access] = $propertyScopes[$name] ?? null) {
  315. $scope = Registry::getScopeForWrite($propertyScopes, $class, $name, $access >> 2);
  316. $state = $this->lazyObjectState ?? null;
  318. if ($state && ($writeScope === $scope || isset($propertyScopes["\0$scope\0$name"]))
  319. && LazyObjectState::STATUS_INITIALIZED_FULL !== $state->status
  320. ) {
  321. if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  322. $state->initialize($this, $name, $writeScope ?? $scope);
  323. }
  324. goto unset_in_scope;
  325. }
  326. }
  328. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['unset']) {
  329. parent::__unset($name);
  331. return;
  332. }
  334. unset_in_scope:
  336. if (null === $scope) {
  337. unset($this->$name);
  338. } else {
  339. $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  340. $accessor['unset']($this, $name);
  341. }
  342. }
  344. public function __clone(): void
  345. {
  346. if ($state = $this->lazyObjectState ?? null) {
  347. $this->lazyObjectState = clone $state;
  348. }
  350. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['clone']) {
  351. parent::__clone();
  352. }
  353. }
  355. public function __serialize(): array
  356. {
  357. $class = self::class;
  359. if ((Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['serialize']) {
  360. $properties = parent::__serialize();
  361. } else {
  362. $this->initializeLazyObject();
  363. $properties = (array) $this;
  364. }
  365. unset($properties["\0$class\0lazyObjectState"]);
  367. if (Registry::$parentMethods[$class]['serialize'] || !Registry::$parentMethods[$class]['sleep']) {
  368. return $properties;
  369. }
  371. $scope = get_parent_class($class);
  372. $data = [];
  374. foreach (parent::__sleep() as $name) {
  375. $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$class\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;
  377. if (null === $k) {
  378. trigger_error(\sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
  379. } else {
  380. $data[$k] = $value;
  381. }
  382. }
  384. return $data;
  385. }
  387. public function __destruct()
  388. {
  389. $state = $this->lazyObjectState ?? null;
  391. if ($state && \in_array($state->status, [LazyObjectState::STATUS_UNINITIALIZED_FULL, LazyObjectState::STATUS_UNINITIALIZED_PARTIAL], true)) {
  392. return;
  393. }
  395. if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {
  396. parent::__destruct();
  397. }
  398. }
  400. #[Ignore]
  401. private function setLazyObjectAsInitialized(bool $initialized): void
  402. {
  403. $state = $this->lazyObjectState ?? null;
  405. if ($state && !\is_array($state->initializer)) {
  406. $state->status = $initialized ? LazyObjectState::STATUS_INITIALIZED_FULL : LazyObjectState::STATUS_UNINITIALIZED_FULL;
  407. }
  408. }
  409. }