SignpostMarv\DaftObject\DaftWriteableObjectMemoryTree

Complexity

Total Complexity

57

Size/Duplication

Total Lines	570
Duplicated Lines	0 %

Test Coverage

Coverage

95.9%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	ModifyDaftNestedObjectTreeRemoveWithId()	0	14	3
A	ModifyDaftNestedObjectTreeInsertMaybeLooseIntoTree()	0	17	5
A	UpdateRoots()	0	11	3
A	StoreThenRetrieveFreshLeaf()	0	8	1
A	ModifyDaftNestedObjectTreeRemoveWithObject()	0	29	4
A	RebuildTreeInefficiently()	0	4	1
A	ModifyDaftNestedObjectTreeInsertBelow()	0	6	1
A	ModifyDaftNestedObjectTreeRemoveWithIdUsingRootObject()	0	30	5
A	MaybeRemoveWithPossibleObject()	0	13	2
A	ModifyDaftNestedObjectTreeInsertAbove()	0	9	1
A	UpdateRemoveThenRebuild()	0	9	1
A	MaybeGetLeaf()	0	21	3
A	ModifyDaftNestedObjectTreeInsertAdjacent()	0	43	6
A	ModifyDaftNestedObjectTreeInsertLooseIntoTree()	0	38	3
A	ModifyDaftNestedObjectTreeInsert()	0	19	4
A	ModifyDaftNestedObjectTreeInsertLoose()	0	43	4
A	RebuildAfterInsert()	0	6	1
A	ModifyDaftNestedObjectTreeRemoveWithObjectPrepareRemovalAndRebuild()	0	10	1
A	RecallDaftNestedWriteableObjectOrThrow()	0	22	2
A	RememberDaftObject()	0	36	5
A	SiblingsExceptLeaf()	0	26	1

<?php
/**
* Base daft objects.
*
* @author SignpostMarv
*/
declare(strict_types=1);

namespace SignpostMarv\DaftObject;

use BadMethodCallException;
use InvalidArgumentException;
use RuntimeException;

/**
* @template T as DaftNestedWriteableObject
*
* @template-extends DaftObjectMemoryTree<T>
*
* @template-implements DaftNestedWriteableObjectTree<T>
*/
abstract class DaftWriteableObjectMemoryTree extends DaftObjectMemoryTree implements DaftNestedWriteableObjectTree
{
    const DEFINITELY_BELOW = false;

    const EXCLUDE_ROOT = false;

    const INSERT_AFTER = false;

    const LIMIT_ONE = 1;

    const RELATIVE_DEPTH_SAME = 0;

    const INT_ARG_INDEX_SECOND = 2;

    /**
    * {@inheritdoc}
    *
    * @psalm-return T
    */
    public function RecallDaftNestedWriteableObjectOrThrow($id) : DaftNestedWriteableObject
    {
        /**
        * @var DaftNestedWriteableObject|null
        *
        * @psalm-var T|null
        */
        $out = $this->RecallDaftNestedObjectOrThrow($id);

        if (is_null($out)) {
            throw new DaftObjectNotRecalledException(
                'Argument 1 passed to ' .
                DaftNestedWriteableObjectTree::class .
                '::RecallDaftNestedWriteableObjectOrThrow() did not resolve to an instance of ' .
                DaftNestedWriteableObject::class .
                ' from ' .
                static::class .
                '::RecallDaftObject()'
            );
        }

        return $out;

The expression return $out returns the type SignpostMarv\DaftObject\DaftNestedObject which includes types incompatible with the type-hinted return SignpostMarv\DaftObject\DaftNestedWriteableObject.

    }

    /**
    * @psalm-param T $newLeaf
    * @psalm-param T $referenceLeaf
    *
    * @psalm-return T
    */
    public function ModifyDaftNestedObjectTreeInsert(
        DaftNestedWriteableObject $newLeaf,
        DaftNestedWriteableObject $referenceLeaf,
        bool $before = self::INSERT_AFTER,
        bool $above = null
    ) : DaftNestedWriteableObject {
        if ($newLeaf->GetId() === $referenceLeaf->GetId()) {
            throw new InvalidArgumentException('Cannot modify leaf relative to itself!');
        }

        if ((bool) $above) {
            $this->ModifyDaftNestedObjectTreeInsertAbove($newLeaf, $referenceLeaf);
        } elseif (self::DEFINITELY_BELOW === $above) {
            $this->ModifyDaftNestedObjectTreeInsertBelow($newLeaf, $referenceLeaf);
        } else {
            $this->ModifyDaftNestedObjectTreeInsertAdjacent($newLeaf, $referenceLeaf, $before);
        }

        return $this->RebuildAfterInsert($newLeaf);
    }

