qvalidator.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2012 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <qdebug.h>
 
#include "qvalidator.h"
#ifndef QT_NO_VALIDATOR
#include "private/qobject_p.h"
#include "private/qlocale_p.h"
#include "private/qnumeric_p.h"
 
#include <limits.h>
#include <cmath>
 
QT_BEGIN_NAMESPACE
 
class QValidatorPrivate : public QObjectPrivate{
    Q_DECLARE_PUBLIC(QValidator)
public:
    QValidatorPrivate() : QObjectPrivate()
    {
    }
 
    QLocale locale;
};
 
 
QValidator::QValidator(QObject * parent)
    : QValidator(*new QValidatorPrivate, parent)
{
}
 
QValidator::~QValidator()
{
}
 
QLocale QValidator::locale() const
{
    Q_D(const QValidator);
    return d->locale;
}
 
void QValidator::setLocale(const QLocale &locale)
{
    Q_D(QValidator);
    if (d->locale != locale) {
        d->locale = locale;
        emit changed();
    }
}
 
void QValidator::fixup(QString &) const
{
}
 
 
QIntValidator::QIntValidator(QObject * parent)
    : QIntValidator(INT_MIN, INT_MAX, parent)
{
}
 
 
QIntValidator::QIntValidator(int minimum, int maximum,
                              QObject * parent)
    : QValidator(parent)
{
    b = minimum;
    t = maximum;
}
 
 
QIntValidator::~QIntValidator()
{
    // nothing
}
 
 
static int numDigits(qlonglong n)
{
    if (n == 0)
        return 1;
    return (int)std::log10(double(n)) + 1;
}
 
static qlonglong pow10(int exp)
{
    qlonglong result = 1;
    for (int i = 0; i < exp; ++i)
        result *= 10;
    return result;
}
 
template <typename T> static inline
std::optional<QValidator::State> initialResultCheck(T min, T max, const ParsingResult &result)
{
    if (result.state == ParsingResult::Invalid)
        return QValidator::Invalid;
 
    const CharBuff &buff = result.buff;
    if (buff.isEmpty())
        return QValidator::Intermediate;
 
    char ch = buff[0];
    const bool signConflicts = (min >= 0 && ch == '-') || (max < 0 && ch == '+');
    if (signConflicts)
        return QValidator::Invalid;
 
    if (result.state == ParsingResult::Intermediate)
        return QValidator::Intermediate;
 
    return std::nullopt;
}
 
QValidator::State QIntValidator::validate(QString & input, int&) const
{
    ParsingResult result =
        locale().d->m_data->validateChars(input, QLocaleData::IntegerMode, -1,
                                          locale().numberOptions());
 
    std::optional<State> opt = initialResultCheck(b, t, result);
    if (opt)
        return *opt;
 
    const CharBuff &buff = result.buff;
    QSimpleParsedNumber r = QLocaleData::bytearrayToLongLong(buff, 10);
    if (!r.ok())
        return Invalid;
 
    qint64 entered = r.result;
    if (entered >= b && entered <= t) {
        bool ok = false;
        locale().toInt(input, &ok);
        return ok ? Acceptable : Intermediate;
    }
 
    if (entered >= 0) {
        // the -entered < b condition is necessary to allow people to type
        // the minus last (e.g. for right-to-left languages)
        // The buffLength > tLength condition validates values consisting
        // of a number of digits equal to or less than the max value as intermediate.
 
        int buffLength = buff.size();
        if (buff[0] == '+')
            buffLength--;
        const int tLength = t != 0 ? static_cast<int>(std::log10(qAbs(t))) + 1 : 1;
 
        return (entered > t && -entered < b && buffLength > tLength) ? Invalid : Intermediate;
    } else {
        return (entered < b) ? Invalid : Intermediate;
    }
}
 
void QIntValidator::fixup(QString &input) const
{
    auto [parseState, buff] =
        locale().d->m_data->validateChars(input, QLocaleData::IntegerMode, -1,
                                          locale().numberOptions());
    if (parseState == ParsingResult::Invalid)
        return;
 
    QSimpleParsedNumber r = QLocaleData::bytearrayToLongLong(buff, 10);
    if (r.ok())
        input = locale().toString(r.result);
}
 
void QIntValidator::setRange(int bottom, int top)
{
    bool rangeChanged = false;
    if (b != bottom) {
        b = bottom;
        rangeChanged = true;
        emit bottomChanged(b);
    }
 
    if (t != top) {
        t = top;
        rangeChanged = true;
        emit topChanged(t);
    }
 
    if (rangeChanged)
        emit changed();
}
 
 
void QIntValidator::setBottom(int bottom)
{
    setRange(bottom, top());
}
 
void QIntValidator::setTop(int top)
{
    setRange(bottom(), top);
}
 
QValidator::QValidator(QObjectPrivate &d, QObject *parent)
        : QObject(d, parent)
{
}
 
