vendor/symfony/var-exporter/Internal/LazyObjectState.php line 61

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\Hydrator as PublicHydrator;
  16. /**
  17.  * Keeps the state of lazy objects.
  18.  *
  19.  * As a micro-optimization, this class uses no type declarations.
  20.  *
  21.  * @internal
  22.  */
  23. class LazyObjectState
  24. {
  25.     public const STATUS_UNINITIALIZED_FULL = 1;
  26.     public const STATUS_UNINITIALIZED_PARTIAL = 2;
  27.     public const STATUS_INITIALIZED_FULL = 3;
  28.     public const STATUS_INITIALIZED_PARTIAL = 4;
  30.     /**
  31.      * @var array<string, true>
  32.      */
  33.     public readonly array $skippedProperties;
  35.     /**
  36.      * @var self::STATUS_*
  37.      */
  38.     public int $status = 0;
  40.     public object $realInstance;
  42.     public function __construct(public readonly \Closure|array $initializer, $skippedProperties = [])
  43.     {
  44.         $this->skippedProperties = $skippedProperties;
  45.         $this->status = \is_array($initializer) ? self::STATUS_UNINITIALIZED_PARTIAL : self::STATUS_UNINITIALIZED_FULL;
  46.     }
  48.     public function initialize($instance, $propertyName, $propertyScope)
  49.     {
  50.         if (self::STATUS_INITIALIZED_FULL === $this->status) {
  51.             return self::STATUS_INITIALIZED_FULL;
  52.         }
  54.         if (\is_array($this->initializer)) {
  55.             $class = $instance::class;
  56.             $propertyScope ??= $class;
  57.             $propertyScopes = Hydrator::$propertyScopes[$class];
  58.             $propertyScopes[$k = "\0$propertyScope\0$propertyName"] ?? $propertyScopes[$k = "\0*\0$propertyName"] ?? $k = $propertyName;
  60.             if ($initializer = $this->initializer[$k] ?? null) {
  61.                 $value = $initializer(...[$instance, $propertyName, $propertyScope, LazyObjectRegistry::$defaultProperties[$class][$k] ?? null]);
  62.                 $accessor = LazyObjectRegistry::$classAccessors[$propertyScope] ??= LazyObjectRegistry::getClassAccessors($propertyScope);
  63.                 $accessor['set']($instance, $propertyName, $value);
  65.                 return $this->status = self::STATUS_INITIALIZED_PARTIAL;
  66.             }
  68.             $status = self::STATUS_UNINITIALIZED_PARTIAL;
  70.             if ($initializer = $this->initializer["\0"] ?? null) {
  71.                 if (!\is_array($values = $initializer($instance, LazyObjectRegistry::$defaultProperties[$class]))) {
  72.                     throw new \TypeError(sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
  73.                 }
  74.                 $properties = (array) $instance;
  75.                 foreach ($values as $key => $value) {
  76.                     if ($k === $key) {
  77.                         $status = self::STATUS_INITIALIZED_PARTIAL;
  78.                     }
  79.                     if (!\array_key_exists($key, $properties) && [$scope, $name, $readonlyScope] = $propertyScopes[$key] ?? null) {
  80.                         $scope = $readonlyScope ?? ('*' !== $scope ? $scope : $class);
  81.                         $accessor = LazyObjectRegistry::$classAccessors[$scope] ??= LazyObjectRegistry::getClassAccessors($scope);
  82.                         $accessor['set']($instance, $name, $value);
  83.                     }
  84.                 }
  85.             }
  87.             return $status;
  88.         }
  90.         $this->status = self::STATUS_INITIALIZED_FULL;
  92.         try {
  93.             if ($defaultProperties = array_diff_key(LazyObjectRegistry::$defaultProperties[$instance::class], $this->skippedProperties)) {
  94.                 PublicHydrator::hydrate($instance, $defaultProperties);
  95.             }
  97.             ($this->initializer)($instance);
  98.         } catch (\Throwable $e) {
  99.             $this->status = self::STATUS_UNINITIALIZED_FULL;
  100.             $this->reset($instance);
  102.             throw $e;
  103.         }
  105.         return self::STATUS_INITIALIZED_FULL;
  106.     }
  108.     public function reset($instance): void
  109.     {
  110.         $class = $instance::class;
  111.         $propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
  112.         $skippedProperties = $this->skippedProperties;
  113.         $properties = (array) $instance;
  114.         $onlyProperties = \is_array($this->initializer) ? $this->initializer : null;
  116.         foreach ($propertyScopes as $key => [$scope, $name, $readonlyScope]) {
  117.             $propertyScopes[$k = "\0$scope\0$name"] ?? $propertyScopes[$k = "\0*\0$name"] ?? $k = $name;
  119.             if ($k === $key && (null !== $readonlyScope || !\array_key_exists($k, $properties))) {
  120.                 $skippedProperties[$k] = true;
  121.             }
  122.         }
  124.         foreach (LazyObjectRegistry::$classResetters[$class] as $reset) {
  125.             $reset($instance, $skippedProperties, $onlyProperties);
  126.         }
  128.         $this->status = self::STATUS_INITIALIZED_FULL === $this->status ? self::STATUS_UNINITIALIZED_FULL : self::STATUS_UNINITIALIZED_PARTIAL;
  129.     }
  130. }