LazyObjectStorage.php

Go to the documentation of this file.

<?php
 
/*
 * 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\Extbase\DomainObject\DomainObjectInterface;
use ‪TYPO3\CMS\Extbase\Object\ObjectManagerInterface;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\Mapper\ColumnMap;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMapper;
use ‪TYPO3\CMS\Extbase\Persistence\ObjectStorage;
 
class ‪LazyObjectStorage extends ‪ObjectStorage implements ‪LoadingStrategyInterface
{
    private ‪$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;
 
    protected ‪$parentObject;
 
    protected ‪$propertyName;
 
    protected ‪$fieldValue;
 
    protected ‪$isInitialized = false;
 
    protected ‪$objectManager;
 
    public function ‪injectObjectManager(‪ObjectManagerInterface ‪$objectManager)
    {
        $this->objectManager = ‪$objectManager;
    }
 
    public function ‪isInitialized()
    {
        return ‪$this->isInitialized;
    }
 
    public function ‪__construct(‪$parentObject, ‪$propertyName, ‪$fieldValue, ?DataMapper ‪$dataMapper = null)
    {
        $this->parentObject = ‪$parentObject;
        $this->propertyName = ‪$propertyName;
        $this->fieldValue = ‪$fieldValue;
        reset($this->storage);
        $this->dataMapper = ‪$dataMapper;
    }
 
    public function ‪initializeObject()
    {
        if (!$this->dataMapper) {
            $this->dataMapper = $this->objectManager->get(DataMapper::class);
        }
    }
 
    protected function ‪initialize()
    {
        if (!$this->‪isInitialized) {
            $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()
    {
        return $this->parentObject->_getCleanProperty($this->propertyName) === $this;
    }
 
    // Delegation to the ObjectStorage methods below
    public function ‪addAll(‪ObjectStorage ‪$storage)
    {
        $this->‪initialize();
        parent::addAll(‪$storage);
    }
 
    public function ‪attach($object, $data = null)
    {
        $this->‪initialize();
        parent::attach($object, $data);
    }
 
    public function ‪contains($object)
    {
        $this->‪initialize();
        return parent::contains($object);
    }
 
    public function ‪count()
    {
        $columnMap = $this->dataMapper->getDataMap(get_class($this->parentObject))->getColumnMap($this->propertyName);
        $numberOfElements = null;
        if (!$this->‪isInitialized && $columnMap->getTypeOfRelation() === ‪ColumnMap::RELATION_HAS_MANY) {
            $numberOfElements = $this->dataMapper->countRelated($this->parentObject, $this->propertyName, $this->fieldValue);
        } else {
            $this->‪initialize();
            $numberOfElements = ‪count($this->storage);
        }
        if ($numberOfElements === null) {
            throw new ‪Exception('The number of elements could not be determined.', 1252514486);
        }
        return $numberOfElements;
    }
 
    public function ‪current()
    {
        $this->‪initialize();
        return parent::current();
    }
 
    public function ‪detach($object)
    {
        $this->‪initialize();
        parent::detach($object);
    }
 
    public function ‪key()
    {
        $this->‪initialize();
        return parent::key();
    }
 
    public function ‪next()
    {
        $this->‪initialize();
        parent::next();
    }
 
    public function ‪offsetExists($value)
    {
        $this->‪initialize();
        return parent::offsetExists($value);
    }
 
    public function ‪offsetGet($value)
    {
        $this->‪initialize();
        return parent::offsetGet($value);
    }
 
    public function ‪offsetSet($object, $info)
    {
        $this->‪initialize();
        parent::offsetSet($object, $info);
    }
 
    public function ‪offsetUnset($value)
    {
        $this->‪initialize();
        parent::offsetUnset($value);
    }
 
    public function ‪removeAll(‪ObjectStorage ‪$storage)
    {
        $this->‪initialize();
        parent::removeAll(‪$storage);
    }
 
    public function ‪rewind()
    {
        $this->‪initialize();
        parent::rewind();
    }
 
    public function ‪valid()
    {
        $this->‪initialize();
        return parent::valid();
    }
 
    public function ‪toArray()
    {
        $this->‪initialize();
        return parent::toArray();
    }
 
    public function ‪getPosition($object)
    {
        $this->‪initialize();
        return parent::getPosition($object);
    }
}