Webmozart\Assert\Extra

Complexity

Total Complexity

47

Size/Duplication

Total Lines	488
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

47 Methods

Rating	Name	Duplication	Size	Complexity
A	nullOrString()	0	4	1
A	allString()	0	4	1
A	nullOrStringNotEmpty()	0	4	1
A	allStringNotEmpty()	0	4	1
A	nullOrInteger()	0	4	1
A	allInteger()	0	4	1
A	nullOrIntegerish()	0	4	1
A	allIntegerish()	0	4	1
A	nullOrFloat()	0	4	1
A	allFloat()	0	4	1
A	nullOrNumeric()	0	4	1
A	allNumeric()	0	4	1
A	nullOrNatural()	0	4	1
A	allNatural()	0	4	1
A	nullOrBoolean()	0	4	1
A	allBoolean()	0	4	1
A	nullOrScalar()	0	4	1
A	allScalar()	0	4	1
A	nullOrObject()	0	4	1
A	allObject()	0	4	1
A	nullOrResource()	0	4	1
A	allResource()	0	4	1
A	nullOrIsCallable()	0	4	1
A	allIsCallable()	0	4	1
A	nullOrIsArray()	0	4	1
A	allIsArray()	0	4	1
A	nullOrIsTraversable()	0	4	1
A	allIsTraversable()	0	4	1
A	nullOrIsCountable()	0	4	1
A	allIsCountable()	0	4	1
A	nullOrIsIterable()	0	4	1
A	allIsIterable()	0	4	1
A	nullOrIsInstanceOf()	0	4	1
A	allIsInstanceOf()	0	4	1
A	nullOrIsEmpty()	0	4	1
A	allIsEmpty()	0	4	1
A	allNull()	0	4	1
A	nullOrTrue()	0	4	1
A	allTrue()	0	4	1
A	nullOrFalse()	0	4	1
A	allFalse()	0	4	1
A	nullOrOneOf()	0	4	1
A	allOneOf()	0	4	1
A	nullOrClassExists()	0	4	1
A	allClassExists()	0	4	1
A	nullOrInterfaceExists()	0	4	1
A	allInterfaceExists()	0	4	1

<?php

/**
 * Automatically generated
 */

namespace Webmozart\Assert;

class Extra extends Assert

Since you have declared the constructor as private, maybe you should also declare the class as final.

