Lua: Fix type confusion between signed and unsigned
[lsnes.git] / include / library / string.hpp
blobbb14aaac034ccf34932af61361c9fc54ca1c6471
1 #ifndef _library__string__hpp__included__
2 #define _library__string__hpp__included__
4 #include <string>
5 #include <sstream>
6 #include <set>
7 #include <list>
8 #include <stdexcept>
9 #include <vector>
10 #include <boost/lexical_cast.hpp>
11 #include "utf8.hpp"
12 #include "int24.hpp"
14 /**
15 * Strip trailing CR if any.
17 std::string strip_CR(const std::string& str);
19 /**
20 * Strip trailing CR if any.
22 void istrip_CR(std::string& str);
24 /**
25 * Return first character or -1 if empty.
27 int firstchar(const std::string& str);
29 /**
30 * String formatter
32 class stringfmt
34 public:
35 stringfmt() {}
36 std::string str() { return x.str(); }
37 std::u32string str32() { return utf8::to32(x.str()); }
38 template<typename T> stringfmt& operator<<(const T& y) { x << y; return *this; }
39 void throwex() { throw std::runtime_error(x.str()); }
40 private:
41 std::ostringstream x;
44 /**
45 * Lambda iterator.
47 template<typename T> class lambda_output_iterator
49 public:
50 template<typename U> class helper
52 public:
53 helper(std::function<void(const U& val)> _fn)
54 : fn(_fn)
57 helper& operator=(const U& v)
59 fn(v);
60 return *this;
62 private:
63 std::function<void(const U& val)> fn;
65 typedef std::output_iterator_tag iterator_category;
66 typedef helper<T> value_type;
67 typedef int difference_type;
68 typedef helper<T>& reference;
69 typedef helper<T>* pointer;
70 /**
71 * Constructor.
73 lambda_output_iterator(std::function<void(const T& val)> _fn)
74 : h(_fn)
77 /**
78 * Dereference.
80 helper<T>& operator*() throw()
82 return h;
84 /**
85 * Increment.
87 lambda_output_iterator<T>& operator++() throw()
89 return *this;
91 /**
92 * Increment.
94 lambda_output_iterator<T> operator++(int) throw()
96 return *this;
98 private:
99 helper<T> h;
103 * Token iterator.
105 template<typename T> class token_iterator
107 public:
108 typedef std::forward_iterator_tag iterator_category;
109 typedef std::basic_string<T> value_type;
110 typedef int difference_type;
111 typedef const std::basic_string<T>& reference;
112 typedef const std::basic_string<T>* pointer;
114 * Create new end-of-sequence iterator.
116 token_iterator() : str(tmp) { ctor_eos(); }
118 * Create a new start-of-sequence iterator.
120 * Parameter s: The string to iterate. Must remain valid during lifetime of iterator.
121 * Parameter sep: The set of separators.
122 * Parameter whole_sequence: If true, after seeing one separator, throw away separators until none more are found.
124 token_iterator(const std::basic_string<T>& s, std::initializer_list<const T*> sep,
125 bool whole_sequence = false) throw(std::bad_alloc) : str(s) { ctor_itr(sep, whole_sequence); }
127 * Compare.
129 bool operator==(const token_iterator<T>& itr) const throw() { return equals_op(itr); }
131 * Compare.
133 bool operator!=(const token_iterator<T>& itr) const throw() { return !equals_op(itr); }
135 * Dereference.
137 const std::basic_string<T>& operator*() const throw() { return dereference(); }
139 * Increment.
141 token_iterator<T>& operator++() throw(std::bad_alloc) { return preincrement(); }
143 * Increment.
145 token_iterator<T> operator++(int) throw(std::bad_alloc) { return postincrement(); }
147 * Do nothing, pull everything.
149 static void pull_fn();
150 private:
152 * Foreach helper.
154 template<typename U> class _foreach
156 public:
158 * Create helper.
160 _foreach(const std::basic_string<U>& _s,
161 std::initializer_list<const U*> sep, bool whole_sequence = false)
162 : s(_s, sep, whole_sequence)
166 * Starting iterator.
168 token_iterator<U> begin() throw() { return s; }
170 * Ending iterator.
172 token_iterator<U> end() throw() { return e; }
173 private:
174 token_iterator<U> s;
175 token_iterator<U> e;
178 void ctor_eos();
179 void ctor_itr(std::initializer_list<const T*> sep, bool whole_sequence = false) throw(std::bad_alloc);
180 token_iterator<T> postincrement() throw(std::bad_alloc);
181 token_iterator<T>& preincrement() throw(std::bad_alloc);
182 const std::basic_string<T>& dereference() const throw();
183 bool equals_op(const token_iterator<T>& itr) const throw();
184 size_t is_sep(size_t pos);
185 void load_helper();
186 const std::basic_string<T>& str;
187 size_t bidx;
188 size_t eidx;
189 std::basic_string<T> tmp;
190 std::set<std::basic_string<T>> spliton;
191 bool is_end_iterator;
192 bool whole_seq;
193 public:
195 * Return an container referencing tokens of string.
197 static _foreach<T> foreach(const std::basic_string<T>& _s,
198 std::initializer_list<const T*> sep, bool whole_sequence = false)
200 return _foreach<T>(_s, sep, whole_sequence);
206 class regex_results
208 public:
209 regex_results();
210 regex_results(std::vector<std::string> res, std::vector<std::pair<size_t, size_t>> mch);
211 operator bool() const;
212 bool operator!() const;
213 size_t size() const;
214 const std::string& operator[](size_t i) const;
215 std::pair<size_t, size_t> match(size_t i) const;
216 private:
217 bool matched;
218 std::vector<std::string> results;
219 std::vector<std::pair<size_t, size_t>> matches;
223 * Regexp a string and return matches.
225 * Parameter regex: The regexp to apply.
226 * Parameter str: The string to apply the regexp to.
227 * Parameter ex: If non-null and string does not match, throw this as std::runtime_error.
228 * Returns: The captures.
230 regex_results regex(const std::string& regex, const std::string& str, const char* ex = NULL)
231 throw(std::bad_alloc, std::runtime_error);
233 enum regex_match_mode
235 REGEX_MATCH_REGEX = 0,
236 REGEX_MATCH_LITERIAL = 1,
237 REGEX_MATCH_IWILDCARDS = 2,
238 REGEX_MATCH_IREGEX = 3,
242 * Regexp a string and return match result.
244 * Parameter regex: The regexp to apply.
245 * Parameter str: The string to apply the regexp to.
246 * Parameter mode: Match mode.
247 * Returns: True if matches, false if not.
249 bool regex_match(const std::string& regex, const std::string& str, enum regex_match_mode mode = REGEX_MATCH_REGEX)
250 throw(std::bad_alloc, std::runtime_error);
253 * Try match a case-insensitive string fragment and return the result.
255 * \param pattern The pattern to match a
259 * Cast string to bool.
261 * The following is true: 'on', 'true', 'yes', '1', 'enable', 'enabled'.
262 * The following is false: 'off', 'false', 'no', '0', 'disable', 'disabled'.
263 * Parameter str: The string to cast.
264 * Returns: -1 if string is bad, 0 if false, 1 if true.
266 int string_to_bool(const std::string& cast_to_bool);
269 * \brief Typeconvert string.
271 template<typename T> inline T parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
273 //Floating-point case.
274 try {
275 if(std::numeric_limits<T>::is_integer) {
276 if(!std::numeric_limits<T>::is_signed && value.length() && value[0] == '-') {
277 throw std::runtime_error("Unsigned values can't be negative");
279 size_t idx = 0;
280 if(value[idx] == '-' || value[idx] == '+')
281 idx++;
282 bool sign = (value[0] == '-');
283 T bound = sign ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
284 T val = 0;
285 if(value.length() > idx + 2 && value[idx] == '0' && value[idx + 1] == 'x') {
286 //Hexadecimal
287 for(size_t i = idx + 2; i < value.length(); i++) {
288 char ch = value[i];
289 T v = 0;
290 if(ch >= '0' && ch <= '9')
291 v = ch - '0';
292 else if(ch >= 'A' && ch <= 'F')
293 v = ch - 'A' + 10;
294 else if(ch >= 'a' && ch <= 'f')
295 v = ch - 'a' + 10;
296 else
297 throw std::runtime_error("Invalid character in number");
298 if((sign && (bound + v) / 16 > val) || (!sign && (bound - v) / 16 < val))
299 throw std::runtime_error("Value exceeds range");
300 val = 16 * val + (sign ? -v : v);
302 } else {
303 //Decimal.
304 for(size_t i = idx; i < value.length(); i++) {
305 char ch = value[i];
306 T v = 0;
307 if(ch >= '0' && ch <= '9')
308 v = ch - '0';
309 else
310 throw std::runtime_error("Invalid character in number");
311 if((sign && (bound + v) / 10 > val) || (!sign && (bound - v) / 10 < val))
312 throw std::runtime_error("Value exceeds range");
313 val = 10 * val + (sign ? -v : v);
316 return val;
318 return boost::lexical_cast<T>(value);
319 } catch(std::exception& e) {
320 throw std::runtime_error("Can't parse value '" + value + "': " + e.what());
324 template<> inline ss_int24_t parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
326 int32_t v = parse_value<int32_t>(value);
327 if(v < -8388608 || v > 8388607)
328 throw std::runtime_error("Can't parse value '" + value + "': Value out of valid range");
329 return v;
332 template<> inline ss_uint24_t parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
334 uint32_t v = parse_value<uint32_t>(value);
335 if(v > 0xFFFFFF)
336 throw std::runtime_error("Can't parse value '" + value + "': Value out of valid range");
337 return v;
340 template<> inline std::string parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
342 return value;
345 template<typename T>
346 class string_list
348 public:
349 string_list();
350 string_list(const std::list<std::basic_string<T>>& list);
351 bool empty();
352 string_list strip_one() const;
353 size_t size() const;
354 const std::basic_string<T>& operator[](size_t idx) const;
355 bool operator<(const string_list<T>& x) const;
356 bool operator==(const string_list<T>& x) const;
357 bool prefix_of(const string_list<T>& x) const;
358 std::basic_string<T> debug_name() const;
359 private:
360 string_list(const std::basic_string<T>* array, size_t arrsize);
361 std::vector<std::basic_string<T>> v;
365 * Split a string into substrings on some unicode codepoint.
367 string_list<char> split_on_codepoint(const std::string& s, char32_t cp);
369 * Split a string into substrings on some unicode codepoint.
371 string_list<char32_t> split_on_codepoint(const std::u32string& s, char32_t cp);
373 #endif