Arsse/lib/Misc/ValueInfo.php

<?php
declare(strict_types=1);
namespace JKingWeb\Arsse\Misc;

class ValueInfo {
    // universal
    const VALID = 1 << 0;
    const NULL  = 1 << 1;
    // integers
    const ZERO  = 1 << 2;
    const NEG   = 1 << 3;
    // strings
    const EMPTY = 1 << 2;
    const WHITE = 1 << 3;

    public static function int($value): int {
        $out = 0;
        if (is_null($value)) {
            // check if the input is null
            return self::NULL;
        } elseif (is_string($value) || (is_object($value) && method_exists($value, "__toString"))) {
            $value = (string) $value;
            // normalize a string an integer or float if possible
            if (!strlen($value)) {
                // the empty string is equivalent to null when evaluating an integer
                return self::NULL;
            } elseif (filter_var($value, \FILTER_VALIDATE_FLOAT) !== false && !fmod((float) $value, 1)) {
                // an integral float is acceptable
                $value = (int) $value;
            } else {
                return $out;
            }
        } elseif (is_float($value) && !fmod($value, 1)) {
            // an integral float is acceptable
            $value = (int) $value;
        } elseif (!is_int($value)) {
            // if the value is not an integer or integral float, stop
            return $out;
        }
        // mark validity
        $out += self::VALID;
        // mark zeroness
        if ($value==0) {
            $out += self::ZERO;
        }
        // mark negativeness
        if ($value < 0) {
            $out += self::NEG;
        }
        return $out;
    }

    public static function str($value): int {
        $out = 0;
        // check if the input is null
        if (is_null($value)) {
            $out += self::NULL;
        }
        if (is_object($value) && method_exists($value, "__toString")) {
            // if the value is an object which has a __toString method, this is acceptable
            $value = (string) $value;
        } elseif (!is_scalar($value) || is_bool($value) || (is_float($value) && !is_finite($value))) {
            // otherwise if the value is not scalar, is a boolean, or is infinity or NaN, it cannot be valid
            return $out;
        }
        // mark validity
        $out += self::VALID;
        if (!strlen((string) $value)) {
            // mark emptiness
            $out += self::EMPTY;
        } elseif (!strlen(trim((string) $value))) {
            // mark whitespacedness
            $out += self::WHITE;
        }
        return $out;
    }

    public static function id($value, bool $allowNull = false): bool {
        $info = self::int($value);
        if ($allowNull && ($info & self::NULL)) { // null (and allowed)
            return true;
        } elseif (!($info & self::VALID)) { // not an integer
            return false;
        } elseif ($info & self::NEG) { // negative integer
            return false;
        } elseif (!$allowNull && ($info & self::ZERO)) { // zero (and not allowed)
            return false;
        } else { // non-negative integer
            return true;
        }
    }

    public static function bool($value, bool $default = null) {
        if (is_null($value) || ValueInfo::str($value) & ValueInfo::WHITE) {
            return $default;
        }
        $out = filter_var($value, \FILTER_VALIDATE_BOOLEAN, \FILTER_NULL_ON_FAILURE);
        if (is_null($out) && (ValueInfo::int($value) & ValueInfo::VALID)) {
            $out = abs((int) filter_var($value, \FILTER_VALIDATE_FLOAT));
            return ($out < 2) ? (bool) $out : $default;
        }
        return !is_null($out) ? $out : $default;
    }
}