Final Class Yiisoft\Validator\Rule\Compare

                public function __construct(
    private mixed $targetValue = null,
    private ?string $targetProperty = null,
    private string $incorrectInputMessage = self::DEFAULT_INCORRECT_INPUT_MESSAGE,
    private string $incorrectDataSetTypeMessage = self::DEFAULT_INCORRECT_DATA_SET_TYPE_MESSAGE,
    private ?string $message = null,
    private string $type = CompareType::NUMBER,
    private string $operator = '==',
    bool|callable|null $skipOnEmpty = null,
    private bool $skipOnError = false,
    private ?Closure $when = null,
) {
    if (!in_array($this->type, self::VALID_TYPES)) {
        $validTypesString = $this->getQuotedList(self::VALID_TYPES);
        $message = "Type \"$this->type\" is not supported. The valid types are: $validTypesString.";
        throw new InvalidArgumentException($message);
    }
    if (!isset(self::VALID_OPERATORS_MAP[$this->operator])) {
        $validOperators = array_keys(self::VALID_OPERATORS_MAP);
        $validOperatorsString = $this->getQuotedList($validOperators);
        $message = "Operator \"$operator\" is not supported. The valid operators are: $validOperatorsString.";
        throw new InvalidArgumentException($message);
    }
    $this->skipOnEmpty = $skipOnEmpty;
}

            

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

            

                public function getIncorrectDataSetTypeMessage(): string
{
    return $this->incorrectDataSetTypeMessage;
}

            

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

            

                public function getMessage(): string
{
    return $this->message ?? match ($this->operator) {
        '==', => '{Property} must be equal to "{targetValueOrProperty}".',
        '===' => '{Property} must be strictly equal to "{targetValueOrProperty}".',
        '!=' => '{Property} must not be equal to "{targetValueOrProperty}".',
        '!==' => '{Property} must not be strictly equal to "{targetValueOrProperty}".',
        '>' => '{Property} must be greater than "{targetValueOrProperty}".',
        '>=' => '{Property} must be greater than or equal to "{targetValueOrProperty}".',
        '<' => '{Property} must be less than "{targetValueOrProperty}".',
        '<=' => '{Property} must be less than or equal to "{targetValueOrProperty}".',
    };
}

            

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

            

                public function getOperator(): string
{
    return $this->operator;
}

            

                public function getOptions(): array
{
    $isTargetValueSimple = $this->targetValue === null || is_scalar($this->targetValue);
    if (!$isTargetValueSimple) {
        $messageParameters = ['targetProperty' => $this->targetProperty];
    } else {
        $messageParameters = [
            'targetValue' => $this->targetValue,
            'targetProperty' => $this->targetProperty,
            'targetValueOrProperty' => $this->targetProperty ?? $this->targetValue,
        ];
    }
    $options = [
        'targetProperty' => $this->targetProperty,
        'incorrectInputMessage' => [
            'template' => $this->incorrectInputMessage,
            'parameters' => $messageParameters,
        ],
        'incorrectDataSetTypeMessage' => [
            'template' => $this->incorrectDataSetTypeMessage,
            'parameters' => $messageParameters,
        ],
        'message' => [
            'template' => $this->getMessage(),
            'parameters' => $messageParameters,
        ],
        'type' => $this->type,
        'operator' => $this->operator,
        'skipOnEmpty' => $this->getSkipOnEmptyOption(),
        'skipOnError' => $this->skipOnError,
    ];
    if (!$isTargetValueSimple) {
        return $options;
    }
    return array_merge(['targetValue' => $this->targetValue], $options);
}

            

                public function getSkipOnEmpty(): bool|callable|null
{
    return $this->skipOnEmpty;
}

            

                public function getTargetProperty(): ?string
{
    return $this->targetProperty;
}

            

                public function getTargetValue(): mixed
{
    return $this->targetValue;
}

            

                public function getType(): string
{
    return $this->type;
}

            

                public function getWhen(): ?Closure
{
    return $this->when;
}

            

                public function shouldSkipOnError(): bool
{
    return $this->skipOnError;
}

            

                public function skipOnEmpty(bool|callable|null $value): static
{
    $new = clone $this;
    $new->skipOnEmpty = $value;
    return $new;
}

            

                public function skipOnError(bool $value): static
{
    $new = clone $this;
    $new->skipOnError = $value;
    return $new;
}

            

                public function when(?Closure $value): static
{
    $new = clone $this;
    $new->when = $value;
    return $new;
}