bingo-soft / xml

src/Impl/Instance/ModelElementInstanceImpl.php

<?php

namespace Xml\Impl\Instance;

use Xml\{
    ModelBuilder
};
use Xml\Impl\{
    ModelInstanceImpl
};
use Xml\Impl\Util\ModelUtil;
use Xml\Instance\{
    DomElementInterface,
    ModelElementInstanceInterface
};
use Xml\Type\{
    ModelElementTypeInterface
};
use Xml\Exception\ModelException;

class ModelElementInstanceImpl implements ModelElementInstanceInterface
{
    protected $modelInstance;

    private $domElement;

    private $elementType;

    public static function registerType(ModelBuilder $modelBuilder): void
    {
        $typeBuilder = $modelBuilder->defineType(ModelElementInstanceInterface::class, "")->abstractType();
        $typeBuilder->build();
    }

    public function __construct(ModelTypeInstanceContext $instanceContext)
    {
        $this->domElement = $instanceContext->getDomElement();
        $this->modelInstance = $instanceContext->getModel();
        $this->elementType = $instanceContext->getModelType();
    }

    public function getDomElement(): ?DomElementInterface
    {
        return $this->domElement;
    }

    public function getModelInstance(): ModelInstanceImpl
    {
        return $this->modelInstance;
    }

    public function getParentElement(): ?ModelElementInstanceInterface
    {
        $parentElement = $this->domElement->getParentElement();

The method getParentElement() does not exist on Xml\Instance\DomElementInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Xml\Instance\DomElementInterface.

        if ($parentElement !== null) {
            return ModelUtil::getModelElement($parentElement, $this->modelInstance);
        } else {
            return null;
        }
    }

    public function getElementType(): ModelElementTypeInterface
    {
        return $this->elementType;
    }

    public function getAttributeValue(string $attributeName): ?string
    {
        return $this->domElement->getAttribute(null, $attributeName);
    }

    public function getAttributeValueNs(string $namespaceUri, string $attributeName): ?string
    {
        return $this->domElement->getAttribute($namespaceUri, $attributeName);
    }

    public function setAttributeValue(
        string $attributeName,
        string $xmlValue,
        bool $isIdAttribute = false,
        bool $withReferenceUpdate = true
    ): void {
        $oldValue = $this->getAttributeValue($attributeName);
        if ($isIdAttribute) {
            $this->domElement->setIdAttribute(null, $attributeName, $xmlValue);
        } else {
            $this->domElement->setAttribute(null, $attributeName, $xmlValue, $isIdAttribute);
        }
        $attribute = $this->elementType->getAttribute($attributeName);
        if ($attribute !== null && $withReferenceUpdate) {
            $attribute->updateIncomingReferences($this, $xmlValue, $oldValue);

The method updateIncomingReferences() does not exist on Xml\Type\Attribute\AttributeInterface. Did you maybe mean getIncomingReferences()?

        }
    }

    public function setAttributeValueNs(
        string $namespaceUri,
        string $attributeName,
        string $xmlValue,
        bool $isIdAttribute = false,
        bool $withReferenceUpdate = true
    ): void {
        $namespaceForSetting = $this->determineNamespace($namespaceUri, $attributeName);
        $oldValue = $this->getAttributeValueNs($namespaceForSetting, $attributeName);
        if ($isIdAttribute) {
            $this->domElement->setIdAttribute($namespaceForSetting, $attributeName, $xmlValue);
        } else {
            $this->domElement->setAttribute($namespaceForSetting, $attributeName, $xmlValue, false);
        }
        $attribute = $this->elementType->getAttribute($attributeName);
        if ($attribute !== null && $withReferenceUpdate) {
            $attribute->updateIncomingReferences($this, $xmlValue, $oldValue);
        }
    }

    private function determineNamespace(string $intendedNamespace, string $attributeName): string
    {
        $isSetInIntendedNamespace = $this->getAttributeValueNs($intendedNamespace, $attributeName) !== null;
        if ($isSetInIntendedNamespace) {
            return $intendedNamespace;
        } else {
            $alternativeNamespaces = $this->modelInstance->getModel()->getAlternativeNamespaces($intendedNamespace);
            if (!empty($alternativeNamespaces)) {
                foreach ($alternativeNamespaces as $alternativeNamespace) {
                    if ($this->getAttributeValueNs($alternativeNamespace, $attributeName) !== null) {
                        return $alternativeNamespace;
                    }
                }
            }
            return $intendedNamespace;
        }
    }

