basestring.h

Go to the documentation of this file.

#pragma once
// MOO NOTE:  a LOT LOT Of these functions should probably be changed to take a 
//            string_view argument now that string will automatically convert....
//            also standardize on whether we use 
//            caseInsensitiveFUNC() or
//            FUNC(...,bool caseSensitive=false) as a standard.
//            I'm leaning to the latter for conciseness
#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_view = std::string_view;
//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_view &in);
BASE_EXPORT std::tuple<uint32,bool> isUInt32(const string_view &in); 
BASE_EXPORT std::tuple<int64,bool>  isInt64(const string_view &in); 
BASE_EXPORT std::tuple<uint64,bool> isUInt64(const string_view &in); 
BASE_EXPORT std::tuple<double,bool> isDouble(const string_view &in); 
BASE_EXPORT std::tuple<bool,bool>   isBool(const string_view &in,const string_view &out="on,off,true,false,yes,no");
 
// explicit string versions to avoid ambiguity
inline std::tuple<int32,bool>  isInt32(const string &in) { return isInt32(string_view(in)); }
inline std::tuple<uint32,bool> isUInt32(const string &in) { return isUInt32(string_view(in)); }
inline std::tuple<int64,bool>  isInt64(const string &in) { return isInt64(string_view(in)); }
inline std::tuple<uint64,bool> isUInt64(const string &in) { return isUInt64(string_view(in)); }
inline std::tuple<double,bool> isDouble(const string &in) { return isDouble(string_view(in)); }
inline std::tuple<bool,bool>   isBool(const string &in,const string_view &out="on,off,true,false,yes,no") { return isBool(string_view(in),out); }
inline std::tuple<int32,bool>  isInt32v(const string_view &in) { return isInt32(string_view(in)); }
inline std::tuple<uint32,bool> isUInt32v(const string_view &in) { return isUInt32(string_view(in)); }
inline std::tuple<int64,bool>  isInt64v(const string_view &in) { return isInt64(string_view(in)); }
inline std::tuple<uint64,bool> isUInt64v(const string_view &in) { return isUInt64(string_view(in)); }
inline std::tuple<double,bool> isDoublev(const string_view &in) { return isDouble(string_view(in)); }
inline std::tuple<bool,bool>   isBoolv(const string_view &in,const string_view &out="on,off,true,false,yes,no") { return isBool(string_view(in),out); }
 
// 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_view &in,Args...args,bool te, std::tuple<T,bool> (*f)(const string_view &,Args...));
inline int32  toInt32(const string_view &in, bool throwException = false) { return toStringConv<int32>(in, throwException, isInt32v); }
inline uint32 toUInt32(const string_view &in,bool throwException=false) { return toStringConv<uint32>(in, throwException, isUInt32v); }
inline int64  toInt64(const string_view &in,bool throwException=false) { return toStringConv<int64>(in, throwException, isInt64v); }
inline uint64 toUInt64(const string_view &in,bool throwException=false) { return toStringConv<uint64>(in, throwException, isUInt64v); }
inline double toDouble(const string_view &in,bool throwException=false) { return toStringConv<double>(in, throwException, isDoublev); }
inline bool   toBool(const string_view &in, const string_view &out = "on,off,true,false,yes,no", bool throwException = false) { return toStringConv<bool,const string_view &>(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;  }
 
};
BASE_EXPORT std::vector<string> toStringList(const std::vector<string_view> &v);
BASE_EXPORT bool                contains(const std::vector<string> &all, const string &s2,bool caseSensitivity=false);
 
