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 Vector2<T> &v,int width=0,char fmt='g',int prec=-1,char fill=' ') {…}
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 Vector3<T> &v,int width=0,char fmt='g',int prec=-1,char fill=' ') {…}
 
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 AVector2<T> &v,int width=0,char fmt='g',int prec=-1,char fill=' ') {…}
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;
}
template <class T> inline QString toQString(const AVector3<T> &v,int width=0,char fmt='g',int prec=-1,char fill=' ') {…}
 
 
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 QStringCILess2 {…};
struct QStringLocalLess2 {
public:
    bool operator()(const QString &left, const QString &right) const {
        return QString::localeAwareCompare(left,right) < 0;
    }
};
struct QStringLocalLess2 {…};
struct QStringCIEqual2 {
public:
    bool operator()(const QString &left, const QString &right) const {
        return left.compare(right,Qt::CaseInsensitive) == 0;
    }
};
struct QStringCIEqual2 {…};
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;
    }
};
struct QStringCIHash2 {…};
 
 
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);
    }
};
struct fmt::formatter<QString> : public fmt::formatter<string> {…};
 
// For the model information system
using StateInfoOutput = QStringMap<QStringList>;
 
struct StateInfoGroup {
    StateInfoGroup() { clear(); }
    StateInfoGroup(const StateInfoGroup& vt) { StateInfoGroup::operator= (vt); }
    const StateInfoGroup& operator=(const StateInfoGroup& vt) {
        groups_ = vt.groups_;
        return *this;
    }
 
    std::vector<std::unordered_map<IString,int>> groups_;
    int doneGroup_ = 0;
    void clear() { groups_.clear(); doneGroup_ = 0; groups_.resize(128); }
    void update(const std::vector<std::pair<int,IString>> &gi) {
        for (auto &v: gi) {
            doneGroup_ += 1;
            groups_[v.first][v.second] += 1;
        }
    }
    void reconcile(const StateInfoGroup &other) {
        doneGroup_ += other.doneGroup_;        
        for (int j=0; j<(int)other.groups_.size(); ++j) {
            for (auto &v: other.groups_[j]) 
                groups_[j][v.first] += v.second;
        }
    }
    int slotsUsed() const {
        int ret = 0;
        for (auto &v: groups_)
            if (v.size())
                ++ret;
        return ret;
    }
};
struct StateInfoGroup {…};
 
struct StateInfoValues {
    std::vector<std::pair<double,quint64>> lvals_, hvals_;
    StateInfoValues() {}
    StateInfoValues(const StateInfoGroup& vt) { StateInfoValues::operator=(vt); }
    const StateInfoValues& operator=(const StateInfoValues& vt) {
        lvals_ = vt.lvals_;
        hvals_ = vt.hvals_;
        return *this;
    }
    void clear() { lvals_.clear(); hvals_.clear(); }
    void initialize(const std::vector<double> &cval,quint64 id) {
        for (auto &v: cval) {
            lvals_.push_back({v,id});
            hvals_.push_back({v,id});
        }
    }
    void update(const std::vector<double> &cval,quint64 id) {
        for (int i=0; i<(int)cval.size(); ++i) {
            if (cval[i] < lvals_[i].first)
                lvals_[i] = {cval[i],id};
            else if (cval[i] > hvals_[i].first)
                hvals_[i] = {cval[i],id};
        }
    }
    void reconcile(const StateInfoValues &cval) {
        for (int i=0; i<(int)cval.lvals_.size(); ++i) {
            if (cval.lvals_[i].first < lvals_[i].first)
                lvals_[i] = cval.lvals_[i];
            if (cval.hvals_[i].first > hvals_[i].first)
                hvals_[i] = cval.hvals_[i];
        }
    }
};
struct StateInfoValues {…};
// EOF
 
using QSL = QStringList;
 
template <typename T>
QString QSN(const T &t) { return toQString(t); }
 
// macro for converting integers to numbers with thousands separators
template <typename T>
QString NUMSEP(const T &t) { return QString("%L1").arg(t); }
// EoF