Common classes that cover a wide range of cases that are used throughout the inanepain libraries.
Utility class providing static methods for validating and verifying common value types such as booleans, emails, integers, floats, IP addresses, MAC addresses, domains, and regex-matched strings.
All methods wrap PHP’s native filter_var function with a consistent, expressive API and sensible defaults.
Validates and converts a given value into a boolean.
Accepts the same truthy/falsy strings that PHP’s filter_var recognises (e.g. "true", "yes", "1", "on" and their negatives).
public static function boolVerify(mixed $value, bool $nullOnFailure = false): ?bool| Parameter | Type | Description |
|---|---|---|
|
|
The value to validate and convert to boolean. |
|
|
When |
VerifyValue::boolVerify('yes'); // true
VerifyValue::boolVerify('off'); // false
VerifyValue::boolVerify('maybe', true); // nullValidates an email address or an array of email addresses.
When an array is supplied, each element is validated individually, and the method returns an associative array keyed by the original input values.
public static function emailVerify(string|array $value): false|string|array| Parameter | Type | Description |
|---|---|---|
|
|
A single email address string, or an array of email address strings. |
VerifyValue::emailVerify('user@example.com'); // 'user@example.com'
VerifyValue::emailVerify('not-an-email'); // false
VerifyValue::emailVerify(['a@b.com', 'bad', 'c@d.com']); // ['a@b.com' => 'a@b.com', 'bad' => false, 'c@d.com' => 'c@d.com']Validates an integer value with optional range and base constraints.
Supports octal (prefix 0) and hexadecimal (prefix 0x) notation when the corresponding flags are enabled.
public static function integerVerify(mixed $int, mixed $default = false, ?int $min = null, ?int $max = null, bool $allowOctal = false, bool $allowHex = false): bool| Parameter | Type | Description |
|---|---|---|
|
|
The value to validate as an integer. |
|
|
Fallback value returned on validation failure. Pass |
|
|
Optional minimum allowed value (inclusive). |
|
|
Optional maximum allowed value (inclusive). |
|
|
When |
|
|
When |
VerifyValue::integerVerify(42); // true
VerifyValue::integerVerify(42, false, 1, 100); // true
VerifyValue::integerVerify(200, false, 1, 100); // false
VerifyValue::integerVerify('0x1A', false, null, null, false, true); // trueValidates an integer value using a named options array.
A convenience wrapper around integerVerify() that accepts a named options array instead of individual parameters. Unrecognised keys are silently ignored.
public static function intVerify(mixed $int, array $options = []): bool| Parameter | Type | Description |
|---|---|---|
|
|
The value to validate as an integer. |
|
|
Named validation options: |
VerifyValue::intVerify(42, ['min' => 1, 'max' => 100]); // true
VerifyValue::intVerify('0xFF', ['allowHex' => true]); // trueValidates a float value with optional range and thousand-separator support.
public static function floatVerify(mixed $int, mixed $default = false, ?int $min = null, ?int $max = null, bool $acceptFloat = false): bool| Parameter | Type | Description |
|---|---|---|
|
|
The value to validate as a float. |
|
|
Fallback value returned on validation failure. Pass |
|
|
Optional minimum allowed value (inclusive). |
|
|
Optional maximum allowed value (inclusive). |
|
|
When |
VerifyValue::floatVerify(3.14); // true
VerifyValue::floatVerify('1,234.56', false, null, null, true); // true
VerifyValue::floatVerify('abc'); // falseValidates a value against a regular expression pattern.
Returns the original value when it matches the pattern, the $default string when provided and the match fails, or null otherwise.
public static function regexVerify(mixed $value, string $pattern, ?string $default = null): ?string| Parameter | Type | Description |
|---|---|---|
|
|
The value to validate. |
|
|
A valid PCRE regular expression (including delimiters). |
|
|
Optional fallback string returned when validation fails. |
VerifyValue::regexVerify('hello123', '/^[a-z]+\d+$/'); // 'hello123'
VerifyValue::regexVerify('!!!', '/^[a-z]+$/', 'no-match'); // 'no-match'
VerifyValue::regexVerify('!!!', '/^[a-z]+$/'); // nullValidates a domain name, optionally enforcing strict hostname rules.
public static function domainVerify(mixed $value, bool $hostname = false): ?string| Parameter | Type | Description |
|---|---|---|
|
|
The value to validate as a domain name. |
|
|
When |
VerifyValue::domainVerify('example.com'); // 'example.com'
VerifyValue::domainVerify('-bad.com', true); // null
VerifyValue::domainVerify('not a domain'); // nullValidates an IP address with configurable version and range policies.
By default, both IPv4 and IPv6 addresses are accepted. Passing false for one version while leaving the other as true restricts validation to the remaining version.
public static function ipVerify(mixed $value, bool $allowV4 = true, bool $allowV6 = true, bool $denyPrivate = false, bool $denyReserved = false, bool $globalOnly = false): ?string| Parameter | Type | Description |
|---|---|---|
|
|
The value to validate as an IP address. |
|
|
Accept IPv4 addresses (default |
|
|
Accept IPv6 addresses (default |
|
|
Reject private-range addresses (e.g. |
|
|
Reject reserved-range addresses (e.g. |
|
|
Accept only globally routable addresses. |
VerifyValue::ipVerify('192.168.1.1'); // '192.168.1.1'
VerifyValue::ipVerify('192.168.1.1', true, true, true); // null (private range denied)
VerifyValue::ipVerify('::1', false, true); // '::1' (IPv6 only)
VerifyValue::ipVerify('not-an-ip'); // nullValidates a MAC address and optionally normalises its format.
PHP’s filter_var accepts colons (:), hyphens (-), and dots (.) as separators. When $normalize is true the validated address is stripped of its original separators and rebuilt using $separator.
public static function macVerify(mixed $value, bool $normalize = false, string $separator = ':'): ?string| Parameter | Type | Description |
|---|---|---|
|
|
The value to validate as a MAC address. |
|
|
When |
|
|
The separator character used when normalising (default |
VerifyValue::macVerify('00-1A-2B-3C-4D-5E'); // '00-1A-2B-3C-4D-5E'
VerifyValue::macVerify('00-1A-2B-3C-4D-5E', true); // '00:1a:2b:3c:4d:5e'
VerifyValue::macVerify('00.1A.2B.3C.4D.5E', true, '-'); // '00-1a-2b-3c-4d-5e'
VerifyValue::macVerify('not-a-mac'); // null
██████████████ ██████████ ██ ████ ████ ██ ██ ██████████████
██ ██ ██ ████ ██████████ ██ ██ ██
██ ██████ ██ ████ ████ ████████ ██████████████████ ██ ██████ ██
██ ██████ ██ ████ ██ ████ ████████ ████ ██ ██████ ██
██ ██████ ██ ██ ██ ████ ██ ██ ██ ██████ ██
██ ██ ██ ██████ ██ ██ ██ ██ ██
██████████████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██████████████
██ ██████ ██ ██████████ ████
████ ████ ██ ████ ██ ██ ██ ██ ████ ██ ████
██ ████ ████ ████ ██ ██ ██ ██ ████ ██
████ ██████████ ██ ██ ██ ████ ████████ ██
████ ████████ ██ ████ ██ ████ ████ ████ ██
██ ████ ████ ████ ██ ████ ██ ██ ██ ████ ██ ████
██ ████ ████ ██████ ██ ██ ██ ████ ██ ██ ██
████ ██████████████ ██████ ██ ████████ ██ ████████
██ ██ ██ ██████ ██ ██ ████ ██ ██████ ██
████ ██████ ██ ██ ██ ████ ██ ██████ ██ ██ ██
██ ██████ ██ ██████ ████████ ██ ██ ██ ██
████ ████████ ████████████ ████████ ██████ ████ ██████ ████ ██
██ ██ ██ ████ ████ ████ ██ ████ ████ ██████████████ ██
██ ████████ ██ ██ ██ ██ ██████ ██ ██
██ ████████ ██ ██ ██████ ████ ██████ ████ ████ ██████
██ ████ ██ ██ ██ ██ ██ ██ ██████ ██
██ ██ ██ ████ ██ ██ ████ ██ ██ ██████ ██ ████████
██ ██████████ ████ ████ ██████ ██████████ ██████
██ ██ ██ ██ ██ ██ ██ ██ ████ ████ ██
████ ██ ██████ ████ ██████ ████ ████ ████ ████████ ████
██ ██████ ████ ██████ ██████████ ████ ████ ██ ██
██ ██████ ████ ██ ████ ██████████████ ████ ██████████████
██████ ████████ ██ ██ ██ ██ ██ ██████
██████████████ ██ ██████ ██████ ████ ████████ ██ ██ ██████ ██
██ ██ ██████ ████ ██ ██ ████ ████ ████
██ ██████ ██ ████ ██ ████ ████ ██ ██ ██████████████
██ ██████ ██ ██ ██████ ████ ██ ██ ██████ ████ ████
██ ██████ ██ ██ ██████████ ██ ████ ████ ████ ████
██ ██ ██ ██ ██ ██ ████ ██████ ████████
██████████████ ██ ██ ████ ██ ████ ██ ████ ██