input_validator.h

Go to the documentation of this file.

#ifndef AUBO_SCOPE_KEYBOARD_INPUT_VALIDATOR_H
#define AUBO_SCOPE_KEYBOARD_INPUT_VALIDATOR_H

#include <string>
#include <functional>
#include <float.h>

#include <QObject>

#include <aubo_caps/domain/value/expression/expression.h>

namespace arcs {
namespace aubo_scope {

/**
 * <p>
 * Interface representing the input validators created by {@link
 * InputValidationFactory}. This factory provides a set of standard input
 * validators that can be used for validating the input entered by the user
 * using the virtual keyboard/keypad.
 * </p>
 *
 * If the standard validators available in the {@link InputValidationFactory}
 * does not satisfy your needs, you are free to implement your own custom
 * validator.
 *
 * @param <T> the (generic) type parameter for the interface representing the
 * type of input data being validated (e.g. Integer or Double).
 */
struct InputValidator
{
    /**
     * @param value to be validated.
     * @return <code>true</code> if value is valid.
     */
    virtual bool isValid(std::string value) = 0;

    /**
     * Returns a meaningful message in case the value is not valid.
     *
     * @param value the invalid value. Can be included in the message if it
     * makes sense.
     * @return message.
     */
    virtual std::string getMessage(std::string value) = 0;
};

struct IntegerRangeValidator : InputValidator
{
    IntegerRangeValidator(int min_value, int max_value)
        : min_value_(min_value), max_value_(max_value)
    {
    }

    IntegerRangeValidator(std::function<std::pair<int, int>()> range_func)
        : range_func_(range_func)
    {
    }

    bool isValid(std::string value) override
    {
        updateValue();

        // 超出 int32 范围
        if (value[0] == '-') {
            if (value.size() > std::to_string(INT_MIN).size()) {
                return false;
            }
        } else if (value.size() > std::to_string(INT_MAX).size()) {
            return false;
        }

        int64_t v = atoll(value.c_str());
        return v >= min_value_ && v <= max_value_;
    }

    std::string getMessage(std::string value) override
    {
        updateValue();

        // 超出 int32 范围
        if (value[0] == '-') {
            if (value.size() > std::to_string(INT_MIN).size()) {
                return QObject::tr("Error: The value is between %1 and %2.")
                    .arg(min_value_)
                    .arg(max_value_)
                    .toStdString();
            }
        } else if (value.size() > std::to_string(INT_MAX).size()) {
            return QObject::tr("Error: The value is between %1 and %2.")
                .arg(min_value_)
                .arg(max_value_)
                .toStdString();
        }

        int64_t v = atoll(value.c_str());
        if (v < min_value_ || v > max_value_) {
            return QObject::tr("Error: The value is between %1 and %2.")
                .arg(min_value_)
                .arg(max_value_)
                .toStdString();
        }
        return "";
    }

private:
    void updateValue()
    {
        if (range_func_) {
            auto [min_value, max_value] = range_func_();
            min_value_ = min_value;
            max_value_ = max_value;
        }

        if (min_value_ > max_value_) {
            min_value_ ^= max_value_ ^= min_value_ ^= max_value_;
        }
    }

private:
    int min_value_{ INT_MIN };
    int max_value_{ INT_MAX };
    std::function<std::pair<int, int>()> range_func_{ nullptr };
};

struct UIntegerRangeValidator : InputValidator
{
    UIntegerRangeValidator(uint32_t min_value, uint32_t max_value)
        : min_value_(min_value), max_value_(max_value)
    {
    }

    UIntegerRangeValidator(
        std::function<std::pair<uint32_t, uint32_t>()> range_func)
        : range_func_(range_func)
    {
    }

    bool isValid(std::string value) override
    {
        updateValue();

        // 超出 uint32 范围
        if (value.size() > std::to_string(UINT_MAX).size()) {
            return false;
        }

        uint64_t v = QString::fromStdString(value).toULongLong();
        return v >= min_value_ && v <= max_value_;
    }

    std::string getMessage(std::string value) override
    {
        updateValue();

        // 超出 uint32 范围
        if (value.size() > std::to_string(UINT_MAX).size()) {
            return QObject::tr("Error: The value is between %1 and %2.")
                .arg(min_value_)
                .arg(max_value_)
                .toStdString();
        }

        uint64_t v = QString::fromStdString(value).toULongLong();
        if (v < min_value_ || v > max_value_) {
            return QObject::tr("Error: The value is between %1 and %2.")
                .arg(min_value_)
                .arg(max_value_)
                .toStdString();
        }
        return "";
    }

private:
    void updateValue()
    {
        if (range_func_) {
            auto [min_value, max_value] = range_func_();
            min_value_ = min_value;
            max_value_ = max_value;
        }

        if (min_value_ > max_value_) {
            min_value_ ^= max_value_ ^= min_value_ ^= max_value_;
        }
    }

private:
    uint32_t min_value_{ 0 };
    uint32_t max_value_{ UINT_MAX };
    std::function<std::pair<uint32_t, uint32_t>()> range_func_{ nullptr };
};

struct DoubleRangeValidator : InputValidator
{
    DoubleRangeValidator(double minValue, double maxValue,
                         bool is_min_inclusive = true,
                         bool is_max_inclusive = true)
        : min_value_(minValue), max_value_(maxValue),
          is_min_inclusive_(is_min_inclusive),
          is_max_inclusive_(is_max_inclusive)
    {
    }

