mpyw\Co\Internal\CoOption

Complexity

Total Complexity

20

Size/Duplication

Total Lines	178
Duplicated Lines	8.99 %

Coupling/Cohesion

Components	2
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	setDefault()	0	4	1
A	getDefault()	0	4	1
A	__construct()	0	4	1
A	reconfigure()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	7	2
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	validateOptions()	0	11	3
A	validateNaturalFloat()	8	8	3
A	validateNaturalInt()	8	8	3
A	validateBool()	0	10	2

<?php

namespace mpyw\Co\Internal;

class CoOption implements \ArrayAccess
{
    /**
     * Field types.
     */
    const TYPES = [
        'throw' => 'Bool', // Throw CURLExceptions?
        'pipeline' => 'Bool', // Use HTTP/1.1 pipelining?
        'multiplex' => 'Bool', // Use HTTP/2 multiplexing?
        'interval' => 'NaturalFloat', // curl_multi_select() timeout
        'concurrency' => 'NaturalInt', // Limit of TCP connections
    ];

    /**
     * Default values.
     * @var array
     */
    private static $defaults = [
        'throw' => true,
        'pipeline' => false,
        'multiplex' => true,
        'interval' => 0.5,
        'concurrency' => 6,
    ];

    /**
     * Actual values.
     * @var array
     */
    private $options;

    /**
     * Set default options.
     * @param array $options
     */
    public static function setDefault(array $options)
    {
        self::$defaults = self::validateOptions($options) + self::$defaults;
    }

    /**
     * Get default options.
     * @return array $options
     */
    public static function getDefault()
    {
        return self::$defaults;
    }

    /**
     * Constructor.
     * @param array $options
     */
    public function __construct(array $options = [])
    {
        $this->options = self::validateOptions($options) + self::$defaults;
    }

    /**
     * Reconfigure to get new instance.
     * @return CoOption
     */
    public function reconfigure(array $options)
    {
        return new self($options + $this->options);
    }

    /**
     * Implemention of ArrayAccess.
     * @param  mixed $offset
     * @return bool
     */
    public function offsetExists($offset)
    {
        return isset($this->options[$offset]);
    }

    /**
     * Implemention of ArrayAccess.
     * @param  mixed $offset
     * @return mixed
     */
    public function offsetGet($offset)
    {
        if (!isset($this->options[$offset])) {
            throw new \DomainException('Undefined field: ' + $offset);
        }
        return $this->options[$offset];
    }

    /**
     * Implemention of ArrayAccess.
     * @param  mixed $offset
     * @param  mixed $value
     * @throws BadMethodCallException
     */
    public function offsetSet($offset, $value)
    {
        throw new \BadMethodCallException('The instance of CoOptions is immutable.');
    }

    /**
     * Implemention of ArrayAccess.
     * @param  mixed $offset
     * @throws BadMethodCallException
     */
    public function offsetUnset($offset)
    {
        throw new \BadMethodCallException('The instance of CoOptions is immutable.');
    }

    /**
     * Validate options.
     * @param  array $options
     * @return array
     */
    private static function validateOptions(array $options)
    {
        foreach ($options as $key => $value) {
            if (!isset(self::TYPES[$key])) {
                throw new \InvalidArgumentException("Unknown option: $key");
            }
            $validator = [__CLASS__, 'validate' . self::TYPES[$key]];
            $options[$key] = $validator($key, $value);
        }
        return $options;
    }

    /**
     * Validate bool value.
     * @param  string $key
     * @param  mixed  $value
     * @throws InvalidArgumentException
     * @return bool
     */
    private static function validateBool($key, $value)
    {
        $value = filter_var($value, FILTER_VALIDATE_BOOLEAN, [
            'flags' => FILTER_NULL_ON_FAILURE,
        ]);
        if ($value === null) {
            throw new \InvalidArgumentException("Option[$key] must be boolean.");
        }
        return $value;
    }

    /**
     * Validate natural float value.
     * @param  string $key
     * @param  mixed  $value
     * @throws InvalidArgumentException
     * @return float
     */
    private static function validateNaturalFloat($key, $value)
    {
        $value = filter_var($value, FILTER_VALIDATE_FLOAT);
        if ($value === false || $value < 0.0) {
            throw new \InvalidArgumentException("Option[$key] must be positive float or zero.");
        }
        return $value;
    }

    /**
     * Validate natural int value.
     * @param  string $key
     * @param  mixed  $value
     * @throws InvalidArgumentException
     * @return int
     */
    private static function validateNaturalInt($key, $value)
    {
        $value = filter_var($value, FILTER_VALIDATE_INT);
        if ($value === false || $value < 0) {
            throw new \InvalidArgumentException("Option[$key] must be positive integer or zero.");
        }
        return $value;
    }
}