{
    /**
     * @psalm-assert null|string $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrString($value, $message = '')
    {
        parent::nullOrString($value, $message);
    }

    /**
     * @psalm-assert array<array-key,string> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allString($value, $message = '')
    {
        parent::allString($value, $message);
    }

    /**
     * @psalm-assert null|string $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrStringNotEmpty($value, $message = '')
    {
        parent::nullOrStringNotEmpty($value, $message);
    }

    /**
     * @psalm-assert array<array-key,string> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allStringNotEmpty($value, $message = '')
    {
        parent::allStringNotEmpty($value, $message);
    }

    /**
     * @psalm-assert null|int $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrInteger($value, $message = '')
    {
        parent::nullOrInteger($value, $message);
    }

    /**
     * @psalm-assert array<array-key,int> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allInteger($value, $message = '')
    {
        parent::allInteger($value, $message);
    }

    /**
     * @psalm-assert null|numeric $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrIntegerish($value, $message = '')
    {
        parent::nullOrIntegerish($value, $message);
    }

    /**
     * @psalm-assert array<array-key,numeric> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allIntegerish($value, $message = '')
    {
        parent::allIntegerish($value, $message);
    }

    /**
     * @psalm-assert null|float $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrFloat($value, $message = '')
    {
        parent::nullOrFloat($value, $message);
    }

    /**
     * @psalm-assert array<array-key,float> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allFloat($value, $message = '')
    {
        parent::allFloat($value, $message);
    }

    /**
     * @psalm-assert null|numeric $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrNumeric($value, $message = '')
    {
        parent::nullOrNumeric($value, $message);
    }

    /**
     * @psalm-assert array<array-key,numeric> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allNumeric($value, $message = '')
    {
        parent::allNumeric($value, $message);
    }

    /**
     * @psalm-assert null|int $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrNatural($value, $message = '')
    {
        parent::nullOrNatural($value, $message);
    }

    /**
     * @psalm-assert array<array-key,int> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allNatural($value, $message = '')
    {
        parent::allNatural($value, $message);
    }

    /**
     * @psalm-assert null|bool $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrBoolean($value, $message = '')
    {
        parent::nullOrBoolean($value, $message);
    }

    /**
     * @psalm-assert array<array-key,bool> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allBoolean($value, $message = '')
    {
        parent::allBoolean($value, $message);
    }

    /**
     * @psalm-assert null|scalar $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrScalar($value, $message = '')
    {
        parent::nullOrScalar($value, $message);
    }

    /**
     * @psalm-assert array<array-key,scalar> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allScalar($value, $message = '')
    {
        parent::allScalar($value, $message);
    }

    /**
     * @psalm-assert null|object $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrObject($value, $message = '')
    {
        parent::nullOrObject($value, $message);
    }

    /**
     * @psalm-assert array<array-key,object> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allObject($value, $message = '')
    {
        parent::allObject($value, $message);
    }

    /**
     * @psalm-assert null|resource $value
     * @param mixed $value
     * @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
     * @param string $message
     */
    public static function nullOrResource($value, $type = null, $message = '')
    {
        parent::nullOrResource($value, $type, $message);
    }

    /**
     * @psalm-assert array<array-key,resource> $value
     * @param mixed $value
     * @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
     * @param string $message
     */
    public static function allResource($value, $type = null, $message = '')
    {
        parent::allResource($value, $type, $message);
    }

    /**
     * @psalm-assert null|callable $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrIsCallable($value, $message = '')
    {
        parent::nullOrIsCallable($value, $message);
    }

    /**
     * @psalm-assert array<array-key,callable> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allIsCallable($value, $message = '')
    {
        parent::allIsCallable($value, $message);
    }

    /**
     * @psalm-assert null|array $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrIsArray($value, $message = '')
    {
        parent::nullOrIsArray($value, $message);
    }

    /**
     * @psalm-assert array<array-key,array> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allIsArray($value, $message = '')
    {
        parent::allIsArray($value, $message);
    }

    /**
     * @psalm-assert null|iterable $value
     * @deprecated use "isIterable" or "isInstanceOf" instead
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrIsTraversable($value, $message = '')
    {
        parent::nullOrIsTraversable($value, $message);
    }

    /**
     * @psalm-assert array<array-key,iterable> $value
     * @deprecated use "isIterable" or "isInstanceOf" instead
     * @param mixed $value
     * @param string $message
     */
    public static function allIsTraversable($value, $message = '')
    {
        parent::allIsTraversable($value, $message);
    }

    /**
     * @psalm-assert null|countable $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrIsCountable($value, $message = '')
    {
        parent::nullOrIsCountable($value, $message);
    }

    /**
     * @psalm-assert array<array-key,countable> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allIsCountable($value, $message = '')
    {
        parent::allIsCountable($value, $message);
    }

    /**
     * @psalm-assert null|iterable $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrIsIterable($value, $message = '')
    {
        parent::nullOrIsIterable($value, $message);
    }

    /**
     * @psalm-assert array<array-key,iterable> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allIsIterable($value, $message = '')
    {
        parent::allIsIterable($value, $message);
    }

    /**
     * @psalm-template ExpectedType of object
     * @psalm-param class-string<ExpectedType> $class
     * @psalm-assert null|ExpectedType $value
     * @param mixed $value
     * @param string|object $class
     * @param string $message
     */
    public static function nullOrIsInstanceOf($value, $class, $message = '')
    {
        parent::nullOrIsInstanceOf($value, $class, $message);
    }

    /**
     * @psalm-template ExpectedType of object
     * @psalm-param class-string<ExpectedType> $class
     * @psalm-assert array<array-key,ExpectedType> $value
     * @param mixed $value
     * @param string|object $class
     * @param string $message
     */
    public static function allIsInstanceOf($value, $class, $message = '')
    {
        parent::allIsInstanceOf($value, $class, $message);
    }

    /**
     * @psalm-assert null|empty $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrIsEmpty($value, $message = '')
    {
        parent::nullOrIsEmpty($value, $message);
    }

    /**
     * @psalm-assert array<array-key,empty> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allIsEmpty($value, $message = '')
    {
        parent::allIsEmpty($value, $message);
    }

    /**
     * @psalm-assert array<array-key,null> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allNull($value, $message = '')
    {
        parent::allNull($value, $message);
    }

    /**
     * @psalm-assert null|true $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrTrue($value, $message = '')
    {
        parent::nullOrTrue($value, $message);
    }

    /**
     * @psalm-assert array<array-key,true> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allTrue($value, $message = '')
    {
        parent::allTrue($value, $message);
    }

    /**
     * @psalm-assert null|false $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrFalse($value, $message = '')
    {
        parent::nullOrFalse($value, $message);
    }

    /**
     * @psalm-assert array<array-key,false> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allFalse($value, $message = '')
    {
        parent::allFalse($value, $message);
    }

    /**
     * @psalm-template ExpectedType
     * @psalm-param array<ExpectedType> $values
     * @psalm-assert null|ExpectedType $value
     * @param mixed $value
     * @param array $values
     * @param string $message
     */
    public static function nullOrOneOf($value, $values, $message = '')
    {
        parent::nullOrOneOf($value, $values, $message);
    }

    /**
     * @psalm-template ExpectedType
     * @psalm-param array<ExpectedType> $values
     * @psalm-assert array<array-key,ExpectedType> $value
     * @param mixed $value
     * @param array $values
     * @param string $message
     */
    public static function allOneOf($value, $values, $message = '')
    {
        parent::allOneOf($value, $values, $message);

The call to Assert::allOneOf() has too many arguments starting with $message.

    }

    /**
     * @psalm-assert null|class-string $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrClassExists($value, $message = '')
    {
        parent::nullOrClassExists($value, $message);
    }

    /**
     * @psalm-assert array<array-key,class-string> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allClassExists($value, $message = '')
    {
        parent::allClassExists($value, $message);
    }

    /**
     * @psalm-assert null|class-string $value
     * @param mixed $value
     * @param string $message
     */
    public static function nullOrInterfaceExists($value, $message = '')
    {
        parent::nullOrInterfaceExists($value, $message);
    }

    /**
     * @psalm-assert array<array-key,class-string> $value
     * @param mixed $value
     * @param string $message
     */
    public static function allInterfaceExists($value, $message = '')
    {
        parent::allInterfaceExists($value, $message);
    }
}