stringutils.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_STRINGUTILS_H
#define SWIFT_MISC_STRINGUTILS_H
 
#include <algorithm>
#include <atomic>
 
#include <QByteArray>
#include <QDateTime>
#include <QFlags>
#include <QList>
#include <QMap>
#include <QMapIterator>
#include <QSet>
#include <QString>
#include <QStringRef>
#include <QStringView>
#include <QtGlobal>
 
#include "misc/range.h"
#include "misc/swiftmiscexport.h"
#include "misc/typetraits.h"
 
template <class T1, class T2>
class QMap;
 
namespace swift::misc
{
    template <class F>
    QString removeChars(const QString &s, F predicate)
    {
        QString result;
        std::copy_if(s.begin(), s.end(), std::back_inserter(result), [=](auto c) { return !predicate(c); });
        return result;
    }
 
    inline QString removeIfInString(const QString &string, const QString &inString)
    {
        return removeChars(string.simplified(), [&](QChar c) { return inString.contains(c); });
    }
 
    inline QString removeIfNotInString(const QString &string, const QString &inString)
    {
        return removeChars(string.simplified(), [&](QChar c) { return !inString.contains(c); });
    }
 
    inline QString removeLineBreakAndTab(const QString &s)
    {
        return removeChars(s, [](QChar c) { return c == '\n' || c == '\t'; });
    }
 
    SWIFT_MISC_EXPORT QString removeDateTimeSeparators(const QString &s);
 
    template <class F>
    bool containsChar(const QString &s, F predicate)
    {
        return std::any_of(s.begin(), s.end(), predicate);
    }
 
    inline bool containsLineBreakOrTab(const QString &s)
    {
        return containsChar(s, [](QChar c) { return c == '\n' || c == '\t'; });
    }
 
    template <class F>
    int indexOfChar(const QString &s, F predicate)
    {
        auto it = std::find_if(s.begin(), s.end(), predicate);
        if (it == s.end()) { return -1; }
        return static_cast<int>(std::distance(s.begin(), it));
    }
 
    SWIFT_MISC_EXPORT int nthIndexOf(const QString &string, QChar ch, int nth = 1,
                                     Qt::CaseSensitivity cs = Qt::CaseInsensitive);
 
    template <class F>
    QList<QStringRef> splitStringRefs(const QString &s, F predicate)
    {
        QList<QStringRef> result;
        auto notPredicate = [=](auto c) { return !predicate(c); };
        auto begin = s.begin();
        while (true)
        {
            begin = std::find_if(begin, s.end(), notPredicate);
            if (begin == s.end()) { return result; }
            auto end = std::find_if(begin, s.end(), predicate);
            result.push_back(QStringRef(&s, std::distance(s.begin(), begin), std::distance(begin, end)));
            begin = end;
        }
    }
 
    SWIFT_MISC_EXPORT QList<QStringRef> splitLinesRefs(const QString &s);
 
    template <class F>
    void splitStringRefs(const QString &&, F) = delete;
 
    void splitLinesRefs(const QString &&) = delete;
 
    template <class F>
    QStringList splitString(const QString &s, F predicate)
    {
        return makeRange(splitStringRefs(s, predicate)).transform([](QStringRef sr) { return sr.toString(); });
    }
 
    SWIFT_MISC_EXPORT QStringList splitLines(const QString &s);
 
    SWIFT_MISC_EXPORT QByteArray utfToPercentEncoding(const QString &s, const QByteArray &allow = {},
                                                      char percent = '%');
 
    SWIFT_MISC_EXPORT QString utfFromPercentEncoding(const QByteArray &ba, char percent = '%');
 
    template <class K, class V>
    QString qmapToString(const QMap<K, V> &map)
    {
        QString s;
        static const QString kv("%1: %2 ");
        QMapIterator<K, V> i(map);
        while (i.hasNext())
        {
            i.next();
            s.append(kv.arg(i.key()).arg(i.value()));
        }
        return s.trimmed();
    }
 
    SWIFT_MISC_EXPORT QMap<QString, QString> parseIniValues(const QString &data);
 
