LazyObjectStorage.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Extbase\Persistence\Generic;
 
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\Mapper\ColumnMap\Relation;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMapper;
use ‪TYPO3\CMS\Extbase\Persistence\ObjectStorage;
 
class ‪LazyObjectStorage extends ‪ObjectStorage implements ‪LoadingStrategyInterface
{
    private string ‪$warning = 'You should never see this warning. If you do, you probably used PHP array functions like current() on the TYPO3\\CMS\\Extbase\\Persistence\\Generic\\LazyObjectStorage. To retrieve the first result, you can use the rewind() and current() methods.';
 
    protected ‪DataMapper ‪$dataMapper;
 
    protected ‪DomainObjectInterface ‪$parentObject;
 
    protected string ‪$propertyName;
 
    protected mixed ‪$fieldValue;
 
    protected bool ‪$isInitialized = false;
 
    public function ‪isInitialized(): bool
    {
        return ‪$this->isInitialized;
    }
 
    public function ‪__construct(object ‪$parentObject, string ‪$propertyName, mixed ‪$fieldValue, ?‪DataMapper ‪$dataMapper = null)
    {
        $this->parentObject = ‪$parentObject;
        $this->propertyName = ‪$propertyName;
        $this->fieldValue = ‪$fieldValue;
        reset($this->storage);
        if (‪$dataMapper === null) {
            ‪$dataMapper = GeneralUtility::makeInstance(DataMapper::class);
        }
        $this->dataMapper = ‪$dataMapper;
    }
 
    protected function ‪initialize(): void
    {
        if ($this->‪isInitialized) {
            return;
        }
 
        $this->‪isInitialized = true;
        $objects = $this->dataMapper->fetchRelated($this->parentObject, $this->propertyName, $this->fieldValue, false);
        foreach ($objects as $object) {
            parent::attach($object);
        }
        $this->‪_memorizeCleanState();
        if (!$this->‪isStorageAlreadyMemorizedInParentCleanState()) {
            $this->parentObject->_memorizeCleanState($this->propertyName);
        }
    }
 
    protected function ‪isStorageAlreadyMemorizedInParentCleanState(): bool
    {
        return $this->parentObject->_getCleanProperty($this->propertyName) === $this;
    }
 
    // Delegation to the ObjectStorage methods below
 
    public function ‪addAll(‪ObjectStorage ‪$storage): void
    {
        $this->‪initialize();
        parent::addAll(‪$storage);
    }
 
    public function ‪attach(object $object, mixed $information = null): void
    {
        $this->‪initialize();
        parent::attach($object, $information);
    }
 
    public function ‪contains(object $object): bool
    {
        $this->‪initialize();
        return parent::contains($object);
    }
 
    public function ‪count(): int
    {
        $columnMap = $this->dataMapper->getDataMap(get_class($this->parentObject))->getColumnMap($this->propertyName);
        if (!$this->‪isInitialized && $columnMap->getTypeOfRelation() === Relation::HAS_MANY) {
            $numberOfElements = $this->dataMapper->countRelated($this->parentObject, $this->propertyName, $this->fieldValue);
        } else {
            $this->‪initialize();
            $numberOfElements = ‪count($this->storage);
        }
        return $numberOfElements;
    }
 
    public function ‪current(): ?object
    {
        $this->‪initialize();
        return parent::current();
    }
 
    public function ‪detach(object $object): void
    {
        $this->‪initialize();
        parent::detach($object);
    }
 
    public function ‪key(): string
    {
        $this->‪initialize();
        return parent::key();
    }
 
    public function ‪next(): void
    {
        $this->‪initialize();
        parent::next();
    }
 
    public function ‪offsetExists(mixed $value): bool
    {
        $this->‪initialize();
        return parent::offsetExists($value);
    }
 
    public function ‪offsetGet(mixed $value): mixed
    {
        $this->‪initialize();
        return parent::offsetGet($value);
    }
 
    public function ‪offsetSet(mixed $object, mixed $information): void
    {
        $this->‪initialize();
        parent::offsetSet($object, $information);
    }
 
    public function ‪offsetUnset(mixed $value): void
    {
        $this->‪initialize();
        parent::offsetUnset($value);
    }
 
    public function ‪removeAll(‪ObjectStorage ‪$storage): void
    {
        $this->‪initialize();
        parent::removeAll(‪$storage);
    }
 
    public function ‪rewind(): void
    {
        $this->‪initialize();
        parent::rewind();
    }
 
    public function ‪valid(): bool
    {
        $this->‪initialize();
        return parent::valid();
    }
 
    public function ‪toArray(): array
    {
        $this->‪initialize();
        return parent::toArray();
    }
 
    public function ‪getPosition($object): ?int
    {
        $this->‪initialize();
        return parent::getPosition($object);
    }
 
    public function ‪__serialize(): array
    {
        $properties = get_object_vars($this);
        unset(
            $properties['warning'],
            $properties['dataMapper']
        );
        return $properties;
    }
 
    public function ‪__unserialize(array $data): void
    {
        foreach ($data as ‪$propertyName => $propertyValue) {
            $this->{$propertyName} = $propertyValue;
        }
 
        $this->dataMapper = GeneralUtility::getContainer()->get(DataMapper::class);
    }
}