Xml\Impl\Type\Reference\ElementReferenceCollectionImpl

Complexity

Total Complexity

48

Size/Duplication

Total Lines	235
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	retainAll()	0	3	1
A	getReferenceIdentifier()	0	3	1
A	add()	0	9	3
A	removeReference()	0	6	1
A	getReferenceTargetElements()	0	5	1
A	contains()	0	13	4
A	__construct()	0	3	1
A	getReferenceSourceCollection()	0	3	1
A	setReferenceSourceElementType()	0	3	1
A	updateReference()	0	8	3
A	remove()	0	9	2
A	clear()	0	11	3
A	performClearOperation()	0	6	2
A	getReferenceSourceElementType()	0	3	1
A	isEmpty()	0	3	1
A	getView()	0	15	3
A	size()	0	3	1
A	setReferenceIdentifier()	0	5	1
A	addAll()	0	10	3
A	performAddOperation()	0	13	3
A	performRemoveOperation()	0	10	3
A	containsAll()	0	21	5
A	removeAll()	0	10	3

<?php

namespace Xml\Impl\Type\Reference;

use Xml\Exception\{
    ModelException,
    ModelReferenceException,
    UnsupportedModelOperationException
};
use Xml\Impl\Instance\ModelElementInstanceImpl;
use Xml\Impl\Type\ModelElementTypeImpl;
use Xml\Impl\Util\ModelUtil;
use Xml\Instance\ModelElementInstanceInterface;
use Xml\Type\ModelElementTypeInterface;
use Xml\Type\Child\ChildElementCollectionInterface;
use Xml\Type\Reference\ElementReferenceCollectionInterface;

class ElementReferenceCollectionImpl extends ReferenceImpl implements ElementReferenceCollectionInterface
{
    private $referenceSourceCollection;
    private $referenceSourceType;

    public function __construct(ChildElementCollectionInterface $referenceSourceCollection)
    {
        $this->referenceSourceCollection = $referenceSourceCollection;
    }

    public function getReferenceSourceCollection(): ChildElementCollectionInterface
    {
        return $this->referenceSourceCollection;
    }

    protected function setReferenceIdentifier(
        ModelElementInstanceInterface $referenceSourceElement,
        string $referenceIdentifier
    ): void {
        $referenceSourceElement->setTextContent($referenceIdentifier);
    }

    protected function performAddOperation(
        ModelElementInstanceImpl $referenceSourceParentElement,
        ModelElementInstanceInterface $referenceTargetElement
    ): void {
        $modelInstance = $referenceSourceParentElement->getModelInstance();
        $referenceTargetIdentifier = $this->referenceTargetAttribute->getValue($referenceTargetElement);
        $existingElement = $modelInstance->getModelElementById($referenceTargetIdentifier);
        if ($existingElement === null || !$referenceTargetElement->equals($existingElement)) {
            throw new ModelReferenceException("Cannot create reference to model element");
        } else {
            $referenceSourceElement = $modelInstance->newInstance($this->referenceSourceType);
            $this->referenceSourceCollection->add($referenceSourceParentElement, $referenceSourceElement);

The method add() does not exist on Xml\Type\Child\ChildElementCollectionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Xml\Type\Child\ChildElementInterface. Are you sure you never get one of those?

            $this->setReferenceIdentifier($referenceSourceElement, $referenceTargetIdentifier);
        }
    }

    protected function performRemoveOperation(
        ModelElementInstanceImpl $referenceSourceParentElement,
        ModelElementInstanceInterface $referenceTargetElement
    ): void {
        $referenceSourceChildElements = $referenceSourceParentElement->getChildElementsByType(
            $this->referenceSourceType
        );
        foreach ($referenceSourceChildElements as $referenceSourceChildElement) {
            if ($referenceTargetElement->equals($this->getReferenceTargetElement($referenceSourceChildElement))) {
                $referenceSourceParentElement->removeChildElement($referenceSourceChildElement);
            }
        }
    }

    protected function performClearOperation(
        ModelElementInstanceImpl $referenceSourceParentElement,
        array $elementsToRemove
    ): void {
        foreach ($elementsToRemove as $element) {
            $referenceSourceParentElement->getDomElement()->removeChild($element);
        }
    }

    /**
     * @return mixed
     */
    public function getReferenceIdentifier(ModelElementInstanceInterface $referenceSourceElement)
    {
        return $referenceSourceElement->getTextContent();
    }

    protected function updateReference(
        ModelElementInstanceInterface $referenceSourceElement,
        ?string $oldIdentifier,
        string $newIdentifier
    ): void {
        $referencingTextContent = $this->getReferenceIdentifier($referenceSourceElement);
        if ($oldIdentifier !== null && $oldIdentifier == $referencingTextContent) {
            $this->setReferenceIdentifier($referenceSourceElement, $newIdentifier);
        }
    }

    //@attention. $referenceTargetElement is mentioned, but not used
    protected function removeReference(
        ModelElementInstanceInterface $referenceSourceElement,
        ModelElementInstanceInterface $referenceTargetElement
    ): void {
        $parentElement = $referenceSourceElement->getParentElement();
        $this->referenceSourceCollection->remove($parentElement, $referenceSourceElement);

The method remove() does not exist on Xml\Type\Child\ChildElementCollectionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Xml\Type\Child\ChildElementInterface. Are you sure you never get one of those?

    }