    public function removeAttribute(string $attributeName): void
    {
        $attribute = $this->elementType->getAttribute($attributeName);
        if ($attribute !== null) {
            $identifier = $attribute->getValue($this);
            if ($identifier !== null) {
                $attribute->unlinkReference($this, $identifier);

The method unlinkReference() does not exist on Xml\Type\Attribute\AttributeInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Xml\Type\Attribute\AttributeInterface.

            }
        }
        $this->domElement->removeAttribute(null, $attributeName);
    }

    public function removeAttributeNs(string $namespaceUri, string $attributeName): void
    {
        $attribute = $this->elementType->getAttribute($attributeName);
        if ($attribute !== null) {
            $identifier = $attribute->getValue($this);
            if ($identifier !== null) {
                $attribute->unlinkReference($this, $identifier);
            }
        }
        $this->domElement->removeAttribute($namespaceUri, $attributeName);
    }

    public function getTextContent(): string
    {
        return trim($this->getRawTextContent());
    }

    public function setTextContent(string $textContent): void
    {
        $this->domElement->setTextContent($textContent);
    }

    public function getRawTextContent(): string
    {
        return $this->domElement->getTextContent();
    }

    public function getUniqueChildElementByNameNs(
        string $namespaceUri,
        string $elementName
    ): ?ModelElementInstanceInterface {
        $model = $this->modelInstance->getModel();
        $childElements = $this->domElement->getChildElementsByNameNs(
            [$namespaceUri, ...$model->getAlternativeNamespaces($namespaceUri)],
            $elementName
        );
        if (!empty($childElements)) {
            return ModelUtil::getModelElement($childElements[0], $this->modelInstance);
        } else {
            return null;
        }
    }

    public function getUniqueChildElementByType(
        string $elementType
    ): ?ModelElementInstanceInterface {
        $childElements = $this->domElement->getChildElementsByType($this->modelInstance, $elementType);
        if (!empty($childElements)) {
            return ModelUtil::getModelElement($childElements[0], $this->modelInstance);
        } else {
            return null;
        }
    }

    public function setUniqueChildElementByNameNs(ModelElementInstanceInterface $newChild): void
    {
        ModelUtil::ensureInstanceOf($newChild, ModelElementInstanceImpl::class);
        $newChildElement = $newChild;
        $childElement =  $newChildElement->getDomElement();
        $existingChild = $this->getUniqueChildElementByNameNs(
            $childElement->getNameSpaceURI(),
            $childElement->getLocalName()
        );
        if ($existingChild === null) {
            $this->addChildElement($newChild);
        } else {
            $this->replaceChildElement($existingChild, $newChildElement);
        }
    }

    public function replaceChildElement(
        ModelElementInstanceInterface $existingChild,
        ModelElementInstanceInterface $newChild
    ): void {
        $existingChildDomElement = $existingChild->getDomElement();
        $newChildDomElement = $newChild->getDomElement();
        $existingChild->unlinkAllChildReferences();

The method unlinkAllChildReferences() does not exist on Xml\Instance\ModelElementInstanceInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Xml\Instance\ModelElementInstanceInterface.

        $this->updateIncomingReferences($existingChild, $newChild);
        $this->domElement->replaceChild($newChildDomElement, $existingChildDomElement);

It seems like $existingChildDomElement can also be of type null; however, parameter $existingChildDomElement of Xml\Instance\DomElementInterface::replaceChild() does only seem to accept Xml\Instance\DomElementInterface, maybe add an additional type check?

It seems like $newChildDomElement can also be of type null; however, parameter $newChildDomElement of Xml\Instance\DomElementInterface::replaceChild() does only seem to accept Xml\Instance\DomElementInterface, maybe add an additional type check?

        $newChild->updateAfterReplacement();
    }

    private function updateIncomingReferences(
        ModelElementInstanceInterface $oldInstance,
        ModelElementInstanceInterface $newInstance
    ): void {
        $oldId = $oldInstance->getAttributeValue("id");
        $newId = $newInstance->getAttributeValue("id");

        if ($oldId === null || $newId === null) {
            return;
        }

        $attributes = $oldInstance->getElementType()->getAllAttributes();

The method getAllAttributes() does not exist on Xml\Type\ModelElementTypeInterface. Did you maybe mean getAttributes()?

        foreach ($attributes as $attribute) {
            if ($attribute->isIdAttribute()) {
                foreach ($attribute->getIncomingReferences() as $incomingReference) {
                    $incomingReference->referencedElementUpdated($newInstance, $oldId, $newId);
                }
            }
        }
    }

    public function replaceWithElement(ModelElementInstanceInterface $newElement): void
    {
        $parentElement = $this->getParentElement();
        if ($parentElement !== null) {
            $parentElement->replaceChildElement($this, $newElement);
        } else {
            throw new ModelException("Unable to remove replace without parent");
        }
    }

