Doctrine\Annotations\Type\IntersectionType

Complexity

Total Complexity

8

Size/Duplication

Total Lines	53
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	describe()	0	13	2
A	getSubTypes()	0	3	1
A	__construct()	0	7	2
A	validate()	0	11	3

<?php

declare(strict_types=1);

namespace Doctrine\Annotations\Type;

use Doctrine\Annotations\Type\Exception\CompositeTypeRequiresAtLeastTwoSubTypes;
use function array_map;
use function count;
use function implode;
use function sprintf;

/**
 * @internal
 */
final class IntersectionType implements CompositeType
{
    /** @var Type[] */
    private $subTypes;

    public function __construct(Type ...$subTypes)
    {
        if (count($subTypes) < 2) {
            throw CompositeTypeRequiresAtLeastTwoSubTypes::fromInsufficientAmount(count($subTypes));
        }

        $this->subTypes = $subTypes;
    }

    /**
     * @return Type[]
     */
    public function getSubTypes() : array
    {
        return $this->subTypes;
    }

    public function describe() : string
    {
        return implode(
            '&',
            array_map(
                static function (Type $subType) : string {
                    if ($subType instanceof CompositeType) {
                        return sprintf('(%s)', $subType->describe());
                    }

                    return $subType->describe();
                },
                $this->subTypes
            )
        );
    }

    /**
     * @param mixed $value
     */
    public function validate($value) : bool
    {
        foreach ($this->subTypes as $subType) {
            if ($subType->validate($value)) {
                continue;
            }

            return false;
        }

        return true;
    }
}