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 <format>
#include <string>
#include <vector>
#include <string_view>
#ifdef _WIN32
#include <codeanalysis\warnings.h>
#endif
 
// 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); }
template <typename ... Args>
string rformat(const string &s,Args...args) { return std::vformat(s,std::make_format_args(args...)); }
 
 
// 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]] inline string                        tostring(const char *s) { return string(s); }
[[nodiscard]] inline string                        tostring(const string & s) { return s; } // For template support
[[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                   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);
[[nodiscard]] BASE_EXPORT string_view              substr(const string_view &s,string::size_type pos,string::size_type count=string::npos); // Same as s.substr() except returns empty string if pos > size()
 
// 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()); }
    string_view toStringView() const { return string_view(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,bool forceAbbreviationsAllowed=false);
BASE_EXPORT uint32 match(const StringList &keywords,const string &token,bool forceAbbreviationsAllowed=false); // 0 if no match, base 1 if match (ugh)
BASE_EXPORT void matchSynonymsAllowed(bool b);
BASE_EXPORT bool matchSynonymsAllowed();
// Getkeyword pull the FIRST full alias keyword from the keyword list at the given index, or def if it doesn't exist
BASE_EXPORT string getKeyword(const StringList &keywords,const uint64 index,const string &def={});
inline string getKeyword(const string &keywords,const uint64 index,const string &def={}) { return getKeyword(split(keywords,","),index,def); }
 
// Create a std::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 std::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_view &) { static_assert(sizeof(T{})==0); return {T{},false}; }
    template<> inline std::tuple<int32, bool>  fsTest(const string_view &in) { return isInt32v(in);  }
    template<> inline std::tuple<uint32, bool> fsTest(const string_view &in) { return isUInt32v(in);  }
    template<> inline std::tuple<int64, bool>  fsTest(const string_view &in) { return isInt64v(in);  }
    template<> inline std::tuple<uint64, bool> fsTest(const string_view &in) { return isUInt64v(in); }
    template<> inline std::tuple<double, bool> fsTest(const string_view &in) { return isDoublev(in);  }
    template<> inline std::tuple<bool, bool>   fsTest(const string_view &in) { return isBoolv(in);  }
    template<> inline std::tuple<string, bool> fsTest(const string_view &in) { return {string(in),true}; }
 
    template <typename T> T fs(const string_view &, [[maybe_unused]] bool throwException = false) { static_assert(sizeof(T{})==0); return T{}; }
    template<> inline int32  fs(const string_view &in,bool throwException) { return toInt32(in,throwException);  }
    template<> inline uint32 fs(const string_view &in,bool throwException) { return toUInt32(in,throwException);  }
    template<> inline int64  fs(const string_view &in,bool throwException) { return toInt64(in,throwException);  }
    template<> inline uint64 fs(const string_view &in,bool throwException) { return toUInt64(in,throwException); }
    template<> inline double fs(const string_view &in,bool throwException) { return toDouble(in,throwException);  }
    template<> inline bool   fs(const string_view &in,bool throwException) { return toBool(in,"on,off,true,false,yes,no",throwException);  }
    template<> inline string fs(const string_view &in,bool) { return {string(in),true}; }
}
 
// < and == functors for strings - to use in std containers when CI comparisons are wanted!
struct StringCILess {
  public:
    bool operator()(const string_view &left, const string_view &right) const { return compare(left,right) < 0; }
};
struct StringCIEqual {
  public:
    bool operator()(const string_view &left, const string_view &right) const { return compare(left,right) == 0; }
};
struct StringCIHash {
  public:
    uint64 operator()(const string_view &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 = rformat(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)  // Resolve -0
        d = 0.0;
    return rformat(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;
}
 
template <class ... Args>
struct FormatCheck : public std::format_string<std::type_identity_t<Args>...> {
    template <unsigned N>
    consteval FormatCheck(const char (&s)[N]) : std::format_string<std::type_identity_t<Args>...>(s) { 
        for (auto i=&(s[0]);i!=&(s[N]);++i) {
            if (*i=='\\') { // Check for \ escape
                ++i;
                if (i==&(s[N])) break;
            } else if (*i=='%') { // Check for %
                ++i;
                if (i==&(s[N]))
                    break;
                if (*i >= '1' and *i <= '9')
                    assert(0 && "%1, %2 etc. token replacement is no longer supported.  Use std::format {} syntax.");
            } 
        }
    }
};
 
// This allows you to send StringLists to a std::format
template <>
struct std::formatter<StringList> : public std::formatter<string> {
    template <typename ParseContext>
    constexpr auto parse(ParseContext &ctx) { return std::formatter<string>::parse(ctx); }
 
    template <typename FormatContext>
    constexpr auto format(StringList const &val, FormatContext &ctx) const {
        return std::formatter<string>::format(join(val,","), ctx);
    }
};
 
// EoF