SignpostMarv\DaftObject\DaftObjectMemoryRepository

Complexity

Total Complexity

15

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	RecallDaftObject()	0	9	2
A	ForgetDaftObjectById()	0	3	1
A	RememberDaftObjectData()	0	9	2
A	RemoveDaftObjectById()	0	3	1
A	RemoveDaftObjectByHashId()	0	6	2
A	RememberDaftObject()	0	9	1
A	ObjectHashId()	0	10	2
A	RecallDaftObjectFromData()	0	15	2
A	ForgetDaftObjectByHashId()	0	4	2

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

namespace SignpostMarv\DaftObject;

class DaftObjectMemoryRepository extends AbstractDaftObjectRepository
{
    /**
    * @var DefinesOwnIdPropertiesInterface[]
    */
    protected $memory = [];

    /**
    * mixed[][].
    */
    protected $data = [];

    public function RememberDaftObject(DefinesOwnIdPropertiesInterface $object) : void
    {
        static::ThrowIfNotType($object, $this->type, 1, __FUNCTION__);

        $hashId = $object::DaftObjectIdHash($object);

        $this->memory[$hashId] = $object;

        $this->RememberDaftObjectData($object);
    }

    /**
    * @param mixed $id
    */
    public function ForgetDaftObjectById($id) : void
    {
        $this->ForgetDaftObjectByHashId($this->ObjectHashId($id));
    }

    /**
    * @param mixed $id
    */
    public function RemoveDaftObjectById($id) : void
    {
        $this->RemoveDaftObjectByHashId($this->ObjectHashId($id));
    }

    /**
    * @param mixed $id
    */
    public function RecallDaftObject($id) : ? DaftObject
    {
        $hashId = $this->ObjectHashId($id);

        if (false === isset($this->memory[$hashId])) {
            return $this->RecallDaftObjectFromData($id);
        }

        return $this->memory[$hashId];
    }

    protected function RememberDaftObjectData(DefinesOwnIdPropertiesInterface $object) : void
    {
        $hashId = $object::DaftObjectIdHash($object);

        $this->data[$hashId] = [];

        foreach ($object::DaftObjectPublicGetters() as $property) {
            $getter = 'Get' . ucfirst($property);
            $this->data[$hashId][$property] = $object->$getter();
        }
    }

    /**
    * Recalls the corresponding daft object instance from cached data.
    *
    * @param mixed $id
    */
    protected function RecallDaftObjectFromData($id) : ? DaftObject
    {
        $hashId = $this->ObjectHashId($id);
        if (true === isset($this->data[$hashId])) {
            $type = $this->type;

            /**
            * @var DaftObject $out
            */
            $out = new $type($this->data[$hashId]);

            return $out;
        }

        return null;
    }

    /**
    * Converts an id to a unique-enough-for-now string.
    *
    * @param mixed $id
    */
    private function ObjectHashId($id) : string
    {
        $id = is_array($id) ? $id : [$id];

        /**
        * @var DefinesOwnIdPropertiesInterface $type
        */
        $type = $this->type;

        return $type::DaftObjectIdValuesHash($id);
    }

    private function ForgetDaftObjectByHashId(string $hashId) : void
    {
        if (true === isset($this->memory[$hashId])) {
            unset($this->memory[$hashId]);
        }
    }

    private function RemoveDaftObjectByHashId(string $hashId) : void
    {
        $this->ForgetDaftObjectByHashId($hashId);

        if (true === isset($this->data[$hashId])) {
            unset($this->data[$hashId]);
        }
    }
}