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, $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. }