File indexing completed on 2024-04-28 05:50:09

 /*
  * SPDX-License-Identifier: GPL-3.0-or-later
  * SPDX-FileCopyrightText: 2019-2020 Johan Ouwerkerk <jm.ouwerkerk@gmail.com>
  */
 
 #include "countervalidator.h"
 
 #include "util.h"
 
 namespace validators
 {
     std::optional<qulonglong> parseUnsignedInteger(const QString &input, const QLocale &locale)
     {
         bool ok = false;
 
         auto v = locale.toULongLong(input, &ok);
         if (ok) {
             return std::optional<qulonglong>(v);
         } else {
             /*
              * Fall back to parsing according to C locale for better UX.
              * This simplifies copy-pasting from websites which may be a bit
              * biased towards the Anglosphere.
              */
             const QLocale c = QLocale::c();
             v = c.toULongLong(input, &ok);
             return ok ? std::optional<qulonglong>(v) : std::nullopt;
         }
     }
 
     UnsignedLongValidator::UnsignedLongValidator(QObject *parent):
         QValidator(parent)
     {
     }
 
     void UnsignedLongValidator::fixup(QString &input) const
     {
         /*
          * First of all: simplify the input to get rid of 'fluff' such as
          * digit group separators in partial input. E.g. if the user wants
          * to type the value 123456 then partial input might become "123,4"
          * at some point which would be invalid.
          */
         const QLocale l = locale();
         const auto c = l.groupSeparator();
         QString fixed = input.replace(c, QLatin1String(""));
         fixed = validators::strip_spaces(fixed);
 
         /*
          * Normalise to locale's preferred formatting if possible
          * I.e. if valid, re-instate any decorative fluff like digit group
          * separators depending on the locale.
          *
          * This may also involve switching from Latin script (C locale) to
          * whatever script the configured locale uses natively.
          */
         const auto v = parseUnsignedInteger(fixed, l);
         if (v) {
             fixed = l.toString(v.value());
         }
 
         input = fixed;
     }
 
     QValidator::State UnsignedLongValidator::validate(QString &input, int &cursor) const
     {
         Q_UNUSED(cursor);
         // Avoid a hard error on empty string.
         if (input.size() == 0) {
             return QValidator::Intermediate;
         } else {
 
             const QLocale l = locale();
             const auto parsed = parseUnsignedInteger(input, l);
 
             /*
              * The actual value is a don't care at this point.
              * All that matters is the input can be parsed
              */
             return parsed ? QValidator::Acceptable : QValidator::Invalid;
         }
     }
 }