baseqstring.h

#pragma once

#include "basetoqt.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 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=' ',char format='g',int precision=-1) {
    format;  precision;
    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,char format,int precision) {
    format;  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(v.x(),w,fill,fmt,prec);
    s = s.arg(v.y(),w,fill,fmt,prec);
    s = s.arg(v.z(),w,fill,fmt,prec);
    return s;
}

BASE_EXPORT QString clip(const QString &in,int length);
BASE_EXPORT bool match(const QString &keyword,const QString &token);
BASE_EXPORT void matchSynonymsAllowed(bool b);
BASE_EXPORT QString build(const QString &s,const QVariant &v1=QVariant(),const QVariant &v2=QVariant(),
                          const QVariant &v3=QVariant(),const QVariant &v4=QVariant(),
                          const QVariant &v5=QVariant(),const QVariant &v6=QVariant());

BASE_EXPORT QString toBytes(const quint64 &ul);

BASE_EXPORT QString readLine(QDataStream &ds,qint64 maxlen=0);
BASE_EXPORT QString readWord(QDataStream &ds,qint64 maxlen=0,const QString &separators=" \t\r\n");
BASE_EXPORT QString cleanupTypename(const char *name);
// 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 QString &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::fromUtf8(in.c_str()); }
// 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;
        auto len = in.size();
        auto *p = in.constData();
        for (size_t i = 0; i<len; ++i) {
            h = 31 * h + p[i].toUpper().unicode();
        }
        return h;
    }
};


inline string tostring(const QString &s) {  return s.toStdString(); }

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>;

// EoF