baseqstring.h

#pragma once
#include "basetoqt.h"
#include "basestring.h"
 
//#include <xfunctional>
 
BASE_EXPORT QString toQString(const QString &s,int width=0,char fill=' ');
BASE_EXPORT QString toQString(const char *str,int width=0,char fill=' '); 
BASE_EXPORT QString toQString(const qint8 &v,int width=0,char fill=' ');  
BASE_EXPORT QString toQString(const quint8 &v,int width=0,char fill=' ');  
BASE_EXPORT QString toQString(const qint16 &v,int width=0,char fill=' ');    
BASE_EXPORT QString toQString(const quint16 &v,int width=0,char fill=' ');   
BASE_EXPORT QString toQString(const qint32 &v,int width=0,char fill=' ');    
BASE_EXPORT QString toQString(const quint32 &v,int width=0,char fill=' ');   
BASE_EXPORT QString toQString(const qint64 &v,int width=0,char fill=' ');    
BASE_EXPORT QString toQString(const quint64 &v,int width=0,char fill=' ');   
BASE_EXPORT QString toQString(const wstring &v,int width,char fill=' ');  
BASE_EXPORT QString toQString(const string &v, int width, char fill = ' '); 
BASE_EXPORT QString toQString(const float & v,int width=0,char format='g',int precision=-1,char fill=' ');  
BASE_EXPORT QString toQString(const double &v,int width=0,char format='g',int precision=-1,char fill=' ');  
BASE_EXPORT QString toQString(const SymTensor &v,int width=0,char format='g',int precision=-1,char fill=' ');  
BASE_EXPORT QString toQString(const QVariant &v,int width=0,char fill=' ',char format='g',int precision=-1);   
BASE_EXPORT QString toQString(const void *v,int width=0,char fill=' ');
BASE_EXPORT QString toQString(bool b,const QString &out="on,off",int width=0,char fill=' ');
 
 
// Template version of toQString, that uses the same argument list
template <class T>
QString toQStringT(const T &t,int width=0,char fill=' ',[[maybe_unused]] char format='g',
                   [[maybe_unused]] int precision=-1) {
    return toQString(t,width,fill);
}
template <>
inline QString toQStringT(const float &t,int width,char fill,char format,int precision) {
    return toQString(t,width,format,precision,fill);
}
template <>
inline QString toQStringT(const double &t,int width,char fill,char format,int precision) {
    return toQString(t,width,format,precision,fill);
}
template <>
inline QString toQStringT(const QVariant &t,int width,char fill,char format,int precision) {
    return toQString(t,width,fill,format,precision);
}
template <>
inline QString toQStringT(const bool &b,int width,char fill,[[maybe_unused]] char format,
                          [[maybe_unused]] int precision) {
    return toQString(b,"on,off",width,fill);
}
 
template <class T> inline QString toQString(const Vector2<T> &v,int width=0,char fmt='g',int prec=-1,char fill=' ') {
    QString s("(%1,%2)");
    int w = (std::abs(width) - 3) / 2;
    if (width<0) w = -1;
    s = s.arg(toQStringT(v.x(),w,fill,fmt,prec));
    s = s.arg(toQStringT(v.y(),w,fill,fmt,prec));
    return s;
}
template <class T> inline QString toQString(const Vector3<T> &v,int width=0,char fmt='g',int prec=-1,char fill=' ') {
    QString s("(%1,%2,%3)");
    int w = (std::abs(width) - 4) / 3;
    if (width<0) w = -1;
    s = s.arg(toQStringT(v.x(),w,fill,fmt,prec));
    s = s.arg(toQStringT(v.y(),w,fill,fmt,prec));
    s = s.arg(toQStringT(v.z(),w,fill,fmt,prec));
    return s;
}
 
template <class T> inline QString toQString(const AVector2<T> &v,int width=0,char fmt='g',int prec=-1,char fill=' ') {
    QString s("(%1)");
    int w = (std::abs(width) - 3) / 2;
    if (width<0) w = -1;
    s = s.arg(toQStringT(v.z(),w,fill,fmt,prec));
    return s;
}
template <class T> inline QString toQString(const AVector3<T> &v,int width=0,char fmt='g',int prec=-1,char fill=' ') {
    QString s("(%1,%2,%3)");
    int w = (std::abs(width) - 4) / 3;
    if (width<0) w = -1;
    s = s.arg(toQStringT(v.x(),w,fill,fmt,prec));
    s = s.arg(toQStringT(v.y(),w,fill,fmt,prec));
    s = s.arg(toQStringT(v.z(),w,fill,fmt,prec));
    return s;
}
 
 
BASE_EXPORT QString toBytes(const quint64 &ul);
inline string tostring(const QString &s) {  return s.toStdString(); }
inline StringList toStringList(const QStringList &sl);
inline QStringList toQStringList(const StringList &sl);
inline StringList fromQStringList(const QStringList &sl);
inline Buffer toBuffer(const QByteArray &ba);
 
