vendor/symfony/var-exporter/LazyProxyTrait.php line 95

  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\Hydrator as PublicHydrator;
  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 LazyProxyTrait
  21. {
  22.     use LazyObjectTrait;
  24.     /**
  25.      * Creates a lazy-loading virtual proxy.
  26.      *
  27.      * @param \Closure():object $initializer Returns the proxied object
  28.      * @param static|null       $instance
  29.      */
  30.     public static function createLazyProxy(\Closure $initializer, object $instance = null): static
  31.     {
  32.         if (self::class !== $class = $instance ? $instance::class : static::class) {
  33.             $skippedProperties = ["\0".self::class."\0lazyObjectState" => true];
  34.         } elseif (\defined($class.'::LAZY_OBJECT_PROPERTY_SCOPES')) {
  35.             Hydrator::$propertyScopes[$class] ??= $class::LAZY_OBJECT_PROPERTY_SCOPES;
  36.         }
  38.         $instance ??= (Registry::$classReflectors[$class] ??= new \ReflectionClass($class))->newInstanceWithoutConstructor();
  39.         $instance->lazyObjectState = new LazyObjectState($initializer);
  41.         foreach (Registry::$classResetters[$class] ??= Registry::getClassResetters($class) as $reset) {
  42.             $reset($instance, $skippedProperties ??= []);
  43.         }
  45.         return $instance;
  46.     }
  48.     /**
  49.      * Returns whether the object is initialized.
  50.      *
  51.      * @param $partial Whether partially initialized objects should be considered as initialized
  52.      */
  53.     public function isLazyObjectInitialized(bool $partial = false): bool
  54.     {
  55.         return !isset($this->lazyObjectState) || isset($this->lazyObjectState->realInstance) || Registry::$noInitializerState === $this->lazyObjectState->initializer;
  56.     }
  58.     /**
  59.      * Forces initialization of a lazy object and returns it.
  60.      */
  61.     public function initializeLazyObject(): parent
  62.     {
  63.         if ($state = $this->lazyObjectState ?? null) {
  64.             return $state->realInstance ??= ($state->initializer)();
  65.         }
  67.         return $this;
  68.     }
  70.     /**
  71.      * @return bool Returns false when the object cannot be reset, ie when it's not a lazy object
  72.      */
  73.     public function resetLazyObject(): bool
  74.     {
  75.         if (!isset($this->lazyObjectState) || Registry::$noInitializerState === $this->lazyObjectState->initializer) {
  76.             return false;
  77.         }
  79.         unset($this->lazyObjectState->realInstance);
  81.         return true;
  82.     }
  84.     public function &__get($name): mixed
  85.     {
  86.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  87.         $scope = null;
  88.         $instance = $this;
  90.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  91.             $scope = Registry::getScope($propertyScopes, $class, $name);
  93.             if (null === $scope || isset($propertyScopes["\0$scope\0$name"])) {
  94.                 if ($state = $this->lazyObjectState ?? null) {
  95.                     $instance = $state->realInstance ??= ($state->initializer)();
  96.                 }
  97.                 $parent = 2;
  98.                 goto get_in_scope;
  99.             }
  100.         }
  101.         $parent = (Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['get'];
  103.         if ($state = $this->lazyObjectState ?? null) {
  104.             $instance = $state->realInstance ??= ($state->initializer)();
  105.         } else {
  106.             if (2 === $parent) {
  107.                 return parent::__get($name);
  108.             }
  109.             $value = parent::__get($name);
  111.             return $value;
  112.         }
  114.         if (!$parent && null === $class && !\array_key_exists($name, (array) $instance)) {
  115.             $frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
  116.             trigger_error(sprintf('Undefined property: %s::$%s in %s on line %s', $instance::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
  117.         }
  119.         get_in_scope:
  121.         try {
  122.             if (null === $scope) {
  123.                 if (null === $readonlyScope && 1 !== $parent) {
  124.                     return $instance->$name;
  125.                 }
  126.                 $value = $instance->$name;
  128.                 return $value;
  129.             }
  130.             $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  132.             return $accessor['get']($instance, $name, null !== $readonlyScope || 1 === $parent);
  133.         } catch (\Error $e) {
  134.             if (\Error::class !== $e::class || !str_starts_with($e->getMessage(), 'Cannot access uninitialized non-nullable property')) {
  135.                 throw $e;
  136.             }
  138.             try {
  139.                 if (null === $scope) {
  140.                     $instance->$name = [];
  142.                     return $instance->$name;
  143.                 }
  145.                 $accessor['set']($instance, $name, []);
  147.                 return $accessor['get']($instance, $name, null !== $readonlyScope || 1 === $parent);
  148.             } catch (\Error) {
  149.                 throw $e;
  150.             }
  151.         }
  152.     }
  154.     public function __set($name, $value): void
  155.     {
  156.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  157.         $scope = null;
  158.         $instance = $this;
  160.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  161.             $scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
  163.             if ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"])) {
  164.                 if ($state = $this->lazyObjectState ?? null) {
  165.                     $instance = $state->realInstance ??= ($state->initializer)();
  166.                 }
  167.                 goto set_in_scope;
  168.             }
  169.         }
  171.         if ($state = $this->lazyObjectState ?? null) {
  172.             $instance = $state->realInstance ??= ($state->initializer)();
  173.         } elseif ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['set']) {
  174.             parent::__set($name, $value);
  176.             return;
  177.         }
  179.         set_in_scope:
  181.         if (null === $scope) {
  182.             $instance->$name = $value;
  183.         } else {
  184.             $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  185.             $accessor['set']($instance, $name, $value);
  186.         }
  187.     }
  189.     public function __isset($name): bool
  190.     {
  191.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  192.         $scope = null;
  193.         $instance = $this;
  195.         if ([$class] = $propertyScopes[$name] ?? null) {
  196.             $scope = Registry::getScope($propertyScopes, $class, $name);
  198.             if (null === $scope || isset($propertyScopes["\0$scope\0$name"])) {
  199.                 if ($state = $this->lazyObjectState ?? null) {
  200.                     $instance = $state->realInstance ??= ($state->initializer)();
  201.                 }
  202.                 goto isset_in_scope;
  203.             }
  204.         }
  206.         if ($state = $this->lazyObjectState ?? null) {
  207.             $instance = $state->realInstance ??= ($state->initializer)();
  208.         } elseif ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['isset']) {
  209.             return parent::__isset($name);
  210.         }
  212.         isset_in_scope:
  214.         if (null === $scope) {
  215.             return isset($instance->$name);
  216.         }
  217.         $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  219.         return $accessor['isset']($instance, $name);
  220.     }
  222.     public function __unset($name): void
  223.     {
  224.         $propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
  225.         $scope = null;
  226.         $instance = $this;
  228.         if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
  229.             $scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
  231.             if ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"])) {
  232.                 if ($state = $this->lazyObjectState ?? null) {
  233.                     $instance = $state->realInstance ??= ($state->initializer)();
  234.                 }
  235.                 goto unset_in_scope;
  236.             }
  237.         }
  239.         if ($state = $this->lazyObjectState ?? null) {
  240.             $instance = $state->realInstance ??= ($state->initializer)();
  241.         } elseif ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['unset']) {
  242.             parent::__unset($name);
  244.             return;
  245.         }
  247.         unset_in_scope:
  249.         if (null === $scope) {
  250.             unset($instance->$name);
  251.         } else {
  252.             $accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
  253.             $accessor['unset']($instance, $name);
  254.         }
  255.     }
  257.     public function __clone(): void
  258.     {
  259.         if (!isset($this->lazyObjectState)) {
  260.             if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['clone']) {
  261.                 parent::__clone();
  262.             }
  264.             return;
  265.         }
  267.         $this->lazyObjectState = clone $this->lazyObjectState;
  269.         if (isset($this->lazyObjectState->realInstance)) {
  270.             $this->lazyObjectState->realInstance = clone $this->lazyObjectState->realInstance;
  271.         }
  272.     }
  274.     public function __serialize(): array
  275.     {
  276.         $class = self::class;
  277.         $state = $this->lazyObjectState ?? null;
  279.         if (!$state && (Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['serialize']) {
  280.             $properties = parent::__serialize();
  281.         } else {
  282.             $properties = (array) $this;
  284.             if ($state) {
  285.                 unset($properties["\0$class\0lazyObjectState"]);
  286.                 $properties["\0$class\0lazyObjectReal"] = $state->realInstance ??= ($state->initializer)();
  287.             }
  288.         }
  290.         if ($state || Registry::$parentMethods[$class]['serialize'] || !Registry::$parentMethods[$class]['sleep']) {
  291.             return $properties;
  292.         }
  294.         $scope = get_parent_class($class);
  295.         $data = [];
  297.         foreach (parent::__sleep() as $name) {
  298.             $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;
  300.             if (null === $k) {
  301.                 trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
  302.             } else {
  303.                 $data[$k] = $value;
  304.             }
  305.         }
  307.         return $data;
  308.     }
  310.     public function __unserialize(array $data): void
  311.     {
  312.         $class = self::class;
  314.         if ($instance = $data["\0$class\0lazyObjectReal"] ?? null) {
  315.             unset($data["\0$class\0lazyObjectReal"]);
  317.             foreach (Registry::$classResetters[$class] ??= Registry::getClassResetters($class) as $reset) {
  318.                 $reset($this, $data);
  319.             }
  321.             if ($data) {
  322.                 PublicHydrator::hydrate($this, $data);
  323.             }
  324.             $this->lazyObjectState = new LazyObjectState(Registry::$noInitializerState ??= static fn () => throw new \LogicException('Lazy proxy has no initializer.'));
  325.             $this->lazyObjectState->realInstance = $instance;
  326.         } elseif ((Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['unserialize']) {
  327.             parent::__unserialize($data);
  328.         } else {
  329.             PublicHydrator::hydrate($this, $data);
  331.             if (Registry::$parentMethods[$class]['wakeup']) {
  332.                 parent::__wakeup();
  333.             }
  334.         }
  335.     }
  337.     public function __destruct()
  338.     {
  339.         if (isset($this->lazyObjectState)) {
  340.             return;
  341.         }
  343.         if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {
  344.             parent::__destruct();
  345.         }
  346.     }
  347. }