QValidator::QValidator(QValidatorPrivate &d, QObject *parent)
        : QObject(d, parent)
{
}
 
class QDoubleValidatorPrivate : public QValidatorPrivate
{
    Q_DECLARE_PUBLIC(QDoubleValidator)
public:
    QDoubleValidatorPrivate()
        : QValidatorPrivate()
        , notation(QDoubleValidator::ScientificNotation)
    {
    }
 
    QDoubleValidator::Notation notation;
 
    QValidator::State validateWithLocale(QString & input, QLocaleData::NumberMode numMode, const QLocale &locale) const;
    void fixupWithLocale(QString &input, QLocaleData::NumberMode numMode,
                         const QLocale &locale) const;
};
 
 
QDoubleValidator::QDoubleValidator(QObject *parent)
    : QDoubleValidator(-HUGE_VAL, HUGE_VAL, -1, parent)
{
}
 
 
QDoubleValidator::QDoubleValidator(double bottom, double top, int decimals,
                                    QObject * parent)
    : QValidator(*new QDoubleValidatorPrivate , parent)
{
    b = bottom;
    t = top;
    dec = decimals;
}
 
 
QDoubleValidator::~QDoubleValidator()
{
}
 
 
#ifndef LLONG_MAX
#   define LLONG_MAX Q_INT64_C(0x7fffffffffffffff)
#endif
 
QValidator::State QDoubleValidator::validate(QString & input, int &) const
{
    Q_D(const QDoubleValidator);
 
    QLocaleData::NumberMode numMode = QLocaleData::DoubleStandardMode;
    switch (d->notation) {
        case StandardNotation:
            numMode = QLocaleData::DoubleStandardMode;
            break;
        case ScientificNotation:
            numMode = QLocaleData::DoubleScientificMode;
            break;
    }
 
    return d->validateWithLocale(input, numMode, locale());
}
 
QValidator::State QDoubleValidatorPrivate::validateWithLocale(QString &input, QLocaleData::NumberMode numMode, const QLocale &locale) const
{
    Q_Q(const QDoubleValidator);
    ParsingResult result =
            locale.d->m_data->validateChars(input, numMode, q->dec, locale.numberOptions());
 
    std::optional<QValidator::State> opt = initialResultCheck(q->b, q->t, result);
    if (opt)
        return *opt;
 
    bool ok = false;
    double i = locale.toDouble(input, &ok); // returns 0.0 if !ok
    Q_ASSERT(!qIsNaN(i)); // Would be caught by validateChars()
    if (!ok)
        return QValidator::Intermediate;
 
    if (i >= q->b && i <= q->t)
        return QValidator::Acceptable;
 
    if (notation == QDoubleValidator::StandardNotation) {
        double max = qMax(qAbs(q->b), qAbs(q->t));
        qlonglong v;
        // Need a whole number to pass to convertDoubleTo() or it fails. Use
        // floor, as max is positive so this has the same number of digits
        // before the decimal point, where qCeil() might take us up to a power
        // of ten, adding a digit.
        if (convertDoubleTo(qFloor(max), &v)) {
            qlonglong n = pow10(numDigits(v));
            // In order to get the highest possible number in the intermediate
            // range we need to get 10 to the power of the number of digits
            // after the decimal's and subtract that from the top number.
            //
            // For example, where q->dec == 2 and with a range of 0.0 - 9.0
            // then the minimum possible number is 0.00 and the maximum
            // possible is 9.99. Therefore 9.999 and 10.0 should be seen as
            // invalid.
            if (qAbs(i) > (n - std::pow(10, -q->dec)))
                return QValidator::Invalid;
        }
    }
 
    return QValidator::Intermediate;
}
 
void QDoubleValidator::fixup(QString &input) const
{
    Q_D(const QDoubleValidator);
    const auto numberMode = d->notation == StandardNotation ? QLocaleData::DoubleStandardMode
                                                            : QLocaleData::DoubleScientificMode;
 
    d->fixupWithLocale(input, numberMode, locale());
}
 
void QDoubleValidatorPrivate::fixupWithLocale(QString &input, QLocaleData::NumberMode numMode,
                                              const QLocale &locale) const
{
    Q_Q(const QDoubleValidator);
    // Passing -1 as the number of decimals, because fixup() exists to improve
    // an Intermediate value, if it can.
    auto [parseState, buff] =
            locale.d->m_data->validateChars(input, numMode, -1, locale.numberOptions());
    if (parseState == ParsingResult::Invalid)
        return;
 
    // buff contains data in C locale.
    bool ok = false;
    const double entered = QByteArrayView(buff).toDouble(&ok);
    if (ok) {
        // Here we need to adjust the output format accordingly
        char mode;
        if (numMode == QLocaleData::DoubleStandardMode) {
            mode = 'f';
        } else {
            // scientific mode can be either 'e' or 'E'
            mode = input.contains(QChar::fromLatin1('E')) ? 'E' : 'e';
        }
        int precision;
        if (q->dec < 0) {
            precision = QLocale::FloatingPointShortest;
        } else {
            if (mode == 'f') {
                const auto decimalPointIndex = buff.indexOf('.');
                precision = decimalPointIndex >= 0 ? buff.size() - decimalPointIndex - 1 : 0;
            } else {
                auto eIndex = buff.indexOf('e');
                // No need to check for 'E' because we can get only 'e' after a
                // call to validateChars()
                if (eIndex < 0)
                    eIndex = buff.size();
                precision = eIndex - (buff.contains('.') ? 1 : 0)
                        - (buff[0] == '-' || buff[0] == '+' ? 1 : 0);
            }
            // Use q->dec to limit the number of decimals, because we want the
            // fixup() result to pass validate().
            precision = qMin(precision, q->dec);
        }
        input = locale.toString(entered, mode, precision);
    }
}
 