    /**
    * @param DaftNestedWriteableObject|scalar|(scalar|array|object|null)[] $leaf
    * @param DaftNestedWriteableObject|scalar|(scalar|array|object|null)[] $referenceId
    *
    * @psalm-param T|scalar|(scalar|array|object|null)[] $leaf
    * @psalm-param T|scalar|(scalar|array|object|null)[] $referenceId
    *
    * @psalm-return T
    */
    public function ModifyDaftNestedObjectTreeInsertLoose(
        $leaf,
        $referenceId,
        bool $before = self::INSERT_AFTER,
        bool $above = null
    ) : DaftNestedWriteableObject {
        $leaf = $this->MaybeGetLeaf($leaf);

        $reference = $referenceId;

        if ( ! ($referenceId instanceof DaftNestedWriteableObject)) {
            /**
            * @var scalar|(scalar|array|object|null)[]
            */
            $referenceId = $referenceId;

            $reference = $this->RecallDaftObject($referenceId);
        }

        /**
        * @var DaftNestedWriteableObject|null
        *
        * @psalm-var T|null
        */
        $reference = $reference;

        $resp = $this->ModifyDaftNestedObjectTreeInsertMaybeLooseIntoTree(
            $this,
            $leaf,
            $reference,
            $referenceId === $this->GetNestedObjectTreeRootId(),
            $before,
            $above
        );

        if ($resp instanceof DaftNestedWriteableObject) {
            return $resp;
        }

        throw new InvalidArgumentException(sprintf(
            'Argument %u passed to %s() did not resolve to a leaf node!',
            is_null($leaf) ? self::INT_ARG_INDEX_FIRST : self::INT_ARG_INDEX_SECOND,
            __METHOD__
        ));
    }

    /**
    * @psalm-param T $root
    * @psalm-param T|null $replacementRoot
    */
    public function ModifyDaftNestedObjectTreeRemoveWithObject(
        DaftNestedWriteableObject $root,
        ? DaftNestedWriteableObject $replacementRoot
    ) : int {
        if (
            $this->CountDaftNestedObjectTreeWithObject(
                $root,
                false,
                null
            ) > AbstractArrayBackedDaftNestedObject::COUNT_EXPECT_NON_EMPTY &&
            is_null($replacementRoot)
        ) {
            throw new BadMethodCallException('Cannot leave orphan objects in a tree');
        }

        $root = $this->StoreThenRetrieveFreshLeaf($root);

        if ( ! is_null($replacementRoot)) {
            $this->ModifyDaftNestedObjectTreeRemoveWithObjectPrepareRemovalAndRebuild(
                $root,
                $replacementRoot
            );
        }

        $this->RemoveDaftObject($root);

        $this->RebuildTreeInefficiently();

        return $this->CountDaftNestedObjectFullTree();
    }

    /**
    * @param scalar|(scalar|array|object|null)[] $root
    * @param scalar|(scalar|array|object|null)[]|null $replacementRoot
    */
    public function ModifyDaftNestedObjectTreeRemoveWithId($root, $replacementRoot) : int
    {
        $rootObject = $this->RecallDaftObject($root);

        $resp = null;

        if ($rootObject instanceof DaftNestedWriteableObject) {
            $resp = $this->ModifyDaftNestedObjectTreeRemoveWithIdUsingRootObject(
                $replacementRoot,
                $rootObject
            );
        }

        return is_int($resp) ? $resp : $this->CountDaftNestedObjectFullTree();
    }

    /**
    * @psalm-param T $leaf
    *
    * @psalm-return T
    */
    public function StoreThenRetrieveFreshLeaf(
        DaftNestedWriteableObject $leaf
    ) : DaftNestedWriteableObject {
        $this->RememberDaftObject($leaf);
        $this->ForgetDaftObject($leaf);
        $this->ForgetDaftObjectById($leaf->GetId());

        return $this->RecallDaftNestedWriteableObjectOrThrow($leaf->GetId());
    }