// String utility functions
[[nodiscard]] BASE_EXPORT string                   tostring(const std::wstring &s); // Converts wstring to string
[[nodiscard]] BASE_EXPORT string                   tostring(const std::u16string &s);
[[nodiscard]] BASE_EXPORT string                   tostring(const std::u32string &s);
[[nodiscard]] inline string                        tostring(const string_view &s) { return string(s.data(),s.size()); }
[[nodiscard]] BASE_EXPORT std::wstring             towstring(const string &s);      // Converts string ot wstring
[[nodiscard]] BASE_EXPORT std::wstring             towstring(const std::u16string &s);
[[nodiscard]] BASE_EXPORT std::u16string           tou16string(const string &s); // Converts string to u16string
[[nodiscard]] BASE_EXPORT std::u16string           tou16string(const std::wstring &s); // Converts wstring to u16string
[[nodiscard]] BASE_EXPORT std::u16string           tou16string(const string_view &s); // Converts string to u32string
[[nodiscard]] BASE_EXPORT std::u32string           tou32string(const string &s);      // Converts string to u32string
[[nodiscard]] BASE_EXPORT std::u32string           tou32string(const string_view &s); // Converts string to u32string
[[nodiscard]] BASE_EXPORT string                   toUpper(const string_view &s);        // All upper case
[[nodiscard]] BASE_EXPORT string                   toLower(const string_view &s);        // All lower case
[[nodiscard]] BASE_EXPORT string                   capitalizeFirstLetter(const string_view &s);
template <typename T,typename U> [[nodiscard]] T   join(const std::vector<T> &s,const U &sep);  // Note works on StringList
[[nodiscard]] BASE_EXPORT std::vector<string_view> splitView(const string_view &s, const string_view &sep,bool keepEmptyParts=false); // NOTE case insensitive
[[nodiscard]] inline      std::vector<string>      split(const string_view &s, const string_view &sep,bool keepEmptyParts=false) { return toStringList(splitView(s,sep,keepEmptyParts)); }
[[nodiscard]] BASE_EXPORT std::vector<string_view> splitViewRegex(const string_view &s,const string_view &regex,bool keepEmptyParts=false); // NOTE Case insensitive
[[nodiscard]] inline      std::vector<string>      splitRegex(const string_view &s,const string_view &regex,bool keepEmptyParts=false) { return toStringList(splitViewRegex(s,regex,keepEmptyParts)); }
[[nodiscard]] BASE_EXPORT string_view              matchViewRegex(const string_view &s,const string_view &regex,string::size_type start=0); // NOTE Case insensitive
[[nodiscard]] inline      string                   matchRegex(const string_view &s,const string_view &regex,string::size_type start=0) { return tostring(matchViewRegex(s,regex,start)); }
[[nodiscard]] BASE_EXPORT string                   replaceRegex(const string &s,const string_view &regex,const string &after); // NOTE Case insensitive
[[nodiscard]] BASE_EXPORT string::size_type        find(const string_view &s1,const string_view &s2,string::size_type start=0,bool caseSensitive=false);
[[nodiscard]] BASE_EXPORT string::size_type        findRegex(const string_view &s,const string_view &regex,string::size_type start=0); // NOTE Case insensitive
[[nodiscard]] BASE_EXPORT bool                     exactMatchRegex(const string_view &s,const string_view &regex); // NOTE Case insensitive
[[nodiscard]] BASE_EXPORT string_view              trimmed_view(const string_view &s);    // Removes whitespace on front and back.
[[nodiscard]] inline string                        trimmed(const string_view &s) { return tostring(trimmed_view(s)); }
[[nodiscard]] BASE_EXPORT string                   simplified(const string_view &s); // As trimmed, but also reduces whitespace sequences inside to one space.
[[nodiscard]] BASE_EXPORT string                   replace(string s, const string_view &sub,const string_view &newsub,bool caseSensitive=false);  // Replace all instances of sub wiwth newsub in s
[[nodiscard]] BASE_EXPORT string                   toBase64(const std::vector<char> &in);
[[nodiscard]] BASE_EXPORT std::vector<char>        fromBase64(const string &in);
[[nodiscard]] BASE_EXPORT bool                     startsWith(const string_view &in,const string_view &check,bool caseSensitive = false);
[[nodiscard]] BASE_EXPORT bool                     endsWith(const string_view &in, const string_view &check,bool caseSensitive = false);
[[nodiscard]] BASE_EXPORT bool                     contains(const string_view &in,const string_view &check,bool caseSensitive = false);
[[nodiscard]] BASE_EXPORT string                   clipLen(string in,string::size_type length);
[[nodiscard]] BASE_EXPORT string                   cleanupTypename(const char *name);
[[nodiscard]] BASE_EXPORT string                   convertPercentToBracket(const string_view &s);
[[nodiscard]] BASE_EXPORT string                   remove(string s,char c);
[[nodiscard]] inline      string                   remove(string s,const string_view &sub,bool caseSensitive=false) { return replace(s,sub,{},caseSensitive); }
[[nodiscard]] BASE_EXPORT int32                    compare(const string_view &s1, const string_view &s2,bool caseSensitive=false);
[[nodiscard]] BASE_EXPORT uint64                   caseInsensitiveHash(const string_view &s);
[[nodiscard]] BASE_EXPORT uint64                   firstNonBlankCharacter(const string_view &s);
[[nodiscard]] BASE_EXPORT bool                     wildcardMatch(const string_view &patter,const string_view &test);
[[nodiscard]] BASE_EXPORT string                   formatBytes(uint64 bytes,uint32 precision=3);
 
// 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
//inline int32 caseInsensitiveCompare(const string &s1, const char *str) { return caseInsensitiveCompare(s1,string_view(str)); }
BASE_EXPORT bool checkLeft(const string_view &s,const string_view &c); // Checks if c matches start of s (case insensitive)
inline bool equal(const string_view &s,const string_view &c,bool caseSensitive=false) { return compare(s,c,caseSensitive)==0; } // Handy shorthand
 
//*
//*    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 compare(left,right) < 0; }
};
struct StringCIEqual {
  public:
    bool operator()(const string &left, const string &right) const { return compare(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 below 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
//----------------------------------------------------
 
template <typename T,typename ... Args>
T toStringConv(const string_view &in,Args...args,bool te, std::tuple<T,bool> (*f)(const string_view &,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;
}
// EoF