MabeEnum\EnumMap

Complexity

Total Complexity

19

Size/Duplication

Total Lines	176
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getKeys()	0	3	1
A	getValues()	0	3	1
A	contains()	0	8	2
A	offsetExists()	0	7	2
A	getEnumeration()	0	3	1
A	__construct()	0	10	2
A	getIterator()	0	5	2
A	offsetGet()	0	12	3
A	offsetUnset()	0	4	1
A	count()	0	3	1
A	search()	0	8	2
A	offsetSet()	0	4	1

<?php

declare(strict_types=1);

namespace MabeEnum;

use ArrayAccess;
use Countable;
use InvalidArgumentException;
use Iterator;
use IteratorAggregate;
use UnexpectedValueException;

/**
 * A map of enumerators (EnumMap<T>) and mixed values.
 *
 * @copyright 2019 Marc Bennewitz
 * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
 * @link http://github.com/marc-mabe/php-enum for the canonical source repository
 */

Missing @category tag in class comment

Missing @package tag in class comment

Missing @author tag in class comment

class EnumMap implements ArrayAccess, Countable, IteratorAggregate
{
    /**
     * The classname of the enumeration type
     * @var string
     */
    private $enumeration;

Expected 1 blank line before member var; 0 found

Private member variable "enumeration" must contain a leading underscore

    /**
     * Internal map of ordinal number and value
     * @var array
     */
    private $map = [];

Private member variable "map" must contain a leading underscore

    /**
     * Constructor
     * @param string $enumeration The classname of the enumeration type

Parameter comment must end with a full stop

     * @throws InvalidArgumentException

Comment missing for @throws tag in function comment

     */
    public function __construct(string $enumeration)
    {
        if (!\is_subclass_of($enumeration, Enum::class)) {
            throw new InvalidArgumentException(\sprintf(
                '%s can handle subclasses of %s only',
                 __CLASS__,
                Enum::class
            ));
        }
        $this->enumeration = $enumeration;
    }

    /**
     * Get the classname of the enumeration
     * @return string
     */
    public function getEnumeration(): string
    {
        return $this->enumeration;
    }

    /**
     * Get a list of map keys
     * @return Enum[]
     */
    public function getKeys(): array
    {
        return \array_map([$this->enumeration, 'byOrdinal'], \array_keys($this->map));
    }

    /**
     * Get a list of map values
     * @return mixed[]
     */
    public function getValues(): array
    {
        return \array_values($this->map);
    }

    /**
     * Search for the given value
     * @param mixed $value

Missing parameter comment

     * @param bool $strict Use strict type comparison

Expected "boolean" but found "bool" for parameter type

Expected 2 spaces after parameter type; 1 found

Parameter comment must end with a full stop

     * @return Enum|null The found key or NULL
     */
    public function search($value, bool $strict = false)

Incorrect spacing between argument "$strict" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$strict"; expected 0 but found 1

    {
        $ord = \array_search($value, $this->map, $strict);
        if ($ord !== false) {
            return ($this->enumeration)::byOrdinal($ord);
        }

        return null;
    }

    /**
     * Test if the given enumerator exists
     * @param Enum|null|bool|int|float|string|array $enumerator

Missing parameter comment

Expected "Enum|null|boolean|integer|float|string|array" but found "Enum|null|bool|int|float|string|array" for parameter type

     * @return bool

Expected "boolean" but found "bool" for function return type

     * @see offsetExists
     */
    public function contains($enumerator): bool
    {
        try {
            $ord = ($this->enumeration)::get($enumerator)->getOrdinal();
            return \array_key_exists($ord, $this->map);
        } catch (InvalidArgumentException $e) {
            // An invalid enumerator can't be contained in this map
            return false;
        }
    }

    /**
     * Test if the given enumerator key exists and is not NULL
     * @param Enum|null|bool|int|float|string|array $enumerator

Missing parameter comment

Expected "Enum|null|boolean|integer|float|string|array" but found "Enum|null|bool|int|float|string|array" for parameter type

     * @return bool

Expected "boolean" but found "bool" for function return type

     * @see contains
     */
    public function offsetExists($enumerator): bool
    {
        try {
            return isset($this->map[($this->enumeration)::get($enumerator)->getOrdinal()]);
        } catch (InvalidArgumentException $e) {
            // An invalid enumerator can't be an offset of this map
            return false;
        }
    }

    /**
     * Get mapped data for the given enumerator
     * @param Enum|null|bool|int|float|string|array $enumerator

Missing parameter comment

Expected "Enum|null|boolean|integer|float|string|array" but found "Enum|null|bool|int|float|string|array" for parameter type

     * @return mixed
     * @throws InvalidArgumentException On an invalid given enumerator

@throws tag comment must end with a full stop

     * @throws UnexpectedValueException If the given enumerator does not exist in this map

@throws tag comment must end with a full stop

     */
    public function offsetGet($enumerator)
    {
        $enumerator = ($this->enumeration)::get($enumerator);
        $ord = $enumerator->getOrdinal();
        if (!isset($this->map[$ord]) && !\array_key_exists($ord, $this->map)) {
            throw new UnexpectedValueException(sprintf(
                'Enumerator %s could not be found',
                \var_export($enumerator->getValue(), true)
            ));
        }

        return $this->map[$ord];
    }

    /**
     * Attach a new enumerator or overwrite an existing one
     * @param Enum|null|bool|int|float|string|array $enumerator

Missing parameter comment

Expected "Enum|null|boolean|integer|float|string|array" but found "Enum|null|bool|int|float|string|array" for parameter type

     * @param mixed                                 $value

Missing parameter comment

     * @return void
     * @throws InvalidArgumentException On an invalid given enumerator

@throws tag comment must end with a full stop

     * @see attach()
     */
    public function offsetSet($enumerator, $value = null): void

Incorrect spacing between argument "$value" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$value"; expected 0 but found 1

    {
        $ord = ($this->enumeration)::get($enumerator)->getOrdinal();
        $this->map[$ord] = $value;
    }

    /**
     * Detach an existing enumerator
     * @param Enum|null|bool|int|float|string|array $enumerator

Missing parameter comment

Expected "Enum|null|boolean|integer|float|string|array" but found "Enum|null|bool|int|float|string|array" for parameter type

     * @return void
     * @throws InvalidArgumentException On an invalid given enumerator

@throws tag comment must end with a full stop

     * @see detach()
     */
    public function offsetUnset($enumerator): void
    {
        $ord = ($this->enumeration)::get($enumerator)->getOrdinal();
        unset($this->map[$ord]);
    }

    /**
     * Get a new Iterator.
     *
     * @return Iterator
     */
    public function getIterator(): Iterator
    {
        $map = $this->map;
        foreach ($map as $ordinal => $value) {
            yield ($this->enumeration)::byOrdinal($ordinal) => $value;
        }
    }

    /**
     * Count the number of elements
     *
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function count(): int
    {
        return \count($this->map);
    }
}