Final Class Yiisoft\Validator\Rule\Ip

                public function __construct(
    array $networks = [],
    private bool $allowIpv4 = true,
    private bool $allowIpv6 = true,
    private bool $allowSubnet = false,
    private bool $requireSubnet = false,
    private bool $allowNegation = false,
    private string $incorrectInputMessage = '{Property} must be a string. {type} given.',
    private string $message = '{Property} must be a valid IP address.',
    private string $ipv4NotAllowedMessage = '{Property} must not be an IPv4 address.',
    private string $ipv6NotAllowedMessage = '{Property} must not be an IPv6 address.',
    private string $wrongCidrMessage = '{Property} contains wrong subnet mask.',
    private string $noSubnetMessage = '{Property} must be an IP address with specified subnet.',
    private string $hasSubnetMessage = '{Property} must not be a subnet.',
    private string $notInRangeMessage = '{Property} is not in the allowed range.',
    array $ranges = [],
    bool|callable|null $skipOnEmpty = null,
    private bool $skipOnError = false,
    private ?Closure $when = null,
) {
    if (!$this->allowIpv4 && !$this->allowIpv6) {
        throw new InvalidArgumentException('Both IPv4 and IPv6 checks can not be disabled at the same time.');
    }
    if ($requireSubnet) {
        // Might be a bug of XDebug, because this line is covered by tests (see "IpTest").
        // @codeCoverageIgnoreStart
        $this->allowSubnet = true;
        // @codeCoverageIgnoreEnd
    }
    $this->ranges = new IpRanges($ranges, $networks);
    $this->skipOnEmpty = $skipOnEmpty;
}

            

                public function getHandler(): string
{
    return IpHandler::class;
}

            

                public function getHasSubnetMessage(): string
{
    return $this->hasSubnetMessage;
}

            

                public function getIncorrectInputMessage(): string
{
    return $this->incorrectInputMessage;
}

            

                public function getIpRanges(): IpRanges
{
    return $this->ranges;
}

            

                public function getIpv4NotAllowedMessage(): string
{
    return $this->ipv4NotAllowedMessage;
}

            

                public function getIpv6NotAllowedMessage(): string
{
    return $this->ipv6NotAllowedMessage;
}

            

                public function getMessage(): string
{
    return $this->message;
}

            

                public function getName(): string
{
    return self::class;
}

            

                public function getNetworks(): array
{
    return $this->ranges->getNetworks();
}

            

                public function getNoSubnetMessage(): string
{
    return $this->noSubnetMessage;
}

            

                public function getNotInRangeMessage(): string
{
    return $this->notInRangeMessage;
}

            

                public function getOptions(): array
{
    return [
        'networks' => $this->ranges->getNetworks(),
        'allowIpv4' => $this->allowIpv4,
        'allowIpv6' => $this->allowIpv6,
        'allowSubnet' => $this->allowSubnet,
        'requireSubnet' => $this->requireSubnet,
        'allowNegation' => $this->allowNegation,
        'incorrectInputMessage' => [
            'template' => $this->incorrectInputMessage,
            'parameters' => [],
        ],
        'message' => [
            'template' => $this->message,
            'parameters' => [],
        ],
        'ipv4NotAllowedMessage' => [
            'template' => $this->ipv4NotAllowedMessage,
            'parameters' => [],
        ],
        'ipv6NotAllowedMessage' => [
            'template' => $this->ipv6NotAllowedMessage,
            'parameters' => [],
        ],
        'wrongCidrMessage' => [
            'template' => $this->wrongCidrMessage,
            'parameters' => [],
        ],
        'noSubnetMessage' => [
            'template' => $this->noSubnetMessage,
            'parameters' => [],
        ],
        'hasSubnetMessage' => [
            'template' => $this->hasSubnetMessage,
            'parameters' => [],
        ],
        'notInRangeMessage' => [
            'template' => $this->notInRangeMessage,
            'parameters' => [],
        ],
        'ranges' => $this->ranges->getRanges(),
        'skipOnEmpty' => $this->getSkipOnEmptyOption(),
        'skipOnError' => $this->skipOnError,
    ];
}

            

                public function getRanges(): array
{
    return $this->ranges->getRanges();
}

            

                public function getWrongCidrMessage(): string
{
    return $this->wrongCidrMessage;
}

            

                public function isAllowed(string $ip): bool
{
    return $this->ranges->isAllowed($ip);
}

            

                public function isIpv4Allowed(): bool
{
    return $this->allowIpv4;
}

            

                public function isIpv6Allowed(): bool
{
    return $this->allowIpv6;
}

            

                public function isNegationAllowed(): bool
{
    return $this->allowNegation;
}

            

                public function isSubnetAllowed(): bool
{
    return $this->allowSubnet;
}

            

                public function isSubnetRequired(): bool
{
    return $this->requireSubnet;
}