    inline bool is09(const QChar &c) { return c >= u'0' && c <= u'9'; }
 
    inline bool is09OrSeparator(const QChar &c) { return is09(c) || c == u',' || c == '.'; }
 
    inline const QString &safeAt(const QStringList &stringList, int index)
    {
        if (stringList.size() > index) { return stringList.at(index); }
        static const QString empty;
        return empty;
    }
 
    inline bool isDigitsOnlyString(const QString &testString)
    {
        return !containsChar(testString, [](QChar c) { return !c.isDigit(); });
    }
 
    inline bool is09OnlyString(const QString &testString)
    {
        return !containsChar(testString, [](QChar c) { return !is09(c); });
    }
 
    inline bool is09OrSeparatorOnlyString(const QString &testString)
    {
        return !containsChar(testString, [](QChar c) { return !is09OrSeparator(c); });
    }
 
    inline QString digitOnlyString(const QString &string)
    {
        return removeChars(string, [](QChar c) { return !c.isDigit(); });
    }
 
    inline QString char09OnlyString(const QString &string)
    {
        return removeChars(string, [](QChar c) { return !is09(c); });
    }
 
    inline QString char09OrSeparatorOnlyString(const QString &string)
    {
        return removeChars(string, [](QChar c) { return !is09OrSeparator(c); });
    }
 
    inline QString asciiOnlyString(const QString &string)
    {
        return removeChars(string.simplified(), [](QChar c) { return c.unicode() > 127; });
    }
 
    SWIFT_MISC_EXPORT QString inApostrophes(const QString &in, bool ignoreEmpty = false);
 
    SWIFT_MISC_EXPORT QString inQuotes(const QString &in, bool ignoreEmpty = false);
 
    SWIFT_MISC_EXPORT bool hasBalancedQuotes(const QString &in, char quote = '"');
 
    SWIFT_MISC_EXPORT QString removeSurroundingApostrophes(const QString &in);
 
    SWIFT_MISC_EXPORT QString removeSurroundingQuotes(const QString &in);
 
    SWIFT_MISC_EXPORT const QString &boolToOnOff(bool v);
 
    SWIFT_MISC_EXPORT const QString &boolToYesNo(bool v);
 
    SWIFT_MISC_EXPORT const QString &boolToTrueFalse(bool v);
 
    SWIFT_MISC_EXPORT const QString &boolToEnabledDisabled(bool v);
 
    SWIFT_MISC_EXPORT const QString &boolToNullNotNull(bool isNull);
 
    SWIFT_MISC_EXPORT bool stringToBool(const QString &boolString);
 
    SWIFT_MISC_EXPORT int fuzzyShortStringComparision(const QString &str1, const QString &str2,
                                                      Qt::CaseSensitivity cs = Qt::CaseSensitive);
 
    SWIFT_MISC_EXPORT QString intToHex(int value, int digits = 2);
 
    SWIFT_MISC_EXPORT QString dotToLocaleDecimalPoint(QString &input);
 
    SWIFT_MISC_EXPORT QString dotToLocaleDecimalPoint(const QString &input);
 
    SWIFT_MISC_EXPORT QString stripDesignatorFromCompleterString(const QString &candidate);
 
    SWIFT_MISC_EXPORT QStringList textCodecNames(bool simpleNames, bool mibNames);
 
    SWIFT_MISC_EXPORT QString simplifyAccents(const QString &candidate);
 
    SWIFT_MISC_EXPORT QString simplifyByDecomposition(const QString &candidate);
 
    SWIFT_MISC_EXPORT bool caseInsensitiveStringCompare(const QString &c1, const QString &c2);
 
    SWIFT_MISC_EXPORT bool stringCompare(const QString &c1, const QString &c2, Qt::CaseSensitivity cs);
 
    SWIFT_MISC_EXPORT QString simplifyNameForSearch(const QString &name);
 
    SWIFT_MISC_EXPORT QString withQuestionMark(const QString &question);
 
    SWIFT_MISC_EXPORT QDateTime fromStringUtc(const QString &dateTimeString, const QString &format);
 
    SWIFT_MISC_EXPORT QDateTime fromStringUtc(const QString &dateTimeString, Qt::DateFormat format = Qt::TextDate);
 