    /**
    * @psalm-param T $object
    */
    public function RememberDaftObject(SuitableForRepositoryType $object) : void
    {
        /**
        * @var DaftNestedWriteableObject
        *
        * @psalm-var T
        */
        $object = $object;

        $left = $object->GetIntNestedLeft();

The method GetIntNestedLeft() does not exist on SignpostMarv\DaftObject\SuitableForRepositoryType. It seems like you code against a sub-type of SignpostMarv\DaftObject\SuitableForRepositoryType such as SignpostMarv\DaftObject\DaftNestedObject.

        $right = $object->GetIntNestedRight();

The method GetIntNestedRight() does not exist on SignpostMarv\DaftObject\SuitableForRepositoryType. It seems like you code against a sub-type of SignpostMarv\DaftObject\SuitableForRepositoryType such as SignpostMarv\DaftObject\DaftNestedObject.

        $level = $object->GetIntNestedLevel();

The method GetIntNestedLevel() does not exist on SignpostMarv\DaftObject\SuitableForRepositoryType. It seems like you code against a sub-type of SignpostMarv\DaftObject\SuitableForRepositoryType such as SignpostMarv\DaftObject\DaftNestedObject.

        if (0 === $left && 0 === $right && 0 === $level) {
            $fullTreeCount = $this->CountDaftNestedObjectFullTree();

            if ($fullTreeCount > AbstractArrayBackedDaftNestedObject::COUNT_EXPECT_NON_EMPTY) {
                $tree = $this->RecallDaftNestedObjectFullTree();

                /**
                * @var DaftNestedWriteableObject
                *
                * @psalm-var T
                */
                $end = end($tree);

                $left = $end->GetIntNestedRight() + 1;
            } else {
                $left = $fullTreeCount + $fullTreeCount;
            }

            $object->SetIntNestedLeft($left);

The method SetIntNestedLeft() does not exist on SignpostMarv\DaftObject\SuitableForRepositoryType. It seems like you code against a sub-type of SignpostMarv\DaftObject\SuitableForRepositoryType such as SignpostMarv\DaftObject\DaftNestedWriteableObject or SignpostMarv\DaftObject\AbstractArrayBackedDaftNestedObject.

            $object->SetIntNestedRight($left + 1);

The method SetIntNestedRight() does not exist on SignpostMarv\DaftObject\SuitableForRepositoryType. It seems like you code against a sub-type of SignpostMarv\DaftObject\SuitableForRepositoryType such as SignpostMarv\DaftObject\DaftNestedWriteableObject or SignpostMarv\DaftObject\AbstractArrayBackedDaftNestedObject.

        }

        parent::RememberDaftObject($object);
    }

    /**
    * @psalm-param T $newLeaf
    * @psalm-param T $referenceLeaf
    */
    protected function ModifyDaftNestedObjectTreeInsertAdjacent(
        DaftNestedWriteableObject $newLeaf,
        DaftNestedWriteableObject $referenceLeaf,
        bool $before
    ) : void {
        /**
        * @var array<int, DaftNestedWriteableObject>
        *
        * @psalm-var array<int, T>
        */
        $siblings = $this->SiblingsExceptLeaf($newLeaf, $referenceLeaf);

        $siblingIds = [];
        $siblingSort = [];
        $j = count($siblings);

        foreach ($siblings as $leaf) {
            /**
            * @var scalar|(scalar|array|object|null)[]
            */
            $siblingId = $leaf->GetId();
            $siblingIds[] = $siblingId;
            $siblingSort[] = $leaf->GetIntNestedSortOrder();
        }

        $pos = array_search($referenceLeaf->GetId(), $siblingIds, true);

        if (false === $pos) {
            throw new RuntimeException('Reference leaf not found in siblings tree!');
        }

        for ($i = 0; $i < $j; ++$i) {
            $siblings[$i]->SetIntNestedSortOrder(
                $siblingSort[$i] +
                (($before ? ($i < $pos) : ($i <= $pos)) ? self::DECREMENT : self::INCREMENT)
            );
            $this->StoreThenRetrieveFreshLeaf($siblings[$i]);
        }

        $newLeaf->SetIntNestedSortOrder($siblingSort[$pos]);
        $newLeaf->AlterDaftNestedObjectParentId($referenceLeaf->ObtainDaftNestedObjectParentId());

        $this->StoreThenRetrieveFreshLeaf($newLeaf);
    }

    protected function RebuildTreeInefficiently() : void
    {
        $rebuilder = new InefficientDaftNestedRebuild($this);
        $rebuilder->RebuildTree();
    }

