Sauls\Component\Helper\Operation\TypeOperation\Collection\ConverterCollection

Complexity

Total Complexity

12

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	set()	0	6	1
A	removeDuplicateConverters()	0	3	1
A	resolveType()	0	3	1
A	__construct()	0	7	2
A	add()	0	4	2
A	sort()	0	14	3
A	get()	0	7	2

<?php
/**
 * This file is part of the sauls/helpers package.
 *
 * @author    Saulius Vaičeliūnas <vaiceliunas@inbox.lt>
 * @link      http://saulius.vaiceliunas.lt
 * @copyright 2018
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sauls\Component\Helper\Operation\TypeOperation\Collection;

use Sauls\Component\Helper\Exception\InvalidTypeConverterException;
use Sauls\Component\Helper\Operation\TypeOperation\Converter\ConverterInterface;

class ConverterCollection implements ConverterCollectionInterface
{
    private $converters = [];

    private static $typeAliases = [
        'boolean' => 'bool',
        'integer' => 'int',
        'long' => 'int',
        'double' => 'float',
        'real' => 'float',
        '[]' => 'array',
    ];

    public function __construct($converters = [])
    {
        if ($converters instanceof \Traversable) {
            $converters = iterator_to_array($converters);
        }

        $this->add($converters);
    }

    public function add(array $converters): void
    {
        foreach ($converters as $ensurer) {
            $this->set($ensurer);
        }
    }

    public function set(ConverterInterface $converter): void
    {
        $type = $this->resolveType($converter->getType());
        $this->converters[$type][] = $converter;
        $this->removeDuplicateConverters($type);
        $this->sort($type);
    }

    private function removeDuplicateConverters($type): void
    {
        $this->converters[$type] = array_unique($this->converters[$type], SORT_REGULAR);
    }

    private function sort(string $type): void
    {
        uasort(
            $this->converters[$this->resolveType($type)],
            function (ConverterInterface $ensurer1, ConverterInterface $ensurer2) {

                $priority1 = $ensurer1->getPriority();
                $priority2 = $ensurer2->getPriority();

                if ($priority1 === $priority2) {
                    return 0;
                }

                return ($priority1 > $priority2) ? -1 : 1;
            }
        );
    }

    /**
     * @return array|ConverterInterface[]
     *
     * @throws \Sauls\Component\Helper\Exception\InvalidTypeConverterException
     */
    public function get(string $type): array
    {
        try {
            return $this->converters[$this->resolveType($type)];
        } catch (\Throwable $t) {
            throw new InvalidTypeConverterException(
                sprintf('Invalid converter type `%s`.', $type)
            );
        }
    }

    /**
     * @param string $type
     *
     * @return mixed
     */
    private function resolveType(string $type)
    {
        return \strtr($type, self::$typeAliases);
    }
}