TypedArrays\AbstractTypedArray

Complexity

Total Complexity

41

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	guardChildTypeToEnforce()	0	7	3
A	collectionType()	0	3	1
A	guardOffsetSetList()	0	8	4
A	isMutable()	0	3	1
A	checkType()	0	12	4
A	guardInstanceTypeToEnforce()	0	8	3
A	guardMutability()	0	4	2
A	guardOffsetSetMap()	0	7	3
A	checkForValidClass()	0	4	2
A	guardOffsetSetType()	0	7	2
A	checkForScalar()	0	3	1
A	offsetSet()	0	8	1
A	offsetUnset()	0	5	1
A	guardInstanceList()	0	7	3
A	guardInstanceMap()	0	8	4
A	getType()	0	5	2
A	guardChildCollectionType()	0	4	2
A	isNullAllowed()	0	3	1

<?php

declare(strict_types=1);

namespace TypedArrays;

use ArrayObject;
use TypedArrays\Exceptions\GuardException;
use TypedArrays\Exceptions\InvalidTypeException;

abstract class AbstractTypedArray extends ArrayObject
{
    protected const SCALAR_BOOLEAN = 'boolean';
    protected const SCALAR_INTEGER = 'integer';
    protected const SCALAR_DOUBLE = 'double';
    protected const SCALAR_STRING = 'string';

    protected const COLLECTION_TYPE_ARRAY = 'array';
    protected const COLLECTION_TYPE_LIST = 'list';
    protected const COLLECTION_TYPE_MAP = 'map';

    private const POSSIBLE_SCALARS = [
        self::SCALAR_BOOLEAN,
        self::SCALAR_INTEGER,
        self::SCALAR_DOUBLE,
        self::SCALAR_STRING,
    ];

    private const POSSIBLE_COLLECTION_TYPES = [
        self::COLLECTION_TYPE_ARRAY,
        self::COLLECTION_TYPE_LIST,
        self::COLLECTION_TYPE_MAP,
    ];

    abstract protected function typeToEnforce(): string;

    protected function collectionType(): string
    {
        return self::COLLECTION_TYPE_ARRAY;
    }

    protected function isMutable(): bool
    {
        return true;
    }

    protected function isNullAllowed(): bool
    {
        return false;
    }

    /**
     * @throws InvalidTypeException
     * @throws GuardException
     */
    public function __construct(array $input = [])
    {
        $this->guardChildCollectionType();
        $this->guardChildTypeToEnforce();

        $this->guardInstanceTypeToEnforce($input);
        $this->guardInstanceList($input);
        $this->guardInstanceMap($input);

        parent::__construct($input);
    }

    /**
     * @param mixed $key
     * @param mixed $value
     *
     * @throws InvalidTypeException
     * @throws GuardException
     */
    public function offsetSet($key, $value): void
    {
        $this->guardMutability();
        $this->guardOffsetSetList($key);
        $this->guardOffsetSetMap($key);
        $this->guardOffsetSetType($value);

        parent::offsetSet($key, $value);
    }

    /**
     * @param mixed $key
     *
     * @throws GuardException
     */
    public function offsetUnset($key): void
    {
        $this->guardMutability();

        parent::offsetUnset($key);
    }

    /**
     * @throws GuardException
     */
    private function guardChildCollectionType(): void
    {
        if (!in_array($this->collectionType(), self::POSSIBLE_COLLECTION_TYPES)) {
            throw GuardException::invalidCollectionType($this->collectionType());
        }
    }

    /**
     * @throws GuardException
     */
    private function guardChildTypeToEnforce(): void
    {
        if (
            !$this->checkForValidClass()
            && !$this->checkForScalar()
        ) {
            throw GuardException::invalidEnforceType($this->typeToEnforce());
        }
    }

    private function checkForValidClass(): bool
    {
        return class_exists($this->typeToEnforce())
            || interface_exists($this->typeToEnforce());
    }

    private function checkForScalar(): bool
    {
        return in_array($this->typeToEnforce(), self::POSSIBLE_SCALARS);
    }

    /**
     * @throws InvalidTypeException
     */
    private function guardInstanceTypeToEnforce(array $input): void
    {
        foreach ($input as $item) {
            if (!$this->checkType($item)) {
                throw InvalidTypeException::onInstantiate(
                    static::class,
                    static::getType($item),
                    $this->typeToEnforce()
                );
            }
        }
    }

    /**
     * @param mixed $variable
     */
    private function checkType($variable): bool
    {
        if ($variable === null) {
            return $this->isNullAllowed();
        }

        if (is_object($variable)) {
            return get_class($variable) === $this->typeToEnforce()
                || is_subclass_of($variable, $this->typeToEnforce());
        }

        return static::getType($variable) === $this->typeToEnforce();
    }

    /**
     * @param mixed $variable
     */
    private static function getType($variable): string
    {
        return is_object($variable)
            ? get_class($variable)
            : gettype($variable);
    }

    /**
     * @throws GuardException
     */
    private function guardInstanceList(array $input): void
    {
        if (
            $this->collectionType() === self::COLLECTION_TYPE_LIST
            && array_values($input) !== $input
        ) {
            throw GuardException::keysNotAllowedInList();
        }
    }

    /**
     * @throws GuardException
     */
    private function guardInstanceMap(array $input): void
    {
        if (
            !empty($input)
            && $this->collectionType() === self::COLLECTION_TYPE_MAP
            && array_values($input) === $input
        ) {
            throw GuardException::keysRequiredInMap();
        }
    }

    /**
     * @throws GuardException
     */
    private function guardMutability(): void
    {
        if (!$this->isMutable()) {
            throw GuardException::immutableCannotMutate();
        }
    }

    /**
     * @param mixed $key
     *
     * @throws GuardException
     */
    private function guardOffsetSetList($key): void
    {
        if (
            isset($key)
            && $this->collectionType() === self::COLLECTION_TYPE_LIST
            && !isset($this[$key])
        ) {
            throw GuardException::keysNotAllowedInList();
        }
    }

    /**
     * @param mixed $key
     *
     * @throws GuardException
     */
    private function guardOffsetSetMap($key): void
    {
        if (
            !isset($key)
            && $this->collectionType() === self::COLLECTION_TYPE_MAP
        ) {
            throw GuardException::keysRequiredInMap();
        }
    }

    /**
     * @param mixed $value
     *
     * @throws InvalidTypeException
     */
    private function guardOffsetSetType($value): void
    {
        if (!$this->checkType($value)) {
            throw InvalidTypeException::onAdd(
                static::class,
                static::getType($value),
                $this->typeToEnforce()
            );
        }
    }
}