void QDoubleValidator::setRange(double minimum, double maximum, int decimals)
{
    bool rangeChanged = false;
    if (b != minimum) {
        b = minimum;
        rangeChanged = true;
        emit bottomChanged(b);
    }
 
    if (t != maximum) {
        t = maximum;
        rangeChanged = true;
        emit topChanged(t);
    }
 
    if (dec != decimals) {
        dec = decimals;
        rangeChanged = true;
        emit decimalsChanged(dec);
    }
    if (rangeChanged)
        emit changed();
}
 
void QDoubleValidator::setRange(double minimum, double maximum)
{
    setRange(minimum, maximum, decimals());
}
 
void QDoubleValidator::setBottom(double bottom)
{
    setRange(bottom, top(), decimals());
}
 
 
void QDoubleValidator::setTop(double top)
{
    setRange(bottom(), top, decimals());
}
 
void QDoubleValidator::setDecimals(int decimals)
{
    setRange(bottom(), top(), decimals);
}
 
void QDoubleValidator::setNotation(Notation newNotation)
{
    Q_D(QDoubleValidator);
    if (d->notation != newNotation) {
        d->notation = newNotation;
        emit notationChanged(d->notation);
        emit changed();
    }
}
 
QDoubleValidator::Notation QDoubleValidator::notation() const
{
    Q_D(const QDoubleValidator);
    return d->notation;
}
 
#if QT_CONFIG(regularexpression)
 
class QRegularExpressionValidatorPrivate : public QValidatorPrivate
{
    Q_DECLARE_PUBLIC(QRegularExpressionValidator)
 
public:
    QRegularExpression origRe; // the one set by the user
    QRegularExpression usedRe; // the one actually used
    void setRegularExpression(const QRegularExpression &re);
};
 
QRegularExpressionValidator::QRegularExpressionValidator(QObject *parent)
    : QValidator(*new QRegularExpressionValidatorPrivate, parent)
{
    // origRe in the private will be an empty QRegularExpression,
    // and therefore this validator will match any string.
}
 
QRegularExpressionValidator::QRegularExpressionValidator(const QRegularExpression &re, QObject *parent)
    : QRegularExpressionValidator(parent)
{
    Q_D(QRegularExpressionValidator);
    d->setRegularExpression(re);
}
 
 
QRegularExpressionValidator::~QRegularExpressionValidator()
{
}
 
QValidator::State QRegularExpressionValidator::validate(QString &input, int &pos) const
{
    Q_D(const QRegularExpressionValidator);
 
    // We want a validator with an empty QRegularExpression to match anything;
    // since we're going to do an exact match (by using d->usedRe), first check if the rx is empty
    // (and, if so, accept the input).
    if (d->origRe.pattern().isEmpty())
        return Acceptable;
 
    const QRegularExpressionMatch m = d->usedRe.match(input, 0, QRegularExpression::PartialPreferCompleteMatch);
    if (m.hasMatch()) {
        return Acceptable;
    } else if (input.isEmpty() || m.hasPartialMatch()) {
        return Intermediate;
    } else {
        pos = input.size();
        return Invalid;
    }
}
 
QRegularExpression QRegularExpressionValidator::regularExpression() const
{
    Q_D(const QRegularExpressionValidator);
    return d->origRe;
}
 
void QRegularExpressionValidator::setRegularExpression(const QRegularExpression &re)
{
    Q_D(QRegularExpressionValidator);
    d->setRegularExpression(re);
}
 
void QRegularExpressionValidatorPrivate::setRegularExpression(const QRegularExpression &re)
{
    Q_Q(QRegularExpressionValidator);
 
    if (origRe != re) {
        usedRe = origRe = re; // copies also the pattern options
        usedRe.setPattern(QRegularExpression::anchoredPattern(re.pattern()));
        emit q->regularExpressionChanged(re);
        emit q->changed();
    }
}
 
#endif // QT_CONFIG(regularexpression)
 
QT_END_NAMESPACE
 
#include "moc_qvalidator.cpp"
 
#endif // QT_NO_VALIDATOR