GpsLab\Component\Enum\Set

Complexity

Total Complexity

32

Size/Duplication

Total Lines	311
Duplicated Lines	18.01 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	values()	0	15	4
A	attach()	0	6	1
A	detach()	0	6	1
A	contains()	0	6	1
A	equal()	0	6	1
A	subset()	0	6	1
A	superset()	0	6	1
A	union()	14	14	2
A	intersect()	14	14	2
A	diff()	14	14	2
A	symDiff()	14	14	2
A	choices()	0	12	2
A	readable()	0	6	1
A	validateValue()	0	6	2
A	validateType()	0	7	2
A	detectConstants()	0	14	3
A	bit()	0	4	1
A	bits()	0	7	1

<?php

/**
 * GpsLab component.
 *
 * @author    Peter Gribanov <info@peter-gribanov.ru>
 * @copyright Copyright (c) 2017, Peter Gribanov
 * @license   http://opensource.org/licenses/MIT
 */

namespace GpsLab\Component\Enum;

use GpsLab\Component\Enum\Exception\InvalidSetException;
use GpsLab\Component\Enum\Exception\OutOfEnumException;

class Set
{
    /**
     * @var int
     */
    private $bit = 0;

    /**
     * @var mixed[][]
     */
    private static $bits = [];

    /**
     * @var mixed[][]
     */
    private static $keys = [];

    /**
     * @param array $values
     */
    final public function __construct(array $values = [])
    {
        foreach ($values as $value) {
            $this->attach($value);
        }
    }

    /**
     * @return mixed[]
     */
    final public function values()
    {
        if (!$this->bit) {
            return [];
        }

        $values = [];
        foreach (self::$bits[get_called_class()] as $bit => $value) {
            if ($this->bit & $bit) {
                $values[] = $value;
            }
        }

        return $values;
    }

    /**
     * Attach the given value.
     *
     * @param mixed $value
     */
    final public function attach($value)
    {
        self::validateValue($value);

        $this->bit |= $this->bit($value);
    }

    /**
     * Detach the given value.
     *
     * @param mixed $value
     */
    final public function detach($value)
    {
        self::validateValue($value);

        $this->bit ^= $this->bit($value);
    }

    /**
     * Given value was attached.
     *
     * @param mixed $value
     *
     * @return bool
     */
    final public function contains($value)
    {
        self::validateValue($value);

        return (bool) ($this->bit & $this->bit($value));
    }

    /**
     * Check if this Set is the same as other.
     *
     * @param Set $set
     *
     * @return bool
     */
    final public function equal(self $set)
    {
        self::validateType($set);

        return $this->bit === $this->bit;
    }

    /**
     * Check if this Set is a subset of other.
     *
     * @param Set $set
     *
     * @return bool
     */
    final public function subset(self $set)
    {
        self::validateType($set);

        return ($this->bit & $set->bit) === $this->bit;
    }

    /**
     * Check if this Set is a superset of other.
     *
     * @param Set $set
     *
     * @return bool
     */
    final public function superset(self $set)
    {
        self::validateType($set);

        return ($this->bit | $set->bit) === $this->bit;
    }

    /**
     * Produce a new set with enum from both this and other (this | other).
     *
     * @param Set ...$set Other Set(s) of the same enum to produce the union
     *
     * @return Set
     */
    final public function union(self $set)
    {
        $bit = $this->bit;
        foreach (func_get_args() as $arg) {
            self::validateType($arg);

            $bit |= $arg->bit;
        }

        $clone = new static();
        $clone->bit = $bit;

        return $clone;
    }

    /**
     * Produce a new set with enum common to both this and other (this & other).
     *
     * @param Set ...$set Other Set(s) of the same enumeration to produce the union
     *
     * @return Set
     */
    final public function intersect(self $set)
    {
        $bit = $this->bit;
        foreach (func_get_args() as $arg) {
            self::validateType($arg);

            $bit &= $arg->bit;
        }

        $clone = new static();
        $clone->bit = $bit;

        return $clone;
    }

    /**
     * Produce a new set with enum in this but not in other (this - other).
     *
     * @param Set ...$set Other Set(s) of the same enumeration to produce the union
     *
     * @return Set
     */
    final public function diff(self $set)
    {
        $bit = 0;
        foreach (func_get_args() as $arg) {
            self::validateType($arg);

            $bit |= $arg->bit;
        }

        $clone = new static();
        $clone->bit = $this->bit & ~$bit;

        return $clone;
    }

    /**
     * Produce a new set with enum in either this and other but not in both (this ^ (other | other)).
     *
     * @param Set ...$set Other Set(s) of the same enumeration to produce the union
     *
     * @return Set
     */
    final public function symDiff(self $set)
    {
        $bit = 0;
        foreach (func_get_args() as $arg) {
            self::validateType($arg);

            $bit |= $arg->bit;
        }

        $clone = new static();
        $clone->bit = $this->bit ^ $bit;

        return $clone;
    }

    /**
     * Get choices for checkbox group.
     *
     * <code>
     * {
     *   value1: 'Readable value 1',
     *   value2: 'Readable value 2',
     * }
     * </code>
     *
     * @return array
     */
    final public static function choices()
    {
        $class = get_called_class();
        self::detectConstants($class);

        $choices = [];
        foreach (self::$keys[$class] as $value) {
            $choices[$value] = static::readable($value);
        }

        return $choices;
    }

    /**
     * @param mixed $value
     *
     * @return string
     */
    public static function readable($value)
    {
        self::validateValue($value);

        return array_search($value, self::$keys[get_called_class()]);
    }

    /**
     * @param mixed $value
     */
    private static function validateValue($value)
    {
        if (!in_array($value, self::bits(), true)) {
            throw OutOfEnumException::invalidValue($value, get_called_class());
        }
    }

    /**
     * @param object $object
     */
    private static function validateType($object)
    {
        $class = get_called_class();
        if ($class !== get_class($object)) {
            throw InvalidSetException::notInstanceOf($class, get_class($object));
        }
    }

    /**
     * @param string $class
     */
    private static function detectConstants($class)
    {
        if (!isset(self::$bits[$class])) {
            self::$keys[$class] = [];
            self::$bits[$class] = [];

            $bit = 1;
            foreach (ConstantDetector::detect($class) as $constant => $constant_value) {
                self::$keys[$class][$constant] = $constant_value;
                self::$bits[$class][$bit] = $constant_value;
                $bit += $bit;
            }
        }
    }

    /**
     * @param mixed $value
     *
     * @return int
     */
    private function bit($value)
    {
        return array_search($value, self::bits(), true);
    }

    /**
     * @return array
     */
    private static function bits()
    {
        $class = get_called_class();
        self::detectConstants($class);

        return self::$bits[$class];
    }
}