Maidenhead.h

Go to the documentation of this file.

#ifndef MAIDENHEAD_HPP__
#define MAIDENHEAD_HPP__
 
#include <QString>
#include <QStringView>
#include <QValidator>

namespace Maidenhead {

constexpr char16_t normalize(char16_t const u) noexcept {
    return (u >= u'a' && u <= u'z') ? u - (u'a' - u'A') : u;
}
 
static_assert(normalize(u'0') == u'0');
static_assert(normalize(u'A') == u'A');
static_assert(normalize(u'Z') == u'Z');
static_assert(normalize(u'a') == u'A');
static_assert(normalize(u'z') == u'Z');

constexpr auto invalidIndex(QStringView const view) noexcept {
    auto const size = view.size();
 
    for (qsizetype i = 0; i < size; ++i) {
        auto const u = normalize(view[i].unicode());
 
        switch (i) {
        case 0:
        case 1:
            if (u >= u'A' && u <= u'R')
                continue;
            break;
        case 2:
        case 3:
        case 6:
        case 7:
        case 10:
        case 11:
            if (u >= u'0' && u <= u'9')
                continue;
            break;
        case 4:
        case 5:
        case 8:
        case 9:
            if (u >= u'A' && u <= u'X')
                continue;
            break;
        }
        return i;
    }
 
    return size;
}
 
static_assert(invalidIndex(u"") == 0);
static_assert(invalidIndex(u"S") == 0);
static_assert(invalidIndex(u"AZ") == 1);
static_assert(invalidIndex(u"AAA") == 2);
static_assert(invalidIndex(u"AA00AA00AA00A") == 12);

template <qsizetype Min = 2, qsizetype Max = 6>
constexpr auto valid(QStringView const view) noexcept {
    static_assert(Min >= 1 && Max >= 1 && Max <= 6 && Min <= Max);
 
    if (auto const size = view.size();
        !(size & 1) && (size >= 2 * Min) && (size <= 2 * Max)) {
        return invalidIndex(view) == size;
    }
 
    return false;
}
 
static_assert(valid(u"AA00"));
static_assert(valid(u"AA00AA"));
static_assert(valid(u"AA00AA00"));
static_assert(valid(u"BP51AD95RF"));
static_assert(valid(u"BP51AD95RF00"));
static_assert(valid(u"aa00"));
static_assert(valid(u"AA00aa"));
static_assert(valid(u"RR00XX"));
 
static_assert(!valid(u""));
static_assert(!valid(u"A"));
static_assert(!valid(u"0"));
static_assert(!valid(u"AA00 "));
static_assert(!valid(u"AA00 "));
static_assert(!valid(u"AA00 "));
static_assert(!valid(u" AA00"));
static_assert(!valid(u" AA00"));
static_assert(!valid(u"00"));
static_assert(!valid(u"aa00a"));
static_assert(!valid(u"AA00ZZA"));
static_assert(!valid(u"!@#$%^"));
static_assert(!valid(u"123456"));
static_assert(!valid(u"AA00ZZ"));
static_assert(!valid(u"ss00XX"));
static_assert(!valid(u"rr00yy"));
static_assert(!valid(u"AAA1aa"));
static_assert(!valid(u"BP51AD95RF00A"));
static_assert(!valid(u"BP51AD95RF0000"));

template <qsizetype Min, qsizetype Max>
class Validator final : public QValidator {
    static_assert(Min >= 1 && Max >= 1 && Max <= 6 && Min <= Max);
 
    using QValidator::QValidator;

    State validate(QString &input, int &pos) const override {
        // Ensure the input is upper case and get the size.
 
        input = input.toUpper();
        auto const size = input.size();
 
        // If nothing's been entered, we need more from them; if over
        // the maximum, less.
 
        if (size == 0)
            return Intermediate;
        if (size > Max * 2)
            return Invalid;
 
        // If anything up to the cursor is invalid, then we're invalid.
        // Anything after the cursor, we're willing to be hopeful about.
 
        if (auto const index = invalidIndex(input); index != size) {
            return index < pos ? Invalid : Intermediate;
        }
 
        // Entire input was valid. If the count is odd, or we haven't yet
        // hit the minimum, we need more from them, otherwise, we're good.
 
        return ((size & 1) || (size < Min * 2)) ? Intermediate : Acceptable;
    }
};

using StandardValidator = Validator<2, 3>;

using ExtendedValidator = Validator<2, 6>;
 
} // namespace Maidenhead
 
#endif