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