basestring.h

Go to the documentation of this file.

#pragma once
#include "basedef.h"
#include "to.h"
#include <cctype>
#include <cwctype>
#include <string>
#include <vector>
#include <string_view>
#ifdef _WIN32
#include <codeanalysis\warnings.h>
#endif
 
// Includes the header-only version of the fmt::format library, which we use for now until
//   the C++20 std::format library is supported by Intel/VS
#define FMT_HEADER_ONLY
//#define FMT_API BASE_EXPORT
//#define FMT_EXTERN_TEMPLATE_API BASE_EXPORT
#ifdef _WIN32
#  include <codeanalysis\warnings.h>
#endif
 
INTELWARNING(186) // Pointless comparison of unsigned integer with zero
PUSHWARNING
VSWARNING(ALL_CODE_ANALYSIS_WARNINGS)
INTELWARNING(177)
INTELWARNING(280) // selector expression is constant
GNUWARNING("-Wstringop-overflow")
#ifdef CLANGCOMP
#  pragma warning ( disable : ALL_CODE_ANALYSIS_WARNINGS ) // Nonstandard
#endif
#include "../fmt/format.h"
POPWARNING
 
// Global namespace versions of std strings
using wstring = std::wstring; // Old string class to avoid interface compatibility breaks
using string = std::string; // Bring into global namespace like the other base types (uint32, etc)
//using String = std::wstring;  // DEPRECATED - should not be used in new code.
 
// String conversion routines.
// These return a tuple, the first is the converted value and the second is whether the conversion was successful.
// If not successful the first value is a default construction.
BASE_EXPORT std::tuple<int32,bool>  isInt32(const string &in);
BASE_EXPORT std::tuple<uint32,bool> isUInt32(const string &in); 
BASE_EXPORT std::tuple<int64,bool>  isInt64(const string &in); 
BASE_EXPORT std::tuple<uint64,bool> isUInt64(const string &in); 
BASE_EXPORT std::tuple<double,bool> isDouble(const string &in); 
BASE_EXPORT std::tuple<bool,bool>   isBool(const string &in,const string &out="on,off,true,false,yes,no");
 
// String conversion routines - converts string directly, throwing out the success check.
// No exception is thrown on failure - just returns a default constructed value.
// This is a common template used just to avoid code repetition in the type-specific version
template <typename T,typename ... Args>
T toStringConv(const string &in,Args...args,bool te, std::tuple<T,bool> (*f)(const string &,Args...)) {
    auto [val, ok] = f(in,args...);
    if (te==true && ok==false)
#ifdef __LINUX
        throw std::runtime_error("String conversion error.");
#else
        throw std::exception("String conversion error.");
#endif
    return val;
}
inline int32  toInt32(const string &in, bool throwException = false) { return toStringConv<int32>(in, throwException, isInt32); }
inline uint32 toUInt32(const string &in,bool throwException=false) { return toStringConv<uint32>(in, throwException, isUInt32); }
inline int64  toInt64(const string &in,bool throwException=false) { return toStringConv<int64>(in, throwException, isInt64); }
inline uint64 toUInt64(const string &in,bool throwException=false) { return toStringConv<uint64>(in, throwException, isUInt64); }
inline double toDouble(const string &in,bool throwException=false) { return toStringConv<double>(in, throwException, isDouble); }
inline bool   toBool(const string &in, const string &out = "on,off,true,false,yes,no", bool throwException = false) { return toStringConv<bool,const string &>(in, out, throwException, isBool); }
 
 
// vector of strings - for convenience and to add some handy utility functions.
class StringList : public std::vector<string> {
  public:
    using std::vector<string>::vector;
    enum class Empty { Keep, Skip };
 
    StringList() {}
    StringList(std::initializer_list<string> list) : std::vector<string>(list) {}
    StringList(const StringList &s) : std::vector<string>(s) {}
    StringList(const std::vector<string> &v) : std::vector<string>(v) {}
    StringList(StringList &&v) noexcept : std::vector<string>(std::move(v)) {}
    StringList(std::vector<string> &&v) noexcept : std::vector<string>(std::move(v)) {}
 
    const StringList &operator=(const StringList &in) { std::vector<string>::operator=(in);  return *this; }
 
    const StringList &operator+=(const string &s) { push_back(s);  return *this; }
    const StringList &operator+=(const std::vector<string> &v) { for (auto &s : v) push_back(s); return *this; }
    const StringList &operator<<(const string &s) { return operator+=(s);  }
    const StringList &operator<<(const StringList &s) { return operator+=(s); }
    StringList operator+(const StringList &s) const { StringList ret(*this);  ret += s; return ret;  }
 
};
 
