include/library/string.hpp

   1 #ifndef _library__string__hpp__included__
   2 #define _library__string__hpp__included__
   3
   4 #include <functional>
   5 #include <string>
   6 #include <sstream>
   7 #include <set>
   8 #include <list>
   9 #include <stdexcept>
  10 #include <vector>
  11 #include <boost/lexical_cast.hpp>
  12 #include "utf8.hpp"
  13 #include "int24.hpp"
  14
  15 /**
  16  * Strip trailing CR if any.
  17  */
  18 std::string strip_CR(const std::string& str);
  19
  20 /**
  21  * Strip trailing CR if any.
  22  */
  23 void istrip_CR(std::string& str);
  24
  25 /**
  26  * Return first character or -1 if empty.
  27  */
  28 int firstchar(const std::string& str);
  29
  30 /**
  31  * String formatter
  32  */
  33 class stringfmt
  34 {
  35 public:
  36         stringfmt() {}
  37         std::string str() { return x.str(); }
  38         std::u32string str32() { return utf8::to32(x.str()); }
  39         template<typename T> stringfmt& operator<<(const T& y) { x << y; return *this; }
  40         void throwex() { throw std::runtime_error(x.str()); }
  41 private:
  42         std::ostringstream x;
  43 };
  44
  45 /**
  46  * Lambda iterator.
  47  */
  48 template<typename T> class lambda_output_iterator
  49 {
  50 public:
  51         template<typename U> class helper
  52         {
  53         public:
  54                 helper(std::function<void(const U& val)> _fn)
  55                         : fn(_fn)
  56                 {
  57                 }
  58                 helper& operator=(const U& v)
  59                 {
  60                         fn(v);
  61                         return *this;
  62                 }
  63         private:
  64                 std::function<void(const U& val)> fn;
  65         };
  66         typedef std::output_iterator_tag iterator_category;
  67         typedef helper<T> value_type;
  68         typedef int difference_type;
  69         typedef helper<T>& reference;
  70         typedef helper<T>* pointer;
  71 /**
  72  * Constructor.
  73  */
  74         lambda_output_iterator(std::function<void(const T& val)> _fn)
  75                 : h(_fn)
  76         {
  77         }
  78 /**
  79  * Dereference.
  80  */
  81         helper<T>& operator*() throw()
  82         {
  83                 return h;
  84         }
  85 /**
  86  * Increment.
  87  */
  88         lambda_output_iterator<T>& operator++() throw()
  89         {
  90                 return *this;
  91         }
  92 /**
  93  * Increment.
  94  */
  95         lambda_output_iterator<T> operator++(int) throw()
  96         {
  97                 return *this;
  98         }
  99 private:
 100         helper<T> h;
 101 };
 102
 103 /**
 104  * Token iterator.
 105  */
 106 template<typename T> class token_iterator
 107 {
 108 public:
 109         typedef std::forward_iterator_tag iterator_category;
 110         typedef std::basic_string<T> value_type;
 111         typedef int difference_type;
 112         typedef const std::basic_string<T>& reference;
 113         typedef const std::basic_string<T>* pointer;
 114 /**
 115  * Create new end-of-sequence iterator.
 116  */
 117         token_iterator() : str(tmp) { ctor_eos(); }
 118 /**
 119  * Create a new start-of-sequence iterator.
 120  *
 121  * Parameter s: The string to iterate. Must remain valid during lifetime of iterator.
 122  * Parameter sep: The set of separators.
 123  * Parameter whole_sequence: If true, after seeing one separator, throw away separators until none more are found.
 124  */
 125         token_iterator(const std::basic_string<T>& s, std::initializer_list<const T*> sep,
 126                 bool whole_sequence = false) throw(std::bad_alloc) : str(s) { ctor_itr(sep, whole_sequence); }
 127 /**
 128  * Compare.
 129  */
 130         bool operator==(const token_iterator<T>& itr) const throw() { return equals_op(itr); }
 131 /**
 132  * Compare.
 133  */
 134         bool operator!=(const token_iterator<T>& itr) const throw() { return !equals_op(itr); }
 135 /**
 136  * Dereference.
 137  */
 138         const std::basic_string<T>& operator*() const throw() { return dereference(); }
 139 /**
 140  * Increment.
 141  */
 142         token_iterator<T>& operator++() throw(std::bad_alloc) { return preincrement(); }
 143 /**
 144  * Increment.
 145  */
 146         token_iterator<T> operator++(int) throw(std::bad_alloc) { return postincrement(); }
 147 /**
 148  * Do nothing, pull everything.
 149  */
 150         static void pull_fn();
 151 private:
 152 /**
 153  * Foreach helper.
 154  */
 155         template<typename U> class _foreach
 156         {
 157         public:
 158 /**
 159  * Create helper.
 160  */
 161                 _foreach(const std::basic_string<U>& _s,
 162                         std::initializer_list<const U*> sep, bool whole_sequence = false)
 163                         : s(_s, sep, whole_sequence)
 164                 {
 165                 }
 166 /**
 167  * Starting iterator.
 168  */
 169                 token_iterator<U> begin() throw() { return s; }
 170 /**
 171  * Ending iterator.
 172  */
 173                 token_iterator<U> end() throw() { return e; }
 174         private:
 175                 token_iterator<U> s;
 176                 token_iterator<U> e;
 177         };
 178
 179         void ctor_eos();
 180         void ctor_itr(std::initializer_list<const T*> sep, bool whole_sequence = false) throw(std::bad_alloc);
 181         token_iterator<T> postincrement() throw(std::bad_alloc);
 182         token_iterator<T>& preincrement() throw(std::bad_alloc);
 183         const std::basic_string<T>& dereference() const throw();
 184         bool equals_op(const token_iterator<T>& itr) const throw();
 185         size_t is_sep(size_t pos);
 186         void load_helper();
 187         const std::basic_string<T>& str;
 188         size_t bidx;
 189         size_t eidx;
 190         std::basic_string<T> tmp;
 191         std::set<std::basic_string<T>> spliton;
 192         bool is_end_iterator;
 193         bool whole_seq;
 194 public:
 195 /**
 196  * Return an container referencing tokens of string.
 197  */
 198         static _foreach<T> foreach(const std::basic_string<T>& _s,
 199                 std::initializer_list<const T*> sep, bool whole_sequence = false)
 200         {
 201                 return _foreach<T>(_s, sep, whole_sequence);
 202         }
 203 };
 204
 205
 206
 207 class regex_results
 208 {
 209 public:
 210         regex_results();
 211         regex_results(std::vector<std::string> res, std::vector<std::pair<size_t, size_t>> mch);
 212         operator bool() const;
 213         bool operator!() const;
 214         size_t size() const;
 215         const std::string& operator[](size_t i) const;
 216         std::pair<size_t, size_t> match(size_t i) const;
 217 private:
 218         bool matched;
 219         std::vector<std::string> results;
 220         std::vector<std::pair<size_t, size_t>> matches;
 221 };
 222
 223 /**
 224  * Regexp a string and return matches.
 225  *
 226  * Parameter regex: The regexp to apply.
 227  * Parameter str: The string to apply the regexp to.
 228  * Parameter ex: If non-null and string does not match, throw this as std::runtime_error.
 229  * Returns: The captures.
 230  */
 231 regex_results regex(const std::string& regex, const std::string& str, const char* ex = NULL)
 232         throw(std::bad_alloc, std::runtime_error);
 233
 234 enum regex_match_mode
 235 {
 236         REGEX_MATCH_REGEX = 0,
 237         REGEX_MATCH_LITERIAL = 1,
 238         REGEX_MATCH_IWILDCARDS = 2,
 239         REGEX_MATCH_IREGEX = 3,
 240 };
 241
 242 /**
 243  * Regexp a string and return match result.
 244  *
 245  * Parameter regex: The regexp to apply.
 246  * Parameter str: The string to apply the regexp to.
 247  * Parameter mode: Match mode.
 248  * Returns: True if matches, false if not.
 249  */
 250 bool regex_match(const std::string& regex, const std::string& str, enum regex_match_mode mode = REGEX_MATCH_REGEX)
 251         throw(std::bad_alloc, std::runtime_error);
 252
 253 /**
 254  * Try match a case-insensitive string fragment and return the result.
 255  *
 256  * \param pattern The pattern to match a
 257  */
 258
 259 /**
 260  * Cast string to bool.
 261  *
 262  * The following is true: 'on', 'true', 'yes', '1', 'enable', 'enabled'.
 263  * The following is false: 'off', 'false', 'no', '0', 'disable', 'disabled'.
 264  * Parameter str: The string to cast.
 265  * Returns: -1 if string is bad, 0 if false, 1 if true.
 266  */
 267 int string_to_bool(const std::string& cast_to_bool);
 268
 269 template<typename T> T raw_lexical_cast(const std::string& value)
 270 {
 271         return boost::lexical_cast<T>(value);
 272 }
 273
 274 /**
 275  * \brief Typeconvert string.
 276  */
 277 template<typename T> inline T parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
 278 {
 279         //Floating-point case.
 280         try {
 281                 if(std::numeric_limits<T>::is_integer) {
 282                         if(!std::numeric_limits<T>::is_signed && value.length() && value[0] == '-') {
 283                                 throw std::runtime_error("Unsigned values can't be negative");
 284                         }
 285                         size_t idx = 0;
 286                         if(value[idx] == '-' || value[idx] == '+')
 287                                 idx++;
 288                         bool sign = (value[0] == '-');
 289                         T bound = sign ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
 290                         T val = 0;
 291                         if(value.length() > idx + 2 && value[idx] == '0' && value[idx + 1] == 'x') {
 292                                 //Hexadecimal
 293                                 for(size_t i = idx + 2; i < value.length(); i++) {
 294                                         char ch = value[i];
 295                                         T v = 0;
 296                                         if(ch >= '0' && ch <= '9')
 297                                                 v = ch - '0';
 298                                         else if(ch >= 'A' && ch <= 'F')
 299                                                 v = ch - 'A' + 10;
 300                                         else if(ch >= 'a' && ch <= 'f')
 301                                                 v = ch - 'a' + 10;
 302                                         else
 303                                                 throw std::runtime_error("Invalid character in number");
 304                                         if((sign && (bound + v) / 16 > val) || (!sign && (bound - v) / 16 < val))
 305                                                 throw std::runtime_error("Value exceeds range");
 306                                         val = 16 * val + (sign ? -v : v);
 307                                 }
 308                         } else {
 309                                 //Decimal.
 310                                 for(size_t i = idx; i < value.length(); i++) {
 311                                         char ch = value[i];
 312                                         T v = 0;
 313                                         if(ch >= '0' && ch <= '9')
 314                                                 v = ch - '0';
 315                                         else
 316                                                 throw std::runtime_error("Invalid character in number");
 317                                         if((sign && (bound + v) / 10 > val) || (!sign && (bound - v) / 10 < val))
 318                                                 throw std::runtime_error("Value exceeds range");
 319                                         val = 10 * val + (sign ? -v : v);
 320                                 }
 321                         }
 322                         return val;
 323                 }
 324                 return raw_lexical_cast<T>(value);
 325         } catch(std::exception& e) {
 326                 throw std::runtime_error("Can't parse value '" + value + "': " + e.what());
 327         }
 328 }
 329
 330 template<> inline ss_int24_t parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
 331 {
 332         int32_t v = parse_value<int32_t>(value);
 333         if(v < -8388608 || v > 8388607)
 334                 throw std::runtime_error("Can't parse value '" + value + "': Value out of valid range");
 335         return v;
 336 }
 337
 338 template<> inline ss_uint24_t parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
 339 {
 340         uint32_t v = parse_value<uint32_t>(value);
 341         if(v > 0xFFFFFF)
 342                 throw std::runtime_error("Can't parse value '" + value + "': Value out of valid range");
 343         return v;
 344 }
 345
 346 template<> inline std::string parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
 347 {
 348         return value;
 349 }
 350
 351 template<typename T>
 352 class string_list
 353 {
 354 public:
 355         string_list();
 356         string_list(const std::list<std::basic_string<T>>& list);
 357         bool empty();
 358         string_list strip_one() const;
 359         size_t size() const;
 360         const std::basic_string<T>& operator[](size_t idx) const;
 361         bool operator<(const string_list<T>& x) const;
 362         bool operator==(const string_list<T>& x) const;
 363         bool prefix_of(const string_list<T>& x) const;
 364         std::basic_string<T> debug_name() const;
 365 private:
 366         string_list(const std::basic_string<T>* array, size_t arrsize);
 367         std::vector<std::basic_string<T>> v;
 368 };
 369
 370 /**
 371  * Split a string into substrings on some unicode codepoint.
 372  */
 373 string_list<char> split_on_codepoint(const std::string& s, char32_t cp);
 374 /**
 375  * Split a string into substrings on some unicode codepoint.
 376  */
 377 string_list<char32_t> split_on_codepoint(const std::u32string& s, char32_t cp);
 378
 379 #endif