    DoubleRangeValidator(std::function<std::pair<double, double>()> range_func)
        : range_func_(range_func)
    {
    }

    DoubleRangeValidator(
        std::function<std::tuple<double, double, bool, bool>()> range_func)
        : range_func_with_flags_(range_func)
    {
    }

    bool isValid(std::string value) override
    {
        updateValue();
        double val = QString::fromStdString(value).toDouble();

        bool valid = true;
        if (is_min_inclusive_) {
            valid &= val >= min_value_;
        } else {
            valid &= val > min_value_;
        }

        if (is_max_inclusive_) {
            valid &= val <= max_value_;
        } else {
            valid &= val < max_value_;
        }

        return valid;
    }

    std::string getMessage(std::string value) override
    {
        updateValue();
        double val = QString::fromStdString(value).toDouble();
        // double 很难超出上限 1e305，故可不考虑超出 double 范围
        if ((is_min_inclusive_ ? val < min_value_ : val <= min_value_) ||
            (is_max_inclusive_ ? val > max_value_ : val >= max_value_)) {
            if (is_min_inclusive_ && is_max_inclusive_) {
                return QObject::tr("Error: The value is between %1 and %2.")
                    .arg(min_value_, 0, 'g', 15)
                    .arg(max_value_, 0, 'g', 15)
                    .toStdString();
            } else if (!is_min_inclusive_ && !is_max_inclusive_) {
                return QObject::tr("Error: The value should be between %1 and "
                                   "%2 (exclusive).")
                    .arg(min_value_, 0, 'g', 15)
                    .arg(max_value_, 0, 'g', 15)
                    .toStdString();
            } else if (is_min_inclusive_ && !is_max_inclusive_) {
                return QObject::tr("Error: The value should be greater than or "
                                   "equal to %1 and less than %2.")
                    .arg(min_value_, 0, 'g', 15)
                    .arg(max_value_, 0, 'g', 15)
                    .toStdString();
            } else {
                return QObject::tr("Error: The value should be greater than %1 "
                                   "and less than or equal to %2.")
                    .arg(min_value_, 0, 'g', 15)
                    .arg(max_value_, 0, 'g', 15)
                    .toStdString();
            }
        }

        return "";
    }

private:
    void updateValue()
    {
        if (range_func_) {
            auto [min_value, max_value] = range_func_();
            min_value_ = min_value;
            max_value_ = max_value;
            is_min_inclusive_ = true;
            is_max_inclusive_ = true;
        } else if (range_func_with_flags_) {
            auto [min_value, max_value, min_inclusive, max_inclusive] =
                range_func_with_flags_();
            min_value_ = min_value;
            max_value_ = max_value;
            is_min_inclusive_ = min_inclusive;
            is_max_inclusive_ = max_inclusive;
        }

        if (min_value_ > max_value_) {
            double t = min_value_;
            min_value_ = max_value_;
            max_value_ = t;
        }
    }

private:
    double min_value_{ DBL_MIN };
    double max_value_{ DBL_MAX };
    std::function<std::pair<double, double>()> range_func_;
    std::function<std::tuple<double, double, bool, bool>()>
        range_func_with_flags_;
    bool is_min_inclusive_{ true }; // 最小值是否闭区间
    bool is_max_inclusive_{ true }; // 最大值是否闭区间
};

struct StringLengthValidator : InputValidator
{
    StringLengthValidator(size_t min_length, size_t max_length)
        : min_length_(min_length), max_length_(max_length)
    {
    }

    StringLengthValidator(std::function<std::pair<size_t, size_t>()> range_func)
        : range_func_(range_func)
    {
    }

    bool isValid(std::string value) override
    {
        updateValue();

        auto value_size = QString::fromStdString(value).length();
        return value_size >= min_length_ && value_size <= max_length_;
    }

    std::string getMessage(std::string value) override
    {
        updateValue();

        auto value_size = QString::fromStdString(value).length();
        if (value_size < min_length_ || value_size > max_length_) {
            return QObject::tr(
                       "Error: The value is between %1 and %2 in length.")
                .arg(min_length_)
                .arg(max_length_)
                .toStdString();
        }
        return "";
    }

private:
    void updateValue()
    {
        if (range_func_) {
            auto [min_length, max_length] = range_func_();
            min_length_ = min_length;
            max_length_ = max_length;
        }

        if (min_length_ > max_length_) {
            min_length_ ^= max_length_ ^= min_length_ ^= max_length_;
        }
    }

private:
    size_t min_length_{ 0 };
    size_t max_length_{ ULONG_MAX };
    std::function<std::pair<size_t, size_t>()> range_func_{ nullptr };
};

} // namespace aubo_scope
} // namespace arcs

#endif