kstring.h

Go to the documentation of this file.

/****************************************************************************
**
** This file is part of KDWinutils, KDAB's MFC to Qt migration tool.
**
** Copyright (C) 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
** All rights reserved.
**
** This file is intended solely for use by the migration tools and services
** provided by Klarälvdalens Datakonsult AB.
**
**  Any other use or distribution of this software that is not otherwise agreed
**  upon in writing and signed by an authorized representative of Klarälvdalens
**  Datakonsult AB, KDAB (USA) LLC, KDAB (Deutschland) GmbH & Co. K.G.,
**  KDAB (France) SAS, KDAB (UK), Ltd., or any future subsidiary of Klarälvdalens
**  Datakonsult AB is hereby prohibited.
**
**  Contact info@kdab.com if any conditions stated above are unclear to you.
**
****************************************************************************/
 
#pragma once
 
#include "../kdwinutils_global.h"
 
#include <QString>
 
#ifdef KDWINUTILS_WITHMFC
#include <afxwin.h>
#endif // KDWINUTILS_WITHMFC
 
#include <string>
 
KDWINUTILS_BEGIN_NAMESPACE
 
class KDWINUTILS_EXPORT KString : public QString
{
public:
    KString();
    ~KString();
    using QString::QString;
    /* implicit */ KString(const wchar_t *text);
    /* implicit */ KString(const QString &str);
    /* implicit */ KString(QString &&str) noexcept;
    /* implicit */ KString(const std::wstring_view str);
 
    // Assignment operators. We redefine a few (and inherit the others),
    // so that they return KString (and not QString)
    using QString::operator=;
    KString &operator=(const char *str);
    KString &operator=(const wchar_t *str);
    KString &operator=(const QString &str);
    KString &operator=(QString &&str) noexcept;
    KString &operator=(const std::wstring_view str);
 
    // In-place concatenation
    using QString::operator+=;
    KString &operator+=(const char *str);
    KString &operator+=(const wchar_t *str);
    KString &operator+=(const QString &str);
    KString &operator+=(QStringView str);
 
    /* Inherited operators
     * This comment exclude those operators to be listed as missing API,
     * by the ApiComparator tool.
     *
     * [ApiComparator: SKIP] bool operator==()
     * [ApiComparator: SKIP] bool operator!=()
     * [ApiComparator: SKIP] bool operator>=()
     * [ApiComparator: SKIP] bool operator<=()
     * [ApiComparator: SKIP] bool operator>()
     * [ApiComparator: SKIP] bool operator<()
     */
 
#ifdef KDWINUTILS_WITHMFC
    // CString specific methods, available only on Windows with MFC set
    explicit KString(const CString &str);
    CString toCString() const;
    operator CString() const;
    KString &operator=(const CString &str);
    KString &operator+=(const CString &str);
#endif // KDWINUTILS_WITHMFC
 
    [[deprecated("Use explicit conversion methods")]] explicit operator const char *() const;
 
    // MFC API from here on
 
    template <typename... Ts>
    KString &Format(const wchar_t *format, Ts &&...args)
    {
        *this = FormatString(format, std::forward<Ts>(args)...);
        return *this;
    }
 
    int Compare(const KString &other) const;
 
    int CompareNoCase(const KString &other) const;
 
    int Find(const KString &other, int iStart = 0) const;
 
    bool IsEmpty() const;
 
    void Empty();
 
    int GetLength() const;
 
    KString &MakeLower();
 
    KString &MakeUpper();
 
    KString Left(int nCount) const;
 
    KString Right(int nCount) const;
 
    KString &Trim();
 
    KString &Trim(QChar chTarget);
 
    KString &Trim(const KString &charsTarget);
 
    KString &TrimLeft();
 
    KString &TrimLeft(QChar charTarget);
 
    KString &TrimLeft(const KString &charsTarget);
 
    KString &TrimRight();
 
    KString &TrimRight(QChar charTarget);
 
    KString &TrimRight(const KString &charsTarget);
 
    int Insert(int iIndex, QChar character);
 
    int Insert(int iIndex, const KString &string);
 
    int Remove(QChar chRemove);
 
    int Collate(const KString &other) const;
 
    int CollateNoCase(const KString &other) const;
 
    KString Mid(int iFirst, int nCount = -1) const;
 
    int Delete(int iIndex, int nCount = 1);
 
    bool GetEnvironmentVariable(const KString &envVar);
 
    int FindOneOf(const KString &charSet) const;
 
    KString Tokenize(const KString &tokens, int &iStart) const;
 
    int Replace(const KString &before, const KString &after);
 
    int Replace(QChar before, QChar after);
 
    KString &MakeReverse();
 
    int ReverseFind(QChar ch);
 
    KString SpanExcluding(const KString &excludeChars) const;
 
    KString SpanIncluding(const KString &includeChars) const;
 
    // Utility methods
 
