SpareParts\Enum\Set\Converter\BitMaskConverter

Complexity

Total Complexity

19

Size/Duplication

Total Lines	106
Duplicated Lines	11.32 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	3
A	convertToEnumSet()	12	12	3
A	convertFromEnumSet()	0	9	2
A	prepareInnerMapping()	0	13	2
A	fetchEnumClass()	0	10	4
A	setEnumClass()	0	7	3
A	printVar()	0	4	2

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

use SpareParts\Enum\Enum;
use SpareParts\Enum\Exception\EnumSetMustContainEnumsException;
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.');
        }
        $this->mapping = $this->prepareInnerMapping($enumValuesMap);
    }

    /**
     * @param int $values
     * @return ISet
     */
    public function convertToEnumSet($values)

This method seems to be duplicated in your project.

    {
        $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 $enumValuesMap
     * @return array
     */
    private function prepareInnerMapping($enumValuesMap)
    {
        // translate enum values to bit values mapping
        $innerMapping = [];
        $shift = 0;
        foreach ($enumValuesMap as $value) {
            $this->fetchEnumClass($value);

            $innerMapping[(string)$value] = 1 << $shift;
            $shift++;
        }
        return $innerMapping;
    }

    /**
     * @param $value
     */
    private function fetchEnumClass($value)
    {
        // try to guess enum class
        if (is_null($this->enumClass)) {
            $this->setEnumClass($value);
        }
        if (!is_object($value) || !($value instanceof $this->enumClass)) {
            throw new EnumSetMustContainEnumsException(sprintf("Expected `%s`, got `%s`", $this->enumClass, $this->printVar($value)));
        }
    }

    /**
     * @param mixed $enum
     */
    private function setEnumClass($enum)
    {
        if (!is_object($enum) || !is_subclass_of($enum, 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 EnumSetMustContainEnumsException(sprintf("Class %s does not implement Enum (as it should).", $this->printVar($enum)));
        }
        $this->enumClass = get_class($enum);
    }

    /**
     * @param mixed $value
     * @return string
     */
    private function printVar($value)
    {
        return is_object($value) ? get_class($value) : var_export($value, true);
    }
}