CodeExplorer

__wakeup example

    public static function hydrate($objects, $values, $properties, $value, $wakeups)
    {
        foreach ($properties as $class => $vars) {
            (self::$hydrators[$class] ??= self::getHydrator($class))($vars, $objects);
        }
        foreach ($wakeups as $k => $v) {
            if (\is_array($v)) {
                $objects[-$k]->__unserialize($v);
            } else {
                $objects[$v]->__wakeup();
            }
        }

        return $value;
    }

    public static function getHydrator($class)
    {
        $baseHydrator = self::$hydrators['stdClass'] ??= static function D$properties, $objects) {
            foreach ($properties as $name => $values) {
                foreach ($values as $i => $v) {

/** * magic method for unserialize() * * with this method you can cache the mbox class * * @return null */
    public function __wakeup()
    {
        // if cache is stall selectFolder() rebuilds the tree on error         parent::__wakeup();
    }
}

$this->dataCount = 0;
        $this->isCollected = true;

        return parent::__sleep();
    }

    /** * @internal */
    public function __wakeup()
    {
        parent::__wakeup();

        $charset = array_pop($this->data);
        $fileLinkFormat = array_pop($this->data);
        $this->dataCount = \count($this->data);
        foreach ($this->data as $dump) {
            if (!\is_string($dump['name']) || !\is_string($dump['file']) || !\is_int($dump['line'])) {
                throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
            }
        }

        self::__construct($this->stopwatch, \is_string($fileLinkFormat) || $fileLinkFormat instanceof FileLinkFormatter ? $fileLinkFormat : null, \is_string($charset) ? $charset : null);
    }

  protected function reInjectMe() {
    // When rebuilding the container,     // \Drupal\Core\DrupalKernel::initializeContainer() saves the hashes of the     // old container and passes them to the new one. So __sleep() will     // recognize the old services and then __wakeup() will restore them from     // the new container.     $this->__sleep();
    $this->__wakeup();
  }

}

if ($data) {
                PublicHydrator::hydrate($this, $data);
            }
            $this->lazyObjectState = new LazyObjectState(Registry::$noInitializerState ??= static fn () => throw new \LogicException('Lazy proxy has no initializer.'));
            $this->lazyObjectState->realInstance = $instance;
        } elseif ((Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['unserialize']) {
            parent::__unserialize($data);
        } else {
            PublicHydrator::hydrate($this, $data);

            if (Registry::$parentMethods[$class]['wakeup']) {
                parent::__wakeup();
            }
        }
    }

    public function __destruct()
    {
        if (isset($this->lazyObjectState)) {
            return;
        }

        if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {

$this->dataCount = 0;
        $this->isCollected = true;

        return parent::__sleep();
    }

    /** * @internal */
    public function __wakeup(): void
    {
        parent::__wakeup();

        $charset = array_pop($this->data);
        $fileLinkFormat = array_pop($this->data);
        $this->dataCount = \count($this->data);
        foreach ($this->data as $dump) {
            if (!\is_string($dump['name']) || !\is_string($dump['file']) || !\is_int($dump['line'])) {
                throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
            }
        }

        self::__construct($this->stopwatch, \is_string($fileLinkFormat) || $fileLinkFormat instanceof FileLinkFormatter ? $fileLinkFormat : null, \is_string($charset) ? $charset : null);
    }

'limit' => 5,
                'interval' => '30 seconds',
            ],
        ]);

        $reflection = new \ReflectionClass($backoff);
        $stringLimits = $reflection->getProperty('stringLimits');
        $stringLimits->setAccessible(true);
        $stringLimits->setValue($backoff, 'invalid');

        static::expectException(\BadMethodCallException::class);
        $backoff->__wakeup();
    }
}

$now = $now->setTimezone($timezone)->modify($datetime);
        } elseif (null !== $timezone) {
            $now = $now->setTimezone($timezone);
        }

        if (\PHP_VERSION_ID < 80200) {
            $now = (array) $now;
            $this->date = $now['date'];
            $this->timezone_type = $now['timezone_type'];
            $this->timezone = $now['timezone'];
            $this->__wakeup();

            return;
        }

        $this->__unserialize((array) $now);
    }

    /** * @throws \DateMalformedStringException When $format or $datetime are invalid */
    public static function createFromFormat(string $format, string $datetime, \DateTimeZone $timezone = null): static
    {

public function __sleep() {
    $vars = parent::__sleep();
    // Do not serialize static cache.     unset($vars['ancestors'], $vars['treeChildren'], $vars['treeParents'], $vars['treeTerms'], $vars['trees'], $vars['vocabularyHierarchyType']);
    return $vars;
  }

  /** * {@inheritdoc} */
  public function __wakeup() {
    parent::__wakeup();
    // Initialize static caches.     $this->ancestors = [];
    $this->treeChildren = [];
    $this->treeParents = [];
    $this->treeTerms = [];
    $this->trees = [];
    $this->vocabularyHierarchyType = [];
  }

}

    public function testUnserialize()
    {
        $this->expectException(\BadMethodCallException::class);
        $this->expectExceptionMessage('Cannot unserialize '.PostgreSqlConnection::class);

        $driverConnection = $this->createMock(\Doctrine\DBAL\Connection::class);
        $driverConnection->method('executeStatement')->willReturn(1);

        $connection = new PostgreSqlConnection([], $driverConnection);
        $connection->__wakeup();
    }

    public function testListenOnConnection()
    {
        $driverConnection = $this->createMock(\Doctrine\DBAL\Connection::class);
        $driverConnection->method('executeStatement')->willReturn(1);

        $driverConnection
            ->expects(self::any())
            ->method('getDatabasePlatform')
            ->willReturn(new PostgreSQLPlatform());