    SWIFT_MISC_EXPORT QDateTime fromStringUtc(const QString &dateTimeString, const QLocale &locale,
                                              QLocale::FormatType format);
 
    SWIFT_MISC_EXPORT QDateTime parseMultipleDateTimeFormats(const QString &dateTimeString);
 
    SWIFT_MISC_EXPORT QDateTime parseDateTimeStringOptimized(const QString &dateTimeString);
 
    SWIFT_MISC_EXPORT QString joinStringSet(const QSet<QString> &set, const QString &separator);
 
    SWIFT_MISC_EXPORT QString removeComments(const QString &in, bool removeSlash, bool removeDoubleSlash);
 
    SWIFT_MISC_EXPORT const QString &defaultIfEmpty(const QString &candidate, const QString &defaultIfEmpty);
 
    SWIFT_MISC_EXPORT bool containsAny(const QString &testString, const QStringList &any, Qt::CaseSensitivity cs);
 
    SWIFT_MISC_EXPORT double parseFraction(const QString &fraction,
                                           double failDefault = std::numeric_limits<double>::quiet_NaN());
 
    SWIFT_MISC_EXPORT QString cleanNumber(const QString &number);
 
    template <typename T, typename = void>
    struct TString;
 
    // Stringification traits specializations.
    template <>
    struct TString<QString>
    {
        static QString toQString(const QString &s) { return s; }
    };
    template <>
    struct TString<QStringRef>
    {
        static QString toQString(const QStringRef &sr) { return sr.toString(); }
    };
    template <>
    struct TString<QStringView>
    {
        static QString toQString(QStringView sv) { return sv.toString(); }
    };
    template <>
    struct TString<QChar>
    {
        static QString toQString(QChar c) { return c; }
    };
    template <>
    struct TString<char>
    {
        static QString toQString(char c) { return QChar(c); }
    };
    template <>
    struct TString<bool>
    {
        static QString toQString(bool n) { return QString::number(n); }
    };
    template <>
    struct TString<int>
    {
        static QString toQString(int n) { return QString::number(n); }
    };
    template <>
    struct TString<uint>
    {
        static QString toQString(uint n) { return QString::number(n); }
    };
    template <>
    struct TString<long>
    {
        static QString toQString(long n) { return QString::number(n); }
    };
    template <>
    struct TString<ulong>
    {
        static QString toQString(ulong n) { return QString::number(n); }
    };
    template <>
    struct TString<qlonglong>
    {
        static QString toQString(qlonglong n) { return QString::number(n); }
    };
    template <>
    struct TString<qulonglong>
    {
        static QString toQString(qulonglong n) { return QString::number(n); }
    };
    template <>
    struct TString<short>
    {
        static QString toQString(short n) { return QString::number(n); }
    };
    template <>
    struct TString<ushort>
    {
        static QString toQString(ushort n) { return QString::number(n); }
    };
    template <>
    struct TString<float>
    {
        static QString toQString(float n) { return QString::number(n); }
    };
    template <>
    struct TString<double>
    {
        static QString toQString(double n) { return QString::number(n); }
    };
    template <typename T>
    struct TString<T, std::enable_if_t<std::is_enum_v<T>>>
    {
        static QString toQString(T e) { return QString::number(e); }
    };
    template <typename T>
    struct TString<T, std::enable_if_t<std::is_convertible_v<T, QString>>>
    {
        static QString toQString(const T &v) { return v; }
    };
    template <typename T>
    struct TString<T, std::enable_if_t<THasToQString<T>::value>>
    {
        static QString toQString(const T &v) { return v.toQString(); }
    };
    template <typename T>
    struct TString<QFlags<T>>
    {
        static QString toQString(QFlags<T> n) { return TString<typename QFlags<T>::Int>::toQString(n); }
    };
    template <typename T>
    struct TString<std::atomic<T>>
    {
        static QString toQString(const std::atomic<T> &n) { return TString<T>::toQString(n); }
    };
} // namespace swift::misc
 
#endif // SWIFT_MISC_STRINGUTILS_H