// String utility functions
BASE_EXPORT string              tostring(const std::wstring &s); // Converts wstring to string
BASE_EXPORT string              tostring(const std::u16string &s);
BASE_EXPORT string              tostring(const std::u32string &s);
BASE_EXPORT std::wstring        towstring(const string &s);      // Converts string ot wstring
BASE_EXPORT std::wstring        towstring(const std::u16string &s);
BASE_EXPORT std::u16string      tou16string(const string &s); // Converts string to u16string
BASE_EXPORT std::u16string      tou16string(const std::wstring &s); // Converts wstring to u16string
BASE_EXPORT std::u16string      tou16string(const std::string_view &s); // Converts string to u32string
BASE_EXPORT std::u32string      tou32string(const std::string &s);      // Converts string to u32string
BASE_EXPORT std::u32string      tou32string(const std::string_view &s); // Converts string to u32string
BASE_EXPORT string              toUpper(const string &s);        // All upper case
BASE_EXPORT string              toLower(const string &s);        // All lower case
BASE_EXPORT string              capitalizeFirstLetter(const string &s);
template <typename T,typename U> T join(const std::vector<T> &s,const U &sep);  // Note works on StringList
BASE_EXPORT std::vector<string> split(const string &s, const string &sep,bool keepEmptyParts=false);
BASE_EXPORT std::vector<string> splitRegex(const string &s,const string &regex,bool keepEmptyParts=false); // NOTE Case insensitive
BASE_EXPORT string              matchRegex(const string &s,const string &regex,string::size_type start=0); // NOTE Case insensitive
BASE_EXPORT string              replaceRegex(const string &s,const string &regex,const string &after); // NOTE Case insensitive
BASE_EXPORT string::size_type   findRegex(const string &s,const string &regex,string::size_type start=0); // NOTE Case insensitive
BASE_EXPORT bool                exactMatchRegex(const string &s,const string &regex); // NOTE Case insensitive
BASE_EXPORT string              trimmed(const string &s);    // Removes whitespace on front and back.
BASE_EXPORT string              simplified(const string &s); // As trimmed, but also reduces whitespace sequences inside to one space.
BASE_EXPORT string              replaceAll(const string &s, const string &sub,const string &newsub);  // Replace all instances of sub wiwth newsub in s
BASE_EXPORT string              toBase64(const std::vector<char> &in);
BASE_EXPORT std::vector<char>   fromBase64(const string &in);
BASE_EXPORT bool                startsWith(const string &in,const string &check, bool caseSensitive = false);
BASE_EXPORT bool                endsWith(const string &in, const string &check, bool caseSensitive = false);
BASE_EXPORT string              clipLen(const string &in,string::size_type length);
BASE_EXPORT string              cleanupTypename(const char *name);
BASE_EXPORT string              convertPercentToBracket(const string &s);
BASE_EXPORT string              remove(const string &s,char c);
 
// A buffer class - thin wrapper around std::vector<char>
// Useful in places where we would other use QByteArray.
class Buffer : public std::vector<char> {
  public:
    using std::vector<char>::vector;
    Buffer(const std::vector<char> &v) : std::vector<char>(v) {}
    Buffer(std::vector<char> &&v) : std::vector<char>(std::move(v)) {}
    Buffer(const char *c, size_t len) : std::vector<char>(c, c+len) {}
    explicit Buffer(const string &s)  : std::vector<char>(s.begin(),s.end()) {}
 
    const Buffer &operator=(const std::vector<char> &v) { std::vector<char>::operator=(v);  return *this; }
    const Buffer &operator=(std::vector<char> &&v) { std::vector<char>::operator=(std::move(v));  return *this; }
 
    void append(const char *data, uint64 len) { insert(end(),data, data+len); }
    void operator+=(const string &s) { insert(end(),s.begin(),s.end()); }
    string toString() const { return string(begin(), end()); }
    const char *constData() const { return data(); }
};
 
// As string::compare but the comparison is case insensitive
BASE_EXPORT int32 caseInsensitiveCompare(const string &s1, const string &s2);
BASE_EXPORT int32 caseInsensitiveCompare(const string &s1, const std::string_view &s2);
inline int32 caseInsensitiveCompare(const string &s1, const char *str) { return caseInsensitiveCompare(s1,std::string_view(str)); }
BASE_EXPORT uint64 caseInsensitiveHash(const string &s);
BASE_EXPORT uint64 caseInsensitiveFind(const string &s1, const string &s2, string::size_type start = 0);
BASE_EXPORT string caseInsensitiveReplace(const string &start,const string &before,const string &after);
BASE_EXPORT bool caseInsensitiveContains(const std::vector<string> &all, const string &s2);
BASE_EXPORT uint64 caseInsensitiveFind(const std::vector<string> &all, const string &s2);
BASE_EXPORT bool checkLeft(const string &s,const string &c); // Checks if c matches start of s (case insensitive)
inline bool equal(const string &s,const string &c) { return caseInsensitiveCompare(s,c)==0; } // Handy shorthand
inline bool contains(const string &s,const string &s2) { return caseInsensitiveFind(s,s2)!=string::npos; }
 
