entitycollection.php

<?php
namespace Bitrix\Sale\Internals;
 
use Bitrix\Sale;
use Bitrix\Main;
 
abstract class EntityCollection
    extends CollectionBase
{
    private $index = -1;
 
    protected $isClone = false;
 
    protected $anyItemDeleted = false;
    protected $anyItemAdded = false;
 
    protected function __construct() {}
 
    public function onItemModify(CollectableEntity $item, $name = null, $oldValue = null, $value = null)
    {
        return new Sale\Result();
    }
 
    public static function getRegistryType()
    {
        throw new Main\NotImplementedException();
    }
 
    public function deleteItem($index)
    {
        if (!isset($this->collection[$index]))
        {
            throw new Main\ArgumentOutOfRangeException("collection item index wrong");
        }
 
        $oldItem = $this->collection[$index];
 
        $eventManager = Main\EventManager::getInstance();
        $eventsList = $eventManager->findEventHandlers('sale', 'OnBeforeCollectionDeleteItem');
        if (!empty($eventsList))
        {
            $event = new Main\Event('sale', 'OnBeforeCollectionDeleteItem', array(
                'COLLECTION' => $this->collection,
                'ENTITY' => $oldItem,
            ));
            $event->send();
        }
 
        unset($this->collection[$index]);
        $this->setAnyItemDeleted(true);
 
        return $oldItem;
    }
 
    protected function addItem(CollectableEntity $item)
    {
        $index = $this->createIndex();
        $item->setInternalIndex($index);
 
        $this->collection[$index] = $item;
        $this->setAnyItemAdded(true);
 
        $eventManager = Main\EventManager::getInstance();
        $eventsList = $eventManager->findEventHandlers('sale', 'OnCollectionAddItem');
        if (!empty($eventsList))
        {
            $event = new Main\Event('sale', 'OnCollectionAddItem', array(
                'COLLECTION' => $this->collection,
                'ENTITY' => $item,
            ));
            $event->send();
        }
 
        return $item;
    }
 
    protected function createIndex()
    {
        $this->index++;
        return $this->index;
    }
 
    public function clearCollection()
    {
        $this->callEventOnBeforeCollectionClear();
 
        foreach ($this->getDeletableItems() as $item)
        {
            $item->delete();
        }
    }
 
    protected function getDeletableItems()
    {
        return $this->collection;
    }
 
 
    protected function callEventOnBeforeCollectionClear()
    {
        $eventManager = Main\EventManager::getInstance();
 
        $eventsList = $eventManager->findEventHandlers('sale', 'OnBeforeCollectionClear');
        if (!empty($eventsList))
        {
            $event = new Main\Event('sale', 'OnBeforeCollectionClear', array(
                'COLLECTION' => $this->collection,
            ));
            $event->send();
        }
    }
 
    public function getItemById($id)
    {
        if (intval($id) <= 0)
        {
            throw new Main\ArgumentNullException('id');
        }
 
        $index = $this->getIndexById($id);
        if ($index === null)
        {
            return null;
        }
 
        if (isset($this->collection[$index]))
        {
            return $this->collection[$index];
        }
 
        return null;
    }
 
 
    public function getIndexById($id)
    {
        if (intval($id) <= 0)
        {
            throw new Main\ArgumentNullException('id');
        }
 
        foreach ($this->collection as $item)
        {
            if ($item->getId() > 0 && $id == $item->getId())
            {
                return $item->getInternalIndex();
            }
        }
        return null;
    }
 
    public function getItemByIndex($index)
    {
        if (intval($index) < 0)
        {
            throw new Main\ArgumentNullException('id');
        }
 
        foreach ($this->collection as $item)
        {
            if ($item->getInternalIndex() == $index)
            {
                return $item;
            }
        }
        return null;
    }
 
    abstract protected function getEntityParent();
 
    public function isStartField($isMeaningfulField = false)
    {
        $parent = $this->getEntityParent();
        if ($parent === null)
        {
            return false;
        }
 
        return $parent->isStartField($isMeaningfulField);
    }
 
    public function clearStartField()
    {
        $parent = $this->getEntityParent();
        if ($parent === null)
        {
            return false;
        }
 
        return $parent->clearStartField();
    }
 
    public function hasMeaningfulField()
    {
        $parent = $this->getEntityParent();
        if ($parent === null)
        {
            return false;
        }
 
        return $parent->hasMeaningfulField();
    }
 
    public function doFinalAction($hasMeaningfulField = false)
    {
        $parent = $this->getEntityParent();
        if ($parent === null)
        {
            return new Sale\Result();
        }
 
        return $parent->doFinalAction($hasMeaningfulField);
    }
 
    public function isMathActionOnly()
    {
        $parent = $this->getEntityParent();
        if ($parent === null)
        {
            return false;
        }
 
        return $parent->isMathActionOnly();
    }
 
    public function setMathActionOnly($value = false)
    {
        $parent = $this->getEntityParent();
        if ($parent == null)
        {
            return false;
        }
 
        return $parent->setMathActionOnly($value);
    }
 
    public function isChanged()
    {
        if (count($this->collection) > 0)
        {
            foreach ($this->collection as $item)
            {
                if ($item->isChanged())
                {
                    return true;
                }
            }
        }
 
        return $this->isAnyItemDeleted() || $this->isAnyItemAdded();
    }
 
    public function verify()
    {
        return new Sale\Result();
    }
 
    public function isClone()
    {
        return $this->isClone;
    }
 
 
    public function isAnyItemDeleted()
    {
        return $this->anyItemDeleted;
    }
 
    protected function setAnyItemDeleted($value)
    {
        return $this->anyItemDeleted = ($value === true);
    }
 
    public function isAnyItemAdded()
    {
        return $this->anyItemAdded;
    }
 
    protected function setAnyItemAdded($value)
    {
        return $this->anyItemAdded = ($value === true);
    }
 
    public function clearChanged()
    {
        if (!empty($this->collection))
        {
            foreach ($this->collection as $entityItem)
            {
                if ($entityItem instanceof Entity)
                {
                    $entityItem->clearChanged();
                }
            }
        }
    }
 
    public function createClone(\SplObjectStorage $cloneEntity)
    {
        if ($this->isClone() && $cloneEntity->contains($this))
        {
            return $cloneEntity[$this];
        }
 
        $entityClone = clone $this;
        $entityClone->isClone = true;
 
        if (!$cloneEntity->contains($this))
        {
            $cloneEntity[$this] = $entityClone;
        }
 
        foreach ($entityClone->collection as $key => $entity)
        {
            if (!$cloneEntity->contains($entity))
            {
                $cloneEntity[$entity] = $entity->createClone($cloneEntity);
            }
 
            $entityClone->collection[$key] = $cloneEntity[$entity];
        }
 
        return $entityClone;
    }
}