Stratadox\EntityState\StateRepresentation

Complexity

Total Complexity

19

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	current()	0	3	1
A	count()	0	3	1
A	offsetGet()	0	3	1
A	key()	0	3	1
A	offsetExists()	0	3	1
A	entityStates()	0	3	1
A	with()	0	5	1
A	offsetUnset()	0	3	1
A	__construct()	0	6	1
A	add()	0	14	2
A	offsetSet()	0	3	1
A	changesSince()	0	3	1
A	rewind()	0	3	1
A	addToMapIfNew()	0	12	2
A	valid()	0	3	1
A	next()	0	3	1
A	identityMap()	0	3	1

<?php declare(strict_types=1);

namespace Stratadox\EntityState;

use Stratadox\IdentityMap\MapsObjectsByIdentity;

final class StateRepresentation implements State
{
    private $entityStates;
    private $map;

    public function __construct(
        ListsEntityStates $entities,
        MapsObjectsByIdentity $map
    ) {
        $this->entityStates = $entities;
        $this->map = $map;
    }

    public static function with(
        ListsEntityStates $entities,
        MapsObjectsByIdentity $map
    ): State {
        return new self($entities, $map);
    }

    public function entityStates(): ListsEntityStates
    {
        return $this->entityStates;
    }

    public function identityMap(): MapsObjectsByIdentity
    {
        return $this->map;
    }

    public function add(State $additional): State
    {
        $entityStates = $this->entityStates;
        $map = $this->map;
        foreach ($additional->entityStates() as $entityState) {
            $entityStates = $entityStates->add($entityState);
            $map = $this->addToMapIfNew(
                $map,
                $additional->identityMap(),
                $entityState->class(),
                $entityState->id()
            );
        }
        return new self($entityStates, $map);
    }

    public function changesSince(State $previous): TellsWhatChanged
    {
        return $this->entityStates->changesSince($previous->entityStates());
    }

    public function offsetExists($offset): bool
    {
        return $this->entityStates->offsetExists($offset);
    }

    public function offsetGet($offset): RepresentsEntity
    {
        return $this->entityStates->offsetGet($offset);
    }

    public function offsetSet($offset, $value): void
    {
        $this->entityStates->offsetSet($offset, $value);
    }

    public function offsetUnset($offset): void
    {
        $this->entityStates->offsetUnset($offset);
    }

    public function next(): void
    {
        $this->entityStates->next();
    }

    public function key(): int
    {
        return $this->entityStates->key();
    }

    public function valid(): bool
    {
        return $this->entityStates->valid();
    }

    public function rewind(): void
    {
        $this->entityStates->rewind();
    }

    public function current(): RepresentsEntity
    {
        return $this->entityStates->current();
    }

    public function count(): int
    {
        return $this->entityStates->count();
    }

    private function addToMapIfNew(
        MapsObjectsByIdentity $map,
        MapsObjectsByIdentity $additionalMap,
        string $class,
        string $id
    ): MapsObjectsByIdentity {
        if ($map->has($class, $id)) {
            return $map;
        }
        return $map->add(
            $id,
            $additionalMap->get($class, $id)
        );
    }
}