//*
//*    Specifically, compares to length of token or keyword, whichever is shorter.\n
//*    If token is longer than keyword no match.\n
//*    If keyword contains the character '^', that character is disregarded for comparison purposes
//*      and token must have at least as many characters as precede the '^' character.\n
//*    If a token has a starting hyphen '-', then it is ignored for matching.
//*    If a token has an internal hyphen 'one-two', then the hyphen must be present in keyword and
//*      BOTH sides are checked using matching rules and any possible '^' character.
//*/
BASE_EXPORT bool match(const string &keyword,const string &token);
BASE_EXPORT void matchSynonymsAllowed(bool b);
BASE_EXPORT bool matchSynonymsAllowed();
 
// Create a fmt::format specification using the parameters indicated  {:fw.pn}
// Note position indicator is not included (yet).
BASE_EXPORT string buildFormat(int64 width, char notation='\0', int precision=-1,char fill=' ');
 
namespace base {
    // Thesee are type->string conversion functions, for convenience.   less verbose than fmt::format
    //   and intended for use in formatted << output, but can be used in any string stuff.
    // ts stands for To String, fs stands for From String.
    // If you use these in text output I reccomend you put "using base::ts" at the start of the FUNCTION.
    template <class T>
    inline string ts(const T &t, int width=0, char notation = '\0', int precision = -1, char fill = ' ');
 
 
    // Concise conversion from string to type.   fsTest returns  a tuple with the second
    //   value being a success boolean.  fs just returns the type with an optional
    //   second argument indicating if an exception should be thrown on failure.
    template <typename T>
    std::tuple<T, bool> fsTest(const string &) { static_assert(sizeof(T{})==0); return {T{},false}; }
    template<> inline std::tuple<int32, bool>  fsTest(const string &in) { return isInt32(in);  }
    template<> inline std::tuple<uint32, bool> fsTest(const string &in) { return isUInt32(in);  }
    template<> inline std::tuple<int64, bool>  fsTest(const string &in) { return isInt64(in);  }
    template<> inline std::tuple<uint64, bool> fsTest(const string &in) { return isUInt64(in); }
    template<> inline std::tuple<double, bool> fsTest(const string &in) { return isDouble(in);  }
    template<> inline std::tuple<bool, bool>   fsTest(const string &in) { return isBool(in);  }
    template<> inline std::tuple<string, bool> fsTest(const string &in) { return {in,true}; }
 
    template <typename T> T fs(const string &, [[maybe_unused]] bool throwException = false) { static_assert(sizeof(T{})==0); return T{}; }
    template<> inline int32  fs(const string &in,bool throwException) { return toInt32(in,throwException);  }
    template<> inline uint32 fs(const string &in,bool throwException) { return toUInt32(in,throwException);  }
    template<> inline int64  fs(const string &in,bool throwException) { return toInt64(in,throwException);  }
    template<> inline uint64 fs(const string &in,bool throwException) { return toUInt64(in,throwException); }
    template<> inline double fs(const string &in,bool throwException) { return toDouble(in,throwException);  }
    template<> inline bool   fs(const string &in,bool throwException) { return toBool(in,"on,off,true,false,yes,no",throwException);  }
    template<> inline string fs(const string &in,bool) { return {in,true}; }
}
 
// < and == functors for strings - to use in std containers when CI comparisons are wanted!
struct StringCILess {
  public:
    bool operator()(const string &left, const string &right) const {
        return caseInsensitiveCompare(left,right) < 0;
    }
};
struct StringCIEqual {
  public:
    bool operator()(const string &left, const string &right) const {
        return caseInsensitiveCompare(left,right) == 0;
    }
};
struct StringCIHash {
  public:
    uint64 operator()(const string &in) const {
        return caseInsensitiveHash(in);
    }
};
 
//----------------------------------------------------
// Implementations
//----------------------------------------------------
 
// Might want to move this to a dedicated header so not everybody has to include these containers
 
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
 
template <typename T> using StringMap = std::map<string, T, StringCILess>;
 
template <typename T> using StringMultiMap = std::multimap<string, T, StringCILess>;
 
template <typename T> using StringHashMap = std::unordered_map<string, T, StringCIHash, StringCIEqual>;
 
using StringSet = std::set<string, StringCILess>;
 
using StringHashSet = std::unordered_set<string, StringCIHash, StringCIEqual>;
 
template <class T>
inline string base::ts(const T &t, int width, char notation, int precision, char fill) {
    string s = fmt::format(buildFormat(width, notation, precision, fill), t);
    if (width!=0)
        return clipLen(s,std::abs(width));
    return s;
}
 
// OK the fmt;:format library will output -0.0000 instead of 0.0000 if the value was
//   <0 but belwo limits.  This is confusing and breaks former output checks.
// So we need a template override to check for that and get rid of it (sigh)
template <>
inline string base::ts(const double &dIn, int width, char notation, int precision, char fill) {
    double d(dIn);
    if (d==0.0)  // Revove -0
        d = 0.0;
    return fmt::format(buildFormat(width, notation, precision, fill), d);
}
 
template <typename T,typename U>
T join(const std::vector<T> &s,const U &sep) {
    string ret;
    for (StringList::size_type i=0;i<s.size();++i) {
        if (i) ret += sep;
        ret += s[i];
    }
    return ret;
}
 
//----------------------------------------------------
// Implementations
//----------------------------------------------------
 
// EoF