    /**
    * @psalm-param T|null $leaf
    * @psalm-param T|null $reference
    *
    * @psalm-return T|null
    */
    private function ModifyDaftNestedObjectTreeInsertMaybeLooseIntoTree(
        DaftNestedWriteableObjectTree $tree,
        ? DaftNestedWriteableObject $leaf,
        ? DaftObject $reference,
        bool $isRoot,
        bool $before,
        ? bool $above
    ) : ? DaftNestedWriteableObject {
        if ( ! is_null($leaf) && (($reference instanceof DaftNestedWriteableObject) || $isRoot)) {
            if ($reference instanceof DaftNestedWriteableObject) {
                return $tree->ModifyDaftNestedObjectTreeInsert($leaf, $reference, $before, $above);
            }

            return $this->ModifyDaftNestedObjectTreeInsertLooseIntoTree($leaf, $before, $above);
        }

        return null;
    }

    /**
    * @psalm-param T $newLeaf
    *
    * @psalm-return T
    */
    private function RebuildAfterInsert(
        DaftNestedWriteableObject $newLeaf
    ) : DaftNestedWriteableObject {
        $this->RebuildTreeInefficiently();

        return $this->RecallDaftNestedWriteableObjectOrThrow($newLeaf->GetId());
    }

    /**
    * @psalm-param T $root
    * @psalm-param T $replacementRoot
    */
    private function ModifyDaftNestedObjectTreeRemoveWithObjectPrepareRemovalAndRebuild(
        DaftNestedWriteableObject $root,
        DaftNestedWriteableObject $replacementRoot
    ) : void {
        /**
        * @var scalar|(scalar|array|object|null)[]
        */
        $replacementRootId = $this->StoreThenRetrieveFreshLeaf($replacementRoot)->GetId();

        $this->UpdateRoots($root, $replacementRootId);
    }

    /**
    * @param scalar|(scalar|array|object|null)[] $replacementRootId
    *
    * @psalm-param T $root
    */
    private function UpdateRoots(DaftNestedWriteableObject $root, $replacementRootId) : void
    {
        /**
        * @var array<int, DaftNestedObject>
        */
        $alterThese = $this->RecallDaftNestedObjectTreeWithObject($root, false, self::LIMIT_ONE);

        foreach ($alterThese as $alter) {
            if ($alter instanceof DaftNestedWriteableObject) {
                $alter->AlterDaftNestedObjectParentId($replacementRootId);
                $this->RememberDaftObject($alter);
            }
        }
    }

    /**
    * @param DaftNestedWriteableObject|scalar|(scalar|array|object|null)[] $leaf
    *
    * @psalm-param T|scalar|(scalar|array|object|null)[] $leaf
    */
    private function MaybeGetLeaf($leaf) : ? DaftNestedWriteableObject
    {
        if ($leaf === $this->GetNestedObjectTreeRootId()) {
            throw new InvalidArgumentException('Cannot pass root id as new leaf');
        } elseif ($leaf instanceof DaftNestedWriteableObject) {
            return $this->StoreThenRetrieveFreshLeaf($leaf);
        }

        /**
        * @psalm-var scalar|(scalar|array|object|null)[]
        */
        $leaf = $leaf;

        /**
        * @var DaftNestedWriteableObject|null
        *
        * @psalm-var T|null
        */
        $out = $this->RecallDaftObject($leaf);

        return $out;

The expression return $out could return the type SignpostMarv\DaftObject\SuitableForRepositoryType which includes types incompatible with the type-hinted return SignpostMarv\DaftObject\DaftNestedWriteableObject|null. Consider adding an additional type-check to rule them out.

    }

    /**
    * @psalm-param T $leaf
    *
    * @psalm-return T
    */
    private function ModifyDaftNestedObjectTreeInsertLooseIntoTree(
        DaftNestedWriteableObject $leaf,
        bool $before,
        ? bool $above
    ) : DaftNestedWriteableObject {
        /**
        * @var array<int, DaftNestedWriteableObject>
        *
        * @psalm-var array<int, T>
        */
        $leaves = $this->RecallDaftNestedObjectFullTree(self::RELATIVE_DEPTH_SAME);
        $leaves = array_filter(
            $leaves,
            /**
            * @psalm-param T $e
            */
            function (DaftNestedWriteableObject $e) use ($leaf) : bool {
                return $e->GetId() !== $leaf->GetId();
            }
        );

        /**
        * @var false|DaftNestedWriteableObject
        *
        * @psalm-var false|T
        */
        $reference = $before ? current($leaves) : end($leaves);

        if ( ! ($reference instanceof DaftNestedWriteableObject)) {
            $leaf->SetIntNestedLeft(0);
            $leaf->SetIntNestedRight(1);
            $leaf->SetIntNestedLevel(0);
            $leaf->AlterDaftNestedObjectParentId($this->GetNestedObjectTreeRootId());

            return $this->StoreThenRetrieveFreshLeaf($leaf);
        }

        return $this->ModifyDaftNestedObjectTreeInsert($leaf, $reference, $before, $above);
    }

