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

  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\VarExporter\Internal\Hydrator;
  15. use Symfony\Component\VarExporter\Internal\LazyObjectRegistry as Registry;
  16. use Symfony\Component\VarExporter\Internal\LazyObjectState;
  17. use Symfony\Component\VarExporter\Internal\LazyObjectTrait;
  19. trait LazyGhostTrait
  20. {
  21.     use LazyObjectTrait;
  23.     /**
  24.      * Creates a lazy-loading ghost instance.
  25.      *
  26.      * When the initializer is a closure, it should initialize all properties at
  27.      * once and is given the instance to initialize as argument.
  28.      *
  29.      * When the initializer is an array of closures, it should be indexed by
  30.      * properties and closures should accept 4 arguments: the instance to
  31.      * initialize, the property to initialize, its write-scope, and its default
  32.      * value. Each closure should return the value of the corresponding property.
  33.      * The special "\0" key can be used to define a closure that returns all
  34.      * properties at once when full-initialization is needed; it takes the
  35.      * instance and its default properties as arguments.
  36.      *
  37.      * Properties should be indexed by their array-cast name, see
  38.      * https://php.net/manual/language.types.array#language.types.array.casting
  39.      *
  40.      * @param (\Closure(static):void
  41.      *        |array<string, \Closure(static, string, ?string, mixed):mixed>
  42.      *        |array{"\0": \Closure(static, array<string, mixed>):array<string, mixed>}) $initializer
  43.      * @param array<string, true>|null $skippedProperties An array indexed by the properties to skip, aka the ones
  44.      *                                                    that the initializer doesn't set when its a closure
  45.      * @param static|null              $instance
  46.      */
  47.     public static function createLazyGhost(\Closure|array $initializer, array $skippedProperties = null, object $instance = null): static
  48.     {
  49.         $onlyProperties = null === $skippedProperties && \is_array($initializer) ? $initializer : null;
  51.         if (self::class !== $class = $instance ? $instance::class : static::class) {
  52.             $skippedProperties["\0".self::class."\0lazyObjectState"] = true;
  53.         } elseif (\defined($class.'::LAZY_OBJECT_PROPERTY_SCOPES')) {
  54.             Hydrator::$propertyScopes[$class] ??= $class::LAZY_OBJECT_PROPERTY_SCOPES;
  55.         }
  57.         $instance ??= (Registry::$classReflectors[$class] ??= new \ReflectionClass($class))->newInstanceWithoutConstructor();
  58.         Registry::$defaultProperties[$class] ??= (array) $instance;
  59.         $instance->lazyObjectState = new LazyObjectState($initializer, $skippedProperties ??= []);
  61.         foreach (Registry::$classResetters[$class] ??= Registry::getClassResetters($class) as $reset) {
  62.             $reset($instance, $skippedProperties, $onlyProperties);
  63.         }
  65.         return $instance;
  66.     }
  68.     /**
  69.      * Returns whether the object is initialized.
  70.      *
  71.      * @param $partial Whether partially initialized objects should be considered as initialized
  72.      */
  73.     public function isLazyObjectInitialized(bool $partial = false): bool
  74.     {
  75.         if (!$state = $this->lazyObjectState ?? null) {
  76.             return true;
  77.         }
  79.         if (!\is_array($state->initializer)) {
  80.             return LazyObjectState::STATUS_INITIALIZED_FULL === $state->status;
  81.         }
  83.         $class = $this::class;
  84.         $properties = (array) $this;
  86.         if ($partial) {
  87.             return (bool) array_intersect_key($state->initializer, $properties);
  88.         }
  90.         $propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
  91.         foreach ($state->initializer as $key => $initializer) {
  92.             if (!\array_key_exists($key, $properties) && isset($propertyScopes[$key])) {
  93.                 return false;
  94.             }
  95.         }
  97.         return true;
  98.     }
  100.     /**
  101.      * Forces initialization of a lazy object and returns it.
  102.      */
  103.     public function initializeLazyObject(): static
  104.     {
  105.         if (!$state = $this->lazyObjectState ?? null) {
  106.             return $this;
  107.         }
  109.         if (!\is_array($state->initializer)) {
  110.             if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  111.                 $state->initialize($this, '', null);
  112.             }
  114.             return $this;
  115.         }
  117.         $values = isset($state->initializer["\0"]) ? null : [];
  119.         $class = $this::class;
  120.         $properties = (array) $this;
  121.         $propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
  122.         foreach ($state->initializer as $key => $initializer) {
  123.             if (\array_key_exists($key, $properties) || ![$scope, $name, $readonlyScope] = $propertyScopes[$key] ?? null) {
  124.                 continue;
  125.             }
  126.             $scope = $readonlyScope ?? ('*' !== $scope ? $scope : $class);
  128.             if (null === $values) {
  129.                 if (!\is_array($values = ($state->initializer["\0"])($this, Registry::$defaultProperties[$class]))) {
  130.                     throw new \TypeError(sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
  131.                 }
  133.                 if (\array_key_exists($key, $properties = (array) $this)) {
  134.                     continue;
  135.                 }
  136.             }
  138.             if (\array_key_exists($key, $values)) {
  139.                 $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  140.                 $accessor['set']($this, $name, $properties[$key] = $values[$key]);
  141.             } else {
  142.                 $state->initialize($this, $name, $scope);
  143.                 $properties = (array) $this;
  144.             }
  145.         }
  147.         return $this;
  148.     }
  150.     /**
  151.      * @return bool Returns false when the object cannot be reset, ie when it's not a lazy object
  152.      */
  153.     public function resetLazyObject(): bool
  154.     {
  155.         if (!$state = $this->lazyObjectState ?? null) {
  156.             return false;
  157.         }
  159.         if (LazyObjectState::STATUS_UNINITIALIZED_FULL !== $state->status) {
  160.             $state->reset($this);
  161.         }
  163.         return true;
  164.     }
  166.     public function &__get($name): mixed
  167.     {
  168.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  169.         $scope = null;
  171.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  172.             $scope = Registry::getScope($propertyScopes, $class, $name);
  173.             $state = $this->lazyObjectState ?? null;
  175.             if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))
  176.                 && LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $readonlyScope ?? $scope)
  177.             ) {
  178.                 goto get_in_scope;
  179.             }
  180.         }
  182.         if ($parent = (Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['get']) {
  183.             if (2 === $parent) {
  184.                 return parent::__get($name);
  185.             }
  186.             $value = parent::__get($name);
  188.             return $value;
  189.         }
  191.         if (null === $class) {
  192.             $frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
  193.             trigger_error(sprintf('Undefined property: %s::$%s in %s on line %s', $this::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
  194.         }
  196.         get_in_scope:
  198.         try {
  199.             if (null === $scope) {
  200.                 if (null === $readonlyScope) {
  201.                     return $this->$name;
  202.                 }
  203.                 $value = $this->$name;
  205.                 return $value;
  206.             }
  207.             $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  209.             return $accessor['get']($this, $name, null !== $readonlyScope);
  210.         } catch (\Error $e) {
  211.             if (\Error::class !== $e::class || !str_starts_with($e->getMessage(), 'Cannot access uninitialized non-nullable property')) {
  212.                 throw $e;
  213.             }
  215.             try {
  216.                 if (null === $scope) {
  217.                     $this->$name = [];
  219.                     return $this->$name;
  220.                 }
  222.                 $accessor['set']($this, $name, []);
  224.                 return $accessor['get']($this, $name, null !== $readonlyScope);
  225.             } catch (\Error) {
  226.                 throw $e;
  227.             }
  228.         }
  229.     }
  231.     public function __set($name, $value): void
  232.     {
  233.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  234.         $scope = null;
  235.         $state = null;
  237.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  238.             $scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
  239.             $state = $this->lazyObjectState ?? null;
  241.             if ($state && ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"]))) {
  242.                 if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  243.                     $state->initialize($this, $name, $readonlyScope ?? $scope);
  244.                 }
  245.                 goto set_in_scope;
  246.             }
  247.         }
  249.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['set']) {
  250.             parent::__set($name, $value);
  252.             return;
  253.         }
  255.         set_in_scope:
  257.         if (null === $scope) {
  258.             $this->$name = $value;
  259.         } else {
  260.             $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  261.             $accessor['set']($this, $name, $value);
  262.         }
  263.     }
  265.     public function __isset($name): bool
  266.     {
  267.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  268.         $scope = null;
  270.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  271.             $scope = Registry::getScope($propertyScopes, $class, $name);
  272.             $state = $this->lazyObjectState ?? null;
  274.             if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))
  275.                 && LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $readonlyScope ?? $scope)
  276.             ) {
  277.                 goto isset_in_scope;
  278.             }
  279.         }
  281.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['isset']) {
  282.             return parent::__isset($name);
  283.         }
  285.         isset_in_scope:
  287.         if (null === $scope) {
  288.             return isset($this->$name);
  289.         }
  290.         $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  292.         return $accessor['isset']($this, $name);
  293.     }
  295.     public function __unset($name): void
  296.     {
  297.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  298.         $scope = null;
  300.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  301.             $scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
  302.             $state = $this->lazyObjectState ?? null;
  304.             if ($state && ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"]))) {
  305.                 if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  306.                     $state->initialize($this, $name, $readonlyScope ?? $scope);
  307.                 }
  308.                 goto unset_in_scope;
  309.             }
  310.         }
  312.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['unset']) {
  313.             parent::__unset($name);
  315.             return;
  316.         }
  318.         unset_in_scope:
  320.         if (null === $scope) {
  321.             unset($this->$name);
  322.         } else {
  323.             $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  324.             $accessor['unset']($this, $name);
  325.         }
  326.     }
  328.     public function __clone(): void
  329.     {
  330.         if ($state = $this->lazyObjectState ?? null) {
  331.             $this->lazyObjectState = clone $state;
  332.         }
  334.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['clone']) {
  335.             parent::__clone();
  336.         }
  337.     }
  339.     public function __serialize(): array
  340.     {
  341.         $class = self::class;
  343.         if ((Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['serialize']) {
  344.             $properties = parent::__serialize();
  345.         } else {
  346.             $this->initializeLazyObject();
  347.             $properties = (array) $this;
  348.         }
  349.         unset($properties["\0$class\0lazyObjectState"]);
  351.         if (Registry::$parentMethods[$class]['serialize'] || !Registry::$parentMethods[$class]['sleep']) {
  352.             return $properties;
  353.         }
  355.         $scope = get_parent_class($class);
  356.         $data = [];
  358.         foreach (parent::__sleep() as $name) {
  359.             $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;
  361.             if (null === $k) {
  362.                 trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
  363.             } else {
  364.                 $data[$k] = $value;
  365.             }
  366.         }
  368.         return $data;
  369.     }
  371.     public function __destruct()
  372.     {
  373.         $state = $this->lazyObjectState ?? null;
  375.         if ($state && \in_array($state->status, [LazyObjectState::STATUS_UNINITIALIZED_FULL, LazyObjectState::STATUS_UNINITIALIZED_PARTIAL], true)) {
  376.             return;
  377.         }
  379.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {
  380.             parent::__destruct();
  381.         }
  382.     }
  384.     private function setLazyObjectAsInitialized(bool $initialized): void
  385.     {
  386.         $state = $this->lazyObjectState ?? null;
  388.         if ($state && !\is_array($state->initializer)) {
  389.             $state->status = $initialized ? LazyObjectState::STATUS_INITIALIZED_FULL : LazyObjectState::STATUS_UNINITIALIZED_FULL;
  390.         }
  391.     }
  392. }