webshell

Ghost Exploiter Team Official

Directory >> /home/softsuitetech/public_html/DEMO/download_l4g/vendor/sebastian/type/src/type/

File / Folder	Size	Action
.	-
.htaccess	0.27KB	edt ren
CallableType.php	4.983KB	edt ren
FalseType.php	0.859KB	edt ren
GenericObjectType.php	1.048KB	edt ren
IntersectionType.php	2.724KB	edt ren
IterableType.php	1.849KB	edt ren
MixedType.php	0.775KB	edt ren
NeverType.php	0.697KB	edt ren
NullType.php	0.772KB	edt ren
ObjectType.php	1.582KB	edt ren
SimpleType.php	2.003KB	edt ren
StaticType.php	1.432KB	edt ren
TrueType.php	0.854KB	edt ren
Type.php	4.672KB	edt ren
UnionType.php	2.884KB	edt ren
UnknownType.php	0.761KB	edt ren
VoidType.php	0.693KB	edt ren

<?php declare(strict_types=1);
/*
 * This file is part of sebastian/type.
 *
 * (c) Sebastian Bergmann <sebastian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace SebastianBergmann\Type;

use function assert;
use function count;
use function implode;
use function in_array;
use function sort;

final class IntersectionType extends Type
{
    /**
     * @psalm-var non-empty-list<Type>
     */
    private $types;

/**
     * @throws RuntimeException
     */
    public function __construct(Type ...$types)
    {
        $this->ensureMinimumOfTwoTypes(...$types);
        $this->ensureOnlyValidTypes(...$types);
        $this->ensureNoDuplicateTypes(...$types);

$this->types = $types;
    }

public function isAssignable(Type $other): bool
    {
        return $other->isObject();
    }

public function asString(): string
    {
        return $this->name();
    }

public function name(): string
    {
        $types = [];

foreach ($this->types as $type) {
            $types[] = $type->name();
        }

sort($types);

return implode('&', $types);
    }

public function allowsNull(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true IntersectionType $this
     */
    public function isIntersection(): bool
    {
        return true;
    }

/**
     * @psalm-return non-empty-list<Type>
     */
    public function types(): array
    {
        return $this->types;
    }

/**
     * @throws RuntimeException
     */
    private function ensureMinimumOfTwoTypes(Type ...$types): void
    {
        if (count($types) < 2) {
            throw new RuntimeException(
                'An intersection type must be composed of at least two types'
            );
        }
    }

/**
     * @throws RuntimeException
     */
    private function ensureOnlyValidTypes(Type ...$types): void
    {
        foreach ($types as $type) {
            if (!$type->isObject()) {
                throw new RuntimeException(
                    'An intersection type can only be composed of interfaces and classes'
                );
            }
        }
    }

/**
     * @throws RuntimeException
     */
    private function ensureNoDuplicateTypes(Type ...$types): void
    {
        $names = [];

foreach ($types as $type) {
            assert($type instanceof ObjectType);

$classQualifiedName = $type->className()->qualifiedName();

if (in_array($classQualifiedName, $names, true)) {
                throw new RuntimeException('An intersection type must not contain duplicate types');
            }

$names[] = $classQualifiedName;
        }
    }
}

<=Back