    /**
    * @psalm-param T $rootObject
    * @psalm-param T|null $replacementRootObject
    */
    private function MaybeRemoveWithPossibleObject(
        DaftNestedWriteableObject $rootObject,
        ? DaftObject $replacementRootObject
    ) : int {
        if ( ! ($replacementRootObject instanceof DaftNestedWriteableObject)) {
            throw new InvalidArgumentException(
                'Could not locate replacement root, cannot leave orphan objects!'
            );
        }

        return $this->ModifyDaftNestedObjectTreeRemoveWithObject(
            $rootObject,
            $replacementRootObject
        );
    }

    /**
    * @param scalar|(scalar|array|object|null)[] $replacementRoot
    *
    * @psalm-param T $rootObject
    */
    private function UpdateRemoveThenRebuild(
        DaftNestedWriteableObject $rootObject,
        $replacementRoot
    ) : void {
        $this->UpdateRoots($rootObject, $replacementRoot);

        $this->RemoveDaftObject($rootObject);

        $this->RebuildTreeInefficiently();
    }

    /**
    * @psalm-param T $newLeaf
    * @psalm-param T $referenceLeaf
    */
    private function ModifyDaftNestedObjectTreeInsertAbove(
        DaftNestedWriteableObject $newLeaf,
        DaftNestedWriteableObject $referenceLeaf
    ) : void {
        $newLeaf->AlterDaftNestedObjectParentId($referenceLeaf->ObtainDaftNestedObjectParentId());
        $referenceLeaf->AlterDaftNestedObjectParentId($newLeaf->GetId());

        $this->StoreThenRetrieveFreshLeaf($newLeaf);
        $this->StoreThenRetrieveFreshLeaf($referenceLeaf);
    }

    /**
    * @psalm-param T $newLeaf
    * @psalm-param T $referenceLeaf
    */
    private function ModifyDaftNestedObjectTreeInsertBelow(
        DaftNestedWriteableObject $newLeaf,
        DaftNestedWriteableObject $referenceLeaf
    ) : void {
        $newLeaf->AlterDaftNestedObjectParentId($referenceLeaf->GetId());
        $this->StoreThenRetrieveFreshLeaf($newLeaf);
    }

    /**
    * @psalm-param T $newLeaf
    * @psalm-param T $referenceLeaf
    *
    * @psalm-return array<int, T>
    */
    private function SiblingsExceptLeaf(
        DaftNestedWriteableObject $newLeaf,
        DaftNestedWriteableObject $referenceLeaf
    ) : array {
        /**
        * @var array<int, DaftNestedWriteableObject>
        *
        * @psalm-var array<int, T>
        */
        $siblings = $this->RecallDaftNestedObjectTreeWithId(
            $referenceLeaf->ObtainDaftNestedObjectParentId(),
            self::EXCLUDE_ROOT,
            self::RELATIVE_DEPTH_SAME
        );

        $siblings = array_values(array_filter(
            $siblings,
            /**
            * @psalm-param T $leaf
            */
            function (DaftNestedWriteableObject $leaf) use ($newLeaf) : bool {
                return $leaf->GetId() !== $newLeaf->GetId();
            }
        ));

        return $siblings;
    }

    /**
    * @param scalar|(scalar|array|object|null)[]|null $replacementRoot
    *
    * @psalm-param T $rootObject
    */
    private function ModifyDaftNestedObjectTreeRemoveWithIdUsingRootObject(
        $replacementRoot,
        DaftNestedWriteableObject $rootObject
    ) : ? int {
        if (
            $this->CountDaftNestedObjectTreeWithObject(
                $rootObject,
                false,
                null
            ) > AbstractArrayBackedDaftNestedObject::COUNT_EXPECT_NON_EMPTY &&
            is_null($replacementRoot)
        ) {
            throw new BadMethodCallException('Cannot leave orphan objects in a tree');
        } elseif (
            ! is_null($replacementRoot) &&
            $replacementRoot !== $this->GetNestedObjectTreeRootId()
        ) {
            $replacementRoot = $this->RecallDaftObject($replacementRoot);

            return $this->MaybeRemoveWithPossibleObject($rootObject, $replacementRoot);
        }

        /**
        * @var scalar|(scalar|array|object|null)[]
        */
        $replacementRoot = $replacementRoot;

        $this->UpdateRemoveThenRebuild($rootObject, $replacementRoot);

        return null;
    }
}