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

  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;
  18. trait LazyGhostTrait
  19. {
  20.     private LazyObjectState $lazyObjectState;
  22.     /**
  23.      * Creates a lazy-loading ghost instance.
  24.      *
  25.      * When the initializer is a closure, it should initialize all properties at
  26.      * once and is given the instance to initialize as argument.
  27.      *
  28.      * When the initializer is an array of closures, it should be indexed by
  29.      * properties and closures should accept 4 arguments: the instance to
  30.      * initialize, the property to initialize, its write-scope, and its default
  31.      * value. Each closure should return the value of the corresponding property.
  32.      * The special "\0" key can be used to define a closure that returns all
  33.      * properties at once when full-initialization is needed; it takes the
  34.      * instance and its default properties as arguments.
  35.      *
  36.      * Properties should be indexed by their array-cast name, see
  37.      * https://php.net/manual/language.types.array#language.types.array.casting
  38.      *
  39.      * @param (\Closure(static):void
  40.      *        |array<string, \Closure(static, string, ?string, mixed):mixed>
  41.      *        |array{"\0": \Closure(static, array<string, mixed>):array<string, mixed>}) $initializer
  42.      * @param array<string, true>|null $skippedProperties An array indexed by the properties to skip, aka the ones
  43.      *                                                    that the initializer doesn't set when its a closure
  44.      * @param static|null              $instance
  45.      */
  46.     public static function createLazyGhost(\Closure|array $initializer, array $skippedProperties = null, object $instance = null): static
  47.     {
  48.         $onlyProperties = null === $skippedProperties && \is_array($initializer) ? $initializer : null;
  50.         if (self::class !== $class = $instance ? $instance::class : static::class) {
  51.             $skippedProperties["\0".self::class."\0lazyObjectState"] = true;
  52.         } elseif (\defined($class.'::LAZY_OBJECT_PROPERTY_SCOPES')) {
  53.             Hydrator::$propertyScopes[$class] ??= $class::LAZY_OBJECT_PROPERTY_SCOPES;
  54.         }
  56.         $instance ??= (Registry::$classReflectors[$class] ??= new \ReflectionClass($class))->newInstanceWithoutConstructor();
  57.         Registry::$defaultProperties[$class] ??= (array) $instance;
  58.         $instance->lazyObjectState = new LazyObjectState($initializer, $skippedProperties ??= []);
  60.         foreach (Registry::$classResetters[$class] ??= Registry::getClassResetters($class) as $reset) {
  61.             $reset($instance, $skippedProperties, $onlyProperties);
  62.         }
  64.         return $instance;
  65.     }
  67.     /**
  68.      * Returns whether the object is initialized.
  69.      *
  70.      * @param $partial Whether partially initialized objects should be considered as initialized
  71.      */
  72.     public function isLazyObjectInitialized(bool $partial = false): bool
  73.     {
  74.         if (!$state = $this->lazyObjectState ?? null) {
  75.             return true;
  76.         }
  78.         if (!\is_array($state->initializer)) {
  79.             return LazyObjectState::STATUS_INITIALIZED_FULL === $state->status;
  80.         }
  82.         $class = $this::class;
  83.         $properties = (array) $this;
  85.         if ($partial) {
  86.             return (bool) array_intersect_key($state->initializer, $properties);
  87.         }
  89.         $propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
  90.         foreach ($state->initializer as $key => $initializer) {
  91.             if (!\array_key_exists($key, $properties) && isset($propertyScopes[$key])) {
  92.                 return false;
  93.             }
  94.         }
  96.         return true;
  97.     }
  99.     /**
  100.      * Forces initialization of a lazy object and returns it.
  101.      */
  102.     public function initializeLazyObject(): static
  103.     {
  104.         if (!$state = $this->lazyObjectState ?? null) {
  105.             return $this;
  106.         }
  108.         if (!\is_array($state->initializer)) {
  109.             if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  110.                 $state->initialize($this, '', null);
  111.             }
  113.             return $this;
  114.         }
  116.         $values = isset($state->initializer["\0"]) ? null : [];
  118.         $class = $this::class;
  119.         $properties = (array) $this;
  120.         $propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
  121.         foreach ($state->initializer as $key => $initializer) {
  122.             if (\array_key_exists($key, $properties) || ![$scope, $name, $readonlyScope] = $propertyScopes[$key] ?? null) {
  123.                 continue;
  124.             }
  125.             $scope = $readonlyScope ?? ('*' !== $scope ? $scope : $class);
  127.             if (null === $values) {
  128.                 if (!\is_array($values = ($state->initializer["\0"])($this, Registry::$defaultProperties[$class]))) {
  129.                     throw new \TypeError(sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
  130.                 }
  132.                 if (\array_key_exists($key, $properties = (array) $this)) {
  133.                     continue;
  134.                 }
  135.             }
  137.             if (\array_key_exists($key, $values)) {
  138.                 $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  139.                 $accessor['set']($this, $name, $properties[$key] = $values[$key]);
  140.             } else {
  141.                 $state->initialize($this, $name, $scope);
  142.                 $properties = (array) $this;
  143.             }
  144.         }
  146.         return $this;
  147.     }
  149.     /**
  150.      * @return bool Returns false when the object cannot be reset, ie when it's not a lazy object
  151.      */
  152.     public function resetLazyObject(): bool
  153.     {
  154.         if (!$state = $this->lazyObjectState ?? null) {
  155.             return false;
  156.         }
  158.         if (LazyObjectState::STATUS_UNINITIALIZED_FULL !== $state->status) {
  159.             $state->reset($this);
  160.         }
  162.         return true;
  163.     }
  165.     public function &__get($name): mixed
  166.     {
  167.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  168.         $scope = null;
  170.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  171.             $scope = Registry::getScope($propertyScopes, $class, $name);
  172.             $state = $this->lazyObjectState ?? null;
  174.             if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))
  175.                 && LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $readonlyScope ?? $scope)
  176.             ) {
  177.                 goto get_in_scope;
  178.             }
  179.         }
  181.         if ($parent = (Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['get']) {
  182.             if (2 === $parent) {
  183.                 return parent::__get($name);
  184.             }
  185.             $value = parent::__get($name);
  187.             return $value;
  188.         }
  190.         if (null === $class) {
  191.             $frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
  192.             trigger_error(sprintf('Undefined property: %s::$%s in %s on line %s', $this::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
  193.         }
  195.         get_in_scope:
  197.         try {
  198.             if (null === $scope) {
  199.                 if (null === $readonlyScope) {
  200.                     return $this->$name;
  201.                 }
  202.                 $value = $this->$name;
  204.                 return $value;
  205.             }
  206.             $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  208.             return $accessor['get']($this, $name, null !== $readonlyScope);
  209.         } catch (\Error $e) {
  210.             if (\Error::class !== $e::class || !str_starts_with($e->getMessage(), 'Cannot access uninitialized non-nullable property')) {
  211.                 throw $e;
  212.             }
  214.             try {
  215.                 if (null === $scope) {
  216.                     $this->$name = [];
  218.                     return $this->$name;
  219.                 }
  221.                 $accessor['set']($this, $name, []);
  223.                 return $accessor['get']($this, $name, null !== $readonlyScope);
  224.             } catch (\Error) {
  225.                 throw $e;
  226.             }
  227.         }
  228.     }
  230.     public function __set($name, $value): void
  231.     {
  232.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  233.         $scope = null;
  234.         $state = null;
  236.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  237.             $scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
  238.             $state = $this->lazyObjectState ?? null;
  240.             if ($state && ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"]))) {
  241.                 if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  242.                     $state->initialize($this, $name, $readonlyScope ?? $scope);
  243.                 }
  244.                 goto set_in_scope;
  245.             }
  246.         }
  248.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['set']) {
  249.             parent::__set($name, $value);
  251.             return;
  252.         }
  254.         set_in_scope:
  256.         if (null === $scope) {
  257.             $this->$name = $value;
  258.         } else {
  259.             $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  260.             $accessor['set']($this, $name, $value);
  261.         }
  262.     }
  264.     public function __isset($name): bool
  265.     {
  266.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  267.         $scope = null;
  269.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  270.             $scope = Registry::getScope($propertyScopes, $class, $name);
  271.             $state = $this->lazyObjectState ?? null;
  273.             if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))
  274.                 && LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $readonlyScope ?? $scope)
  275.             ) {
  276.                 goto isset_in_scope;
  277.             }
  278.         }
  280.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['isset']) {
  281.             return parent::__isset($name);
  282.         }
  284.         isset_in_scope:
  286.         if (null === $scope) {
  287.             return isset($this->$name);
  288.         }
  289.         $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  291.         return $accessor['isset']($this, $name);
  292.     }
  294.     public function __unset($name): void
  295.     {
  296.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  297.         $scope = null;
  299.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  300.             $scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
  301.             $state = $this->lazyObjectState ?? null;
  303.             if ($state && ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"]))) {
  304.                 if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
  305.                     $state->initialize($this, $name, $readonlyScope ?? $scope);
  306.                 }
  307.                 goto unset_in_scope;
  308.             }
  309.         }
  311.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['unset']) {
  312.             parent::__unset($name);
  314.             return;
  315.         }
  317.         unset_in_scope:
  319.         if (null === $scope) {
  320.             unset($this->$name);
  321.         } else {
  322.             $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  323.             $accessor['unset']($this, $name);
  324.         }
  325.     }
  327.     public function __clone(): void
  328.     {
  329.         if ($state = $this->lazyObjectState ?? null) {
  330.             $this->lazyObjectState = clone $state;
  331.         }
  333.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['clone']) {
  334.             parent::__clone();
  335.         }
  336.     }
  338.     public function __serialize(): array
  339.     {
  340.         $class = self::class;
  342.         if ((Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['serialize']) {
  343.             $properties = parent::__serialize();
  344.         } else {
  345.             $this->initializeLazyObject();
  346.             $properties = (array) $this;
  347.         }
  348.         unset($properties["\0$class\0lazyObjectState"]);
  350.         if (Registry::$parentMethods[$class]['serialize'] || !Registry::$parentMethods[$class]['sleep']) {
  351.             return $properties;
  352.         }
  354.         $scope = get_parent_class($class);
  355.         $data = [];
  357.         foreach (parent::__sleep() as $name) {
  358.             $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;
  360.             if (null === $k) {
  361.                 trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
  362.             } else {
  363.                 $data[$k] = $value;
  364.             }
  365.         }
  367.         return $data;
  368.     }
  370.     public function __destruct()
  371.     {
  372.         $state = $this->lazyObjectState ?? null;
  374.         if ($state && \in_array($state->status, [LazyObjectState::STATUS_UNINITIALIZED_FULL, LazyObjectState::STATUS_UNINITIALIZED_PARTIAL], true)) {
  375.             return;
  376.         }
  378.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {
  379.             parent::__destruct();
  380.         }
  381.     }
  383.     private function setLazyObjectAsInitialized(bool $initialized): void
  384.     {
  385.         $state = $this->lazyObjectState ?? null;
  387.         if ($state && !\is_array($state->initializer)) {
  388.             $state->status = $initialized ? LazyObjectState::STATUS_INITIALIZED_FULL : LazyObjectState::STATUS_UNINITIALIZED_FULL;
  389.         }
  390.     }
  391. }