SpareParts\Enum\Set\Converter\BitMaskConverter

Complexity

Total Complexity

14

Size/Duplication

Total Lines	85
Duplicated Lines	8.24 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

91.43%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	23	6
A	convertToEnumSet()	0	12	3
A	convertFromEnumSet()	0	9	2
A	setEnumClass()	7	7	3

<?php
namespace SpareParts\Enum\Set\Converter;

use SpareParts\Enum\Enum;
use SpareParts\Enum\Exception\EnumSetMustContainEnumsException;
use SpareParts\Enum\Exception\InvalidEnumClassException;
use SpareParts\Enum\Set\ISet;
use SpareParts\Enum\Set\ImmutableSet;

class BitMaskConverter implements IEnumSetConverter
{
    /**
     * @var string
     */
    private $enumClass;

    /**
     * @var array
     */
    private $mapping;


    /**
     * @param Enum[] $enumValuesMap
     */
    public function __construct($enumValuesMap)
    {
        if (!is_array($enumValuesMap) || !count($enumValuesMap)) {
            throw new EnumSetMustContainEnumsException('You have to provide converter mapping.');
        }

        // translate enum values to bit values mapping
        $innerMapping = [];
        $shift = 0;
        foreach ($enumValuesMap as $value) {
            // try to guess enum class
            if (is_null($this->enumClass)) {
                $this->setEnumClass(get_class($value));
            }
            if (!($value instanceof $this->enumClass)) {
                throw new EnumSetMustContainEnumsException(sprintf("Expected %s, got %s", $this->enumClass, get_class($value)));
            }
            $innerMapping[(string) $value] = 1 << $shift;
            $shift++;
        }

        $this->mapping = $innerMapping;
    }


    /**
     * @param int $values
     * @return ISet
     */
    public function convertToEnumSet($values)
    {
        $bitValue = (int) $values;

        $set = [];
        foreach ($this->mapping as $value => $bit) {
            if ($bitValue & $bit) {
                $set[] = call_user_func([$this->enumClass, 'instance'], $value);
            }
        }
        return new ImmutableSet($this->enumClass, $set);
    }


    /**
     * @param ISet $enumSet
     * @return int
     */
    public function convertFromEnumSet(ISet $enumSet)
    {
        $bitValue = 0;
        /** @var Enum $value */
        foreach ($enumSet as $value) {
            $bitValue = $bitValue | $this->mapping[(string) $value];
        }
        return $bitValue;
    }


    /**
     * @param string $enumClass
     */
    protected function setEnumClass($enumClass)

This method seems to be duplicated in your project.

    {
        if (!is_null($enumClass) && !is_subclass_of($enumClass, Enum::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \SpareParts\Enum\Enum::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            throw new InvalidEnumClassException("Class ${enumClass} does not implement Enum (as it should).");
        }
        $this->enumClass = $enumClass;
    }
}