Stratadox\IdentityMap\Whitelist

Complexity

Total Complexity

18

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	forThe()	0	10	2
A	the()	0	4	1
A	has()	0	4	1
A	hasThe()	0	4	1
A	get()	0	4	1
A	idOf()	0	4	1
A	add()	0	7	2
A	remove()	0	4	1
A	removeThe()	0	4	1
A	removeAllObjectsOfThe()	0	7	2
A	classes()	0	4	1
A	purgeIfNotIn()	0	10	2
A	newMap()	0	4	1

<?php
declare(strict_types=1);

namespace Stratadox\IdentityMap;

use function get_class;
use function in_array;

/**
 * Whitelist for the Identity Map.
 *
 * Used for whitelisting entities while loading objects.
 *
 * @see IdentityMap
 *
 * @author Stratadox
 */
final class Whitelist implements MapsObjectsByIdentity
{
    private $allow;
    private $map;

    private function __construct(array $allow, MapsObjectsByIdentity $map)
    {
        $this->allow = $allow;
        $this->map = $map;
    }

    /**
     * Constructs a whitelist for the identity map.
     *
     * @param MapsObjectsByIdentity $mapped            The actual identity map.
     * @param string                ...$allowedClasses The whitelisted classes.
     * @return MapsObjectsByIdentity                   The wrapped identity map.
     */
    public static function forThe(
        MapsObjectsByIdentity $mapped,
        string ...$allowedClasses
    ): MapsObjectsByIdentity {
        $alreadyMapped = $mapped->classes();
        foreach ($alreadyMapped as $class) {
            $mapped = Whitelist::purgeIfNotIn($allowedClasses, $mapped, $class);
        }
        return new Whitelist($allowedClasses, $mapped);
    }

    /**
     * Whitelists the given classes in the identity map.
     *
     * @param string ...$classes     The whitelisted classes.
     * @return MapsObjectsByIdentity The wrapped identity map.
     */
    public static function the(string ...$classes): MapsObjectsByIdentity
    {
        return new Whitelist($classes, IdentityMap::startEmpty());
    }

    /** @inheritdoc */
    public function has(string $class, string $id): bool
    {
        return $this->map->has($class, $id);
    }

    /** @inheritdoc */
    public function hasThe(object $object): bool
    {
        return $this->map->hasThe($object);
    }

    /** @inheritdoc */
    public function get(string $class, string $id): object
    {
        return $this->map->get($class, $id);
    }

    /** @inheritdoc */
    public function idOf(object $object): string
    {
        return $this->map->idOf($object);
    }

    /** @inheritdoc */
    public function add(string $id, object $object): MapsObjectsByIdentity
    {
        if (!in_array(get_class($object), $this->allow)) {
            return $this;
        }
        return $this->newMap($this->map->add($id, $object));
    }

    /** @inheritdoc */
    public function remove(string $class, string $id): MapsObjectsByIdentity
    {
        return $this->newMap($this->map->remove($class, $id));
    }

    /** @inheritdoc */
    public function removeThe(object $object): MapsObjectsByIdentity
    {
        return $this->newMap($this->map->removeThe($object));
    }

    /** @inheritdoc */
    public function removeAllObjectsOfThe(string $class): MapsObjectsByIdentity
    {
        if (!in_array($class, $this->allow)) {
            return $this;
        }
        return $this->newMap($this->map->removeAllObjectsOfThe($class));
    }

    /** @inheritdoc */
    public function classes(): array
    {
        return $this->map->classes();
    }

    private static function purgeIfNotIn(
        array $allowedClasses,
        MapsObjectsByIdentity $mapped,
        string $class
    ): MapsObjectsByIdentity {
        if (in_array($class, $allowedClasses)) {
            return $mapped;
        }
        return $mapped->removeAllObjectsOfThe($class);
    }

    private function newMap(MapsObjectsByIdentity $map): MapsObjectsByIdentity
    {
        return new Whitelist($this->allow, $map);
    }
}