    public function setReferenceSourceElementType(ModelElementTypeImpl $referenceSourceType): void
    {
        $this->referenceSourceType = $referenceSourceType;
    }

    public function getReferenceSourceElementType(): ModelElementTypeInterface
    {
        return $this->referenceSourceType;
    }

    protected function getView(ModelElementInstanceImpl $referenceSourceParentElement): array
    {
        $document = $referenceSourceParentElement->getModelInstance()->getDocument();
        $referenceSourceElements = $this->referenceSourceCollection->get($referenceSourceParentElement);
        $referenceTargetElements = [];
        foreach ($referenceSourceElements as $referenceSourceElement) {
            $identifier = $this->getReferenceIdentifier($referenceSourceElement);
            $referenceTargetElement = $document->getElementById($identifier);
            if ($referenceTargetElement !== null) {
                $referenceTargetElements[] = $referenceTargetElement;
            } else {
                throw new ModelException(spintf("Unable to find a model element instance for id %s", $identifier));

The function spintf was not found. Maybe you did not declare it correctly or list all dependencies?

            }
        }
        return $referenceTargetElements;
    }

    public function size(ModelElementInstanceImpl $referenceSourceParentElement): int
    {
        return count($this->getView($referenceSourceParentElement));
    }

    public function isEmpty(ModelElementInstanceImpl $referenceSourceParentElement): bool
    {
        return count($this->getView($referenceSourceParentElement)) == 0;
    }

    public function contains(
        ModelElementInstanceImpl $referenceSourceParentElement,
        ?ModelElementInstanceInterface $elementToAdd
    ): bool {
        if ($elementToAdd === null) {
            return false;
        } else {
            foreach ($this->getView($referenceSourceParentElement) as $el) {
                if ($elementToAdd->getDomElement()->equals($el)) {
                    return true;
                }
            }
            return false;
        }
    }

    public function containsAll(
        ModelElementInstanceImpl $referenceSourceParentElement,
        array $c
    ): bool {
        $modelElementCollection = ModelUtil::getModelElementCollection(
            $this->getView($referenceSourceParentElement),
            $referenceSourceParentElement->getModelInstance()
        );
        foreach ($modelElementCollection as $el) {
            $flag = false;
            foreach ($c as $elementToCheck) {
                if ($elementToCheck->equals($el)) {
                    $flag = true;
                    break;
                }
            }
            if (!$flag) {
                return false;
            }
        }
        return true;
    }

    public function add(ModelElementInstanceImpl $referenceSourceParentElement, ModelElementInstanceInterface $e): bool
    {
        if ($this->referenceSourceCollection->isImmutable()) {
            throw new UnsupportedModelOperationException("collection is immutable");
        } else {
            if (!$this->contains($referenceSourceParentElement, $e)) {
                $this->performAddOperation($referenceSourceParentElement, $e);
            }
            return true;
        }
    }

    public function remove(
        ModelElementInstanceImpl $referenceSourceParentElement,
        ModelElementInstanceInterface $e
    ): bool {
        if ($this->referenceSourceCollection->isImmutable()) {
            throw new UnsupportedModelOperationException("collection is immutable");
        }
        $this->performRemoveOperation($referenceSourceParentElement, $e);
        return true;
    }

    public function addAll(ModelElementInstanceImpl $referenceSourceParentElement, array $c): bool
    {
        if ($this->referenceSourceCollection->isImmutable()) {
            throw new UnsupportedModelOperationException("collection is immutable");
        }
        $result = false;
        foreach ($c as $elementToAdd) {
            $result |= $this->add($referenceSourceParentElement, $elementToAdd);
        }
        return $result;

The expression return $result could return the type integer which is incompatible with the type-hinted return boolean. Consider adding an additional type-check to rule them out.

    }

    public function removeAll(ModelElementInstanceImpl $referenceSourceParentElement, array $c): bool
    {
        if ($this->referenceSourceCollection->isImmutable()) {
            throw new UnsupportedModelOperationException("collection is immutable");
        }
        $result = false;
        foreach ($c as $elementToRemove) {
            $result |= $this->remove($referenceSourceParentElement, $elementToRemove);
        }
        return $result;

The expression return $result could return the type integer which is incompatible with the type-hinted return boolean. Consider adding an additional type-check to rule them out.

    }

    public function retainAll(ModelElementInstanceImpl $referenceSourceParentElement, array $c): bool

The parameter $c is not used and could be removed.

The parameter $referenceSourceParentElement is not used and could be removed.

    {
        throw new UnsupportedModelOperationException("retainAll not implemented");
    }

    public function clear(ModelElementInstanceImpl $referenceSourceParentElement): void
    {
        if ($this->referenceSourceCollection->isImmutable()) {
            throw new UnsupportedModelOperationException("collection is immutable");
        }
        $view = [];
        $referenceSourceElements = $this->referenceSourceCollection->get($referenceSourceParentElement);
        foreach ($referenceSourceElements as $referenceSourceElement) {
            $view[] = $referenceSourceElement->getDomElement();
        }
        $this->performClearOperation($referenceSourceParentElement, $view);
    }

    public function getReferenceTargetElements(ModelElementInstanceImpl $referenceSourceParentElement): array
    {
        return ModelUtil::getModelElementCollection(
            $this->getView($referenceSourceParentElement),
            $referenceSourceParentElement->getModelInstance()
        );
    }
}