    template <typename T, typename... Ts>
    static QString FormatString(T &&format, Ts... args);
 
private:
    // Transform all string types to QByteArray if needed
    template <typename T>
    static auto ToByteArray(T &&arg);
 
    // Transform any QByteArray into a const char * using QByteArray::constData
    template <typename T>
    static auto ToConstData(T &&arg);
};
 
KDWINUTILS_EXPORT KString operator+(const KString &s1, const KString &s2);
 
// We have a lot of operator+ overloads available because we inherit from
// QString. We are also implicitly convertible *from* QString, and *to* QString
// and CString. This generates a lot of ambiguities, and may be inconvenient to
// use (because they return QString). So, we define some extra overloads for
// our own benefit.
//
// We still need to be very careful when doing so -- Qt/MFC may be relying on
// implicit conversions already on certain overloads.
//
// For instance: operator+(QString, QLatin1StringView) doesn't exist. Instead,
// operator+(QString, QString) gets picked, through the implicit conversion of
// QLatin1String to QString. If we add operator+(KString, QL1SV) we'd make that
// call ambiguous.
//
// Here we try to make our candidates worse than existing ones by making them
// constrained function templates.
#define KDWINUTILS_KSTRING_DEFINE_OP_PLUS(StringClass)                                                                 \
    template <typename T>                                                                                              \
    inline std::enable_if_t<std::is_same_v<T, KString>, KString> operator+(T const &s1, StringClass const &s2)         \
    {                                                                                                                  \
        return s1 + KString(s2);                                                                                       \
    }                                                                                                                  \
    template <typename T>                                                                                              \
    inline std::enable_if_t<std::is_same_v<T, KString>, KString> operator+(StringClass const &s1, T const &s2)         \
    {                                                                                                                  \
        return KString(s1) + s2;                                                                                       \
    }
 
KDWINUTILS_KSTRING_DEFINE_OP_PLUS(QString)
KDWINUTILS_KSTRING_DEFINE_OP_PLUS(const char *)
KDWINUTILS_KSTRING_DEFINE_OP_PLUS(const wchar_t *)
KDWINUTILS_KSTRING_DEFINE_OP_PLUS(QLatin1StringView)
#ifdef KDWINUTILS_WITHMFC
KDWINUTILS_KSTRING_DEFINE_OP_PLUS(CString)
#endif // KDWINUTILS_WITHMFC
 
#undef KDWINUTILS_KSTRING_DEFINE_OP_PLUS
 
template <typename T, typename... Ts>
QString KString::FormatString(T &&format, Ts... args)
{
    // The only way to format using QString::asprintf is to transform into a QByteArray and use constData
    // The const data has the same lifespan as the QByteArray, so we must keep the QByteArray around before calling
    // QString::asprintf
    // 1. Create a tuple with all string parameters changed to a QByteArray if needed
    auto convertStrings = std::make_tuple(ToByteArray(std::forward<T>(format)), ToByteArray(std::forward<Ts>(args))...);
 
    // 2. Create another tuple with all string parameters as const char * (they exists because the QByteArray are in
    // the other tuple)
    auto convertArgs = std::apply(
        [&](const auto &...args) {
            return std::tuple(ToConstData(args)...);
        },
        convertStrings);
 
    // 3. run QString::asprintf with those parameters
    return std::apply(QString::asprintf, convertArgs);
}
 
template <typename T>
auto KString::ToByteArray(T &&arg)
{
    if constexpr (std::is_same_v<QString, std::decay_t<T>>)
        return arg.toUtf8();
    else if constexpr (std::is_same_v<KString, std::decay_t<T>>)
        return arg.toUtf8();
    else if constexpr (std::is_same_v<const wchar_t *, std::decay_t<T>>)
        return QString::fromWCharArray(std::forward<T>(arg)).toUtf8();
    else if constexpr (std::is_same_v<std::wstring, std::decay_t<T>>)
        return QString::fromStdWString(std::forward<T>(arg)).toUtf8();
    else if constexpr (std::is_same_v<std::string, std::decay_t<T>>)
        return QString::fromStdString(std::forward<T>(arg)).toUtf8();
#ifdef KDWINUTILS_WITHMFC
    else if constexpr (std::is_same_v<CStringW, std::decay_t<T>>)
        return QString::fromWCharArray(std::forward<T>(arg), arg.GetLength()).toUtf8();
    else if constexpr (std::is_same_v<CStringA, std::decay_t<T>>)
        return (const char *)arg;
#endif // KDWINUTILS_WITHMFC
    else
        return std::forward<T>(arg);
}
 
template <typename T>
auto KString::ToConstData(T &&arg)
{
    if constexpr (std::is_same_v<QByteArray, std::decay_t<T>>)
        return arg.constData();
    else
        return std::forward<T>(arg);
}
 
KDWINUTILS_END_NAMESPACE