    public function addChildElement(ModelElementInstanceInterface $newChild): void
    {
        ModelUtil::ensureInstanceOf($newChild, ModelElementInstanceImpl::class);
        $elementToInsertAfter = $this->findElementToInsertAfter($newChild);
        $this->insertElementAfter($newChild, $elementToInsertAfter);
    }

    public function removeChildElement(ModelElementInstanceInterface $child): bool
    {
        $child->unlinkAllReferences();

The method unlinkAllReferences() does not exist on Xml\Instance\ModelElementInstanceInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Xml\Instance\ModelElementInstanceInterface.

        $child->unlinkAllChildReferences();
        $res = $this->domElement->removeChild($child->getDomElement());

It seems like $child->getDomElement() can also be of type null; however, parameter $domElement of Xml\Instance\DomElementInterface::removeChild() does only seem to accept Xml\Instance\DomElementInterface, maybe add an additional type check?

        return $res;
    }

    /**
     * @param mixed $childElementType
     */
    public function getChildElementsByType($childElementType): array
    {
        if ($childElementType instanceof ModelElementTypeInterface) {
            $instances = [];
            foreach ($childElementType->getExtendingTypes() as $extendingType) {
                $instances = array_merge($instances, $this->getChildElementsByType($extendingType));
            }
            $model = $this->modelInstance->getModel();
            $alternativeNamespaces = $model->getAlternativeNamespaces($childElementType->getTypeNamespace());

It seems like $childElementType->getTypeNamespace() can also be of type null; however, parameter $actualNs of Xml\Impl\ModelImpl::getAlternativeNamespaces() does only seem to accept string, maybe add an additional type check?

            $elements = $this->domElement->getChildElementsByNameNs(
                [$childElementType->getTypeNamespace(), ...$alternativeNamespaces],
                $childElementType->getTypeName()
            );
            $instances = array_merge($instances, ModelUtil::getModelElementCollection($elements, $this->modelInstance));
            return $instances;
        } elseif (
            is_subclass_of($childElementType, ModelElementInstanceImpl::class) ||
            is_subclass_of($childElementType, ModelElementInstanceInterface::class)
        ) {
            return $this->getChildElementsByType($this->getModelInstance()->getModel()->getType($childElementType));
        }
        return [];
    }

    private function findElementToInsertAfter(
        ModelElementInstanceInterface $elementToInsert
    ): ?ModelElementInstanceInterface {
        $childElementTypes = $this->elementType->getAllChildElementTypes();
        $childDomElements = $this->domElement->getChildElements();
        $childElements = ModelUtil::getModelElementCollection($childDomElements, $this->modelInstance);
        $insertAfterElement = null;
        $newElementTypeIndex = ModelUtil::getIndexOfElementType($elementToInsert, $childElementTypes);
        foreach ($childElements as $childElement) {
            $childElementTypeIndex = ModelUtil::getIndexOfElementType($childElement, $childElementTypes);
            if ($newElementTypeIndex >= $childElementTypeIndex) {
                $insertAfterElement = $childElement;
            } else {
                break;
            }
        }
        return $insertAfterElement;
    }

    public function insertElementAfter(
        ModelElementInstanceInterface $elementToInsert,
        ?ModelElementInstanceInterface $insertAfterElement
    ): void {
        if ($insertAfterElement === null || $insertAfterElement->getDomElement() === null) {
            $this->domElement->insertChildElementAfter($elementToInsert->getDomElement(), null);

It seems like $elementToInsert->getDomElement() can also be of type null; however, parameter $elementToInsert of Xml\Instance\DomElementInterface::insertChildElementAfter() does only seem to accept Xml\Instance\DomElementInterface, maybe add an additional type check?

        } else {
            $this->domElement->insertChildElementAfter(
                $elementToInsert->getDomElement(),
                $insertAfterElement->getDomElement()
            );
        }
    }

    public function updateAfterReplacement(): void
    {
        //
    }

    private function unlinkAllReferences(): void
    {
        $attributes = $this->elementType->getAllAttributes();
        foreach ($attributes as $attribute) {
            $identifier = $attribute->getValue($this);
            if ($identifier !== null) {
                $attribute->unlinkReference($this, $identifier);
            }
        }
    }

    private function unlinkAllChildReferences(): void
    {
        $childElementTypes = $this->elementType->getAllChildElementTypes();
        foreach ($childElementTypes as $type) {
            $childElementsForType = $this->getChildElementsByType($type);
            foreach ($childElementsForType as $childElement) {
                $childElement->unlinkAllReferences();
            }
        }
    }

    public function equals(?ModelElementInstanceInterface $obj): bool
    {
        if ($obj === null) {
            return false;
        } else {
            return $obj->domElement->equals($this->domElement);

Accessing domElement on the interface Xml\Instance\ModelElementInstanceInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
    }
}