BASE_EXPORT QString readLine(QDataStream &ds,qint64 maxlen=0);
BASE_EXPORT QString readWord(QDataStream &ds,qint64 maxlen=0,const QString &separators=" \t\r\n");
// Converts the string This is a "test"  to "This ia a \"test\""
BASE_EXPORT QString enquoteString(const QString &s,QChar quote='"');
 
 
BASE_EXPORT bool isInt(const QString &in,int *i=0);
BASE_EXPORT bool isUInt(const QString &in,uint *u=0); 
BASE_EXPORT bool isLong(const QString &in,qint64 *l=0); 
BASE_EXPORT bool isULong(const QString &in,quint64 *ul=0); 
BASE_EXPORT bool isDouble(const QString &in,double *d=0); 
BASE_EXPORT bool isBool(const QString &in,bool *b=0,const QString &out="on,off,true,false,yes,no");
BASE_EXPORT bool toBool(const QString &in,bool *ok=0,const QString &out="on,off,true,false,yes,no");
//inline string toString(const wsString &in) { return in.toStdWString(); }
//inline String toString(const std::wstring &in) { return in; }
//inline String toString(const string &in) { return QString::fromUtf8(in.c_str()).toStdWString(); }
inline QString toQString(const std::wstring &in) { return QString::fromStdWString(in); }
inline QString toQString(const string &in) { return QString::fromStdString(in); }
// compares two Strings
//inline int compare(const String &s1,const String &s2,bool case_sensitive=false) {
//    if (case_sensitive) return s1.compare(s2);
//#ifdef __LINUX
//    else return wcscasecmp(s1.c_str(),s2.c_str());
//#else
//    else return _wcsicmp(s1.c_str(),s2.c_str());
//#endif
//}
 
// std::hash interface for QStrings!
//namespace std {
//    template <>
//    class hash<QString> {
//    public:
//        size_t operator()(const QString &s) const { return qHash(s); }
//    };
//}
 
// < and == functors for strings - to use in std containers when CI comparisons are wanted!
struct QStringCILess2 {
public:
    bool operator()(const QString &left, const QString &right) const {
        return left.compare(right,Qt::CaseInsensitive) < 0;
    }
};
struct QStringLocalLess2 {
public:
    bool operator()(const QString &left, const QString &right) const {
        return QString::localeAwareCompare(left,right) < 0;
    }
};
struct QStringCIEqual2 {
public:
    bool operator()(const QString &left, const QString &right) const {
        return left.compare(right,Qt::CaseInsensitive) == 0;
    }
};
struct QStringCIHash2 {
public:
    uint operator()(const QString &in) const {
        uint h = 0;
        int len = in.size();
        auto *p = in.constData();
        for (int i = 0; i<len; ++i) {
            h = 31 * h + p[i].toUpper().unicode();
        }
        return h;
    }
};
 
 
template <typename T> using QStringMap = std::map<QString, T, QStringCILess2>;
 
template <typename T> using QStringHashMap = std::unordered_map<QString, T, QStringCIHash2, QStringCIEqual2>;
 
using QStringSet = std::set<QString,QStringCILess2>;
 
using QStringHashSet = std::unordered_set<QString, QStringCIHash2, QStringCIEqual2>;
 
inline StringList toStringList(const QStringList &qsl) {
    StringList sl;
    for (auto &s : qsl)
        sl.push_back(s.toStdString());
    return sl;
}
 
inline QStringList toQStringList(const StringList &sl) {
    QStringList qsl;
    for (auto &s : sl)
        qsl.push_back(QString::fromStdString(s));
    return qsl;
}
 
inline StringList fromQStringList(const QStringList &qsl) {
    StringList sl;
    for (auto &qs : qsl)
        sl.push_back(qs.toStdString());
    return sl;
}
 
inline Buffer toBuffer(const QByteArray &ba) {
    Buffer buf;   buf.reserve(ba.size());
    buf.insert(buf.end(),ba.begin(), ba.end());
    return buf;
}
 
// This allows you to send QStrings to a fmt::format
template <>
struct fmt::formatter<QString> : public fmt::formatter<string> {
    template <typename ParseContext>
    constexpr auto parse(ParseContext &ctx) { return fmt::formatter<string>::parse(ctx); }
 
    template <typename FormatContext>
    auto format(QString const &val, FormatContext &ctx) {
        return fmt::formatter<string>::format(val.toStdString(), ctx);
    }
};
// EoF