From caae1e38d0d239f4f7088a64526fe1d2f6587999 Mon Sep 17 00:00:00 2001 From: Ben Longbons Date: Thu, 26 Sep 2013 23:55:29 -0700 Subject: Split string header into pieces --- src/common/core.cpp | 4 +- src/common/core.hpp | 2 +- src/common/dumb_ptr.hpp | 7 +- src/common/extract.cpp | 4 + src/common/extract.hpp | 2 + src/common/extract_test.cpp | 2 + src/common/human_time_diff.hpp | 3 +- src/common/intern-pool.hpp | 4 +- src/common/intern-pool_test.cpp | 2 + src/common/io.hpp | 2 +- src/common/ip.cpp | 3 + src/common/ip.hpp | 3 +- src/common/lock.cpp | 3 + src/common/lock.hpp | 2 +- src/common/md5calc.cpp | 3 + src/common/md5calc.hpp | 4 +- src/common/md5calc_test.cpp | 3 + src/common/mmo.hpp | 5 +- src/common/socket.hpp | 4 + src/common/strings.hpp | 1092 --------------------------------------- src/common/strings2_test.cpp | 118 ----- src/common/strings_test.cpp | 276 ---------- src/common/timer.cpp | 2 + src/common/timer.hpp | 2 +- src/common/utils.cpp | 8 +- src/common/utils.hpp | 4 +- 26 files changed, 64 insertions(+), 1500 deletions(-) delete mode 100644 src/common/strings.hpp delete mode 100644 src/common/strings2_test.cpp delete mode 100644 src/common/strings_test.cpp (limited to 'src/common') diff --git a/src/common/core.cpp b/src/common/core.cpp index 76aa09c..727babd 100644 --- a/src/common/core.cpp +++ b/src/common/core.cpp @@ -8,6 +8,8 @@ #include #include +#include "../strings/zstring.hpp" + #include "random.hpp" #include "socket.hpp" #include "timer.hpp" @@ -79,7 +81,7 @@ int main(int argc, char **argv) // ZString args[argc]; is (deliberately!) not supported by clang yet ZString *args = static_cast(alloca(argc * sizeof(ZString))); for (int i = 0; i < argc; ++i) - args[i] = ZString(ZString::really_construct_from_a_pointer, argv[i], nullptr); + args[i] = ZString(strings::really_construct_from_a_pointer, argv[i], nullptr); do_init(argc, args); // set up exit handlers *after* the initialization has happened. // This is because term_func is likely to depend on successful init. diff --git a/src/common/core.hpp b/src/common/core.hpp index f1473ed..1cbd0c2 100644 --- a/src/common/core.hpp +++ b/src/common/core.hpp @@ -3,7 +3,7 @@ #include "sanity.hpp" -#include "strings.hpp" +#include "../strings/fwd.hpp" /// core.c contains a server-independent main() function /// and then runs a do_sendrecv loop diff --git a/src/common/dumb_ptr.hpp b/src/common/dumb_ptr.hpp index fe5031a..bcc9dda 100644 --- a/src/common/dumb_ptr.hpp +++ b/src/common/dumb_ptr.hpp @@ -25,8 +25,11 @@ #include +#include "../strings/fstring.hpp" +#include "../strings/zstring.hpp" +#include "../strings/xstring.hpp" + #include "const_array.hpp" -#include "strings.hpp" // unmanaged new/delete-able pointer // should be replaced by std::unique_ptr @@ -240,7 +243,7 @@ struct dumb_string operator ZString() const { - return ZString(ZString::really_construct_from_a_pointer, c_str(), nullptr); + return ZString(strings::really_construct_from_a_pointer, c_str(), nullptr); } FString str() const diff --git a/src/common/extract.cpp b/src/common/extract.cpp index 720e6df..bac7b38 100644 --- a/src/common/extract.cpp +++ b/src/common/extract.cpp @@ -18,6 +18,10 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +#include "../strings/fstring.hpp" +#include "../strings/xstring.hpp" +#include "../strings/vstring.hpp" + #include "../poison.hpp" bool extract(XString str, XString *rv) diff --git a/src/common/extract.hpp b/src/common/extract.hpp index c7bdbcb..dd0a8a3 100644 --- a/src/common/extract.hpp +++ b/src/common/extract.hpp @@ -23,6 +23,8 @@ #include +#include "../strings/xstring.hpp" + #include "const_array.hpp" #include "mmo.hpp" #include "utils.hpp" diff --git a/src/common/extract_test.cpp b/src/common/extract_test.cpp index 78478c2..3d0610e 100644 --- a/src/common/extract_test.cpp +++ b/src/common/extract_test.cpp @@ -2,6 +2,8 @@ #include +#include "../strings/xstring.hpp" + TEST(extract, record_int) { int x, y, z; diff --git a/src/common/human_time_diff.hpp b/src/common/human_time_diff.hpp index 3fc0f09..a937316 100644 --- a/src/common/human_time_diff.hpp +++ b/src/common/human_time_diff.hpp @@ -21,8 +21,9 @@ #include "sanity.hpp" +#include "../strings/xstring.hpp" + #include "extract.hpp" -#include "strings.hpp" struct HumanTimeDiff { diff --git a/src/common/intern-pool.hpp b/src/common/intern-pool.hpp index db840a2..204b659 100644 --- a/src/common/intern-pool.hpp +++ b/src/common/intern-pool.hpp @@ -6,7 +6,9 @@ #include #include -#include "strings.hpp" +#include "../strings/fstring.hpp" +#include "../strings/zstring.hpp" +#include "../strings/xstring.hpp" class InternPool { diff --git a/src/common/intern-pool_test.cpp b/src/common/intern-pool_test.cpp index 3bbca7b..bf17b67 100644 --- a/src/common/intern-pool_test.cpp +++ b/src/common/intern-pool_test.cpp @@ -2,6 +2,8 @@ #include +#include "../strings/base.hpp" + TEST(InternPool, whydoesthisalwaysneedasecondname) { InternPool p; diff --git a/src/common/io.hpp b/src/common/io.hpp index 1831651..27bf4e2 100644 --- a/src/common/io.hpp +++ b/src/common/io.hpp @@ -4,7 +4,7 @@ #include #include -#include "strings.hpp" +#include "../strings/fstring.hpp" namespace io { diff --git a/src/common/ip.cpp b/src/common/ip.cpp index 4734a8b..a1fdfda 100644 --- a/src/common/ip.cpp +++ b/src/common/ip.cpp @@ -18,6 +18,9 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +#include "../strings/xstring.hpp" +#include "../strings/vstring.hpp" + #include "cxxstdio.hpp" #include "../poison.hpp" diff --git a/src/common/ip.hpp b/src/common/ip.hpp index aceb765..cce6c2b 100644 --- a/src/common/ip.hpp +++ b/src/common/ip.hpp @@ -23,8 +23,9 @@ #include +#include "../strings/fwd.hpp" + #include "extract.hpp" -#include "strings.hpp" // TODO - in the long run ports belong here also // and of course, IPv6 stuff. diff --git a/src/common/lock.cpp b/src/common/lock.cpp index f19cd92..e21aee5 100644 --- a/src/common/lock.cpp +++ b/src/common/lock.cpp @@ -4,6 +4,9 @@ #include +#include "../strings/fstring.hpp" +#include "../strings/zstring.hpp" + #include "cxxstdio.hpp" #include "socket.hpp" diff --git a/src/common/lock.hpp b/src/common/lock.hpp index df4d1f8..5ca1aed 100644 --- a/src/common/lock.hpp +++ b/src/common/lock.hpp @@ -5,7 +5,7 @@ #include -#include "strings.hpp" +#include "../strings/fwd.hpp" // TODO replace with a class diff --git a/src/common/md5calc.cpp b/src/common/md5calc.cpp index 1c48a24..1961fa6 100644 --- a/src/common/md5calc.cpp +++ b/src/common/md5calc.cpp @@ -2,6 +2,9 @@ #include +#include "../strings/xstring.hpp" +#include "../strings/vstring.hpp" + #include "cxxstdio.hpp" #include "random.hpp" #include "utils.hpp" diff --git a/src/common/md5calc.hpp b/src/common/md5calc.hpp index 70a996e..e44a7a7 100644 --- a/src/common/md5calc.hpp +++ b/src/common/md5calc.hpp @@ -11,9 +11,11 @@ #include +#include "../strings/fwd.hpp" +#include "../strings/vstring.hpp" + #include "ip.hpp" #include "mmo.hpp" -#include "strings.hpp" /// The digest state - becomes the output struct MD5_state diff --git a/src/common/md5calc_test.cpp b/src/common/md5calc_test.cpp index 51b0b68..ab5f242 100644 --- a/src/common/md5calc_test.cpp +++ b/src/common/md5calc_test.cpp @@ -2,6 +2,9 @@ #include +#include "../strings/xstring.hpp" +#include "../strings/vstring.hpp" + #include "utils.hpp" // This should be made part of the main API, diff --git a/src/common/mmo.hpp b/src/common/mmo.hpp index 0d3403c..16acb88 100644 --- a/src/common/mmo.hpp +++ b/src/common/mmo.hpp @@ -3,6 +3,9 @@ #define MMO_HPP # include "sanity.hpp" + +# include "../strings/vstring.hpp" + # include "timer.t.hpp" # include "utils2.hpp" @@ -57,7 +60,7 @@ T stringish(VString iv) #define DEFAULT_EMAIL stringish("a@a.com") // It is decreed: a mapname shall not contain an extension -class MapName : public strings::_crtp_string +class MapName : public strings::_crtp_string { VString<15> _impl; public: diff --git a/src/common/socket.hpp b/src/common/socket.hpp index 91a8c49..1ff400a 100644 --- a/src/common/socket.hpp +++ b/src/common/socket.hpp @@ -9,6 +9,10 @@ # include +# include "../strings/fstring.hpp" +# include "../strings/vstring.hpp" +# include "../strings/xstring.hpp" + # include "dumb_ptr.hpp" # include "ip.hpp" # include "utils.hpp" diff --git a/src/common/strings.hpp b/src/common/strings.hpp deleted file mode 100644 index 0b10570..0000000 --- a/src/common/strings.hpp +++ /dev/null @@ -1,1092 +0,0 @@ -#ifndef TMWA_COMMON_STRINGS_HPP -#define TMWA_COMMON_STRINGS_HPP -// strings.hpp - All the string classes you'll ever need. -// -// Copyright © 2013 Ben Longbons -// -// This file is part of The Mana World (Athena server) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program. If not, see . - -#include "sanity.hpp" - -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#include "utils2.hpp" - -// It is a common mistake to assume that one string class for everything. -// Because C++ and TMWA have a C legacy, there are a few more here -// than would probably be necessary in an ideal language. -namespace strings -{ - // owning - class MString; - class FString; - class TString; // C legacy version of SString - class SString; // is this one really worth it? - - // non-owning - class ZString; // C legacy version of XString - class XString; - - // semi-owning - template - class VString; - - // simple pointer-wrapping iterator that can be used to get distinct - // types for different containers. - template - class _iterator - { - typedef _iterator X; - - const char *_ptr; - public: - typedef ptrdiff_t difference_type; - typedef char value_type; - typedef const char *pointer; - typedef const char& reference; - typedef std::random_access_iterator_tag iterator_category; - - _iterator(const char *p=nullptr) : _ptr(p) {} - - // iterator - reference operator *() const { return *_ptr; } - X& operator ++() { ++_ptr; return *this; } - // equality comparable - friend bool operator == (X l, X r) { return l._ptr == r._ptr; } - // input iterator - friend bool operator != (X l, X r) { return !(l == r); } - pointer operator->() const { return _ptr; } - X operator++ (int) { X out = *this; ++*this; return out; } - // forward iterator is mostly semantical, and the ctor is above - // bidirectional iterator - X& operator --() { --_ptr; return *this; } - X operator-- (int) { X out = *this; --*this; return out; } - // random access iterator - X& operator += (difference_type n) { _ptr += n; return *this; } - friend X operator + (X a, difference_type n) { return a += n; } - friend X operator + (difference_type n, X a) { return a += n; } - X& operator -= (difference_type n) { _ptr -= n; return *this; } - friend X operator - (X a, difference_type n) { return a -= n; } - friend difference_type operator - (X b, X a) { return b._ptr - a._ptr; } - reference operator[](difference_type n) const { return _ptr[n]; } - friend bool operator < (X a, X b) { return a._ptr < b._ptr; } - friend bool operator > (X a, X b) { return b < a; } - friend bool operator >= (X a, X b) { return !(a < b); } - friend bool operator <= (X a, X b) { return !(a > b); } - }; - - /// A helper class that implements all the interesting stuff that can - /// be done on any constant string, in terms of .begin() and .end(). - template - class _crtp_string - { - public: - // this will have to be changed if MString decides to join in. - typedef _iterator iterator; - typedef std::reverse_iterator reverse_iterator; - private: - const T& _ref() const { return static_cast(*this); } - iterator begin() const { return _ref().begin(); } - iterator end() const { return _ref().end(); } - const FString *base() const { return _ref().base(); } - public: - size_t size() const { return end() - begin(); } - reverse_iterator rbegin() const { return reverse_iterator(end()); } - reverse_iterator rend() const { return reverse_iterator(begin()); } - explicit - operator bool() const { return size(); } - bool operator !() const { return !size(); } - - // the existence of this has led to bugs - // it's not really sane from a unicode perspective anyway ... - // prefer startswith or extract - __attribute__((deprecated)) - char operator[](size_t i) const { return begin()[i]; } - char front() const { return *begin(); } - char back() const { return end()[-1]; } - const char *data() { return &*begin(); } - - Z xslice_t(size_t o) const; - X xslice_h(size_t o) const; - Z xrslice_t(size_t no) const; - X xrslice_h(size_t no) const; - Z xislice_t(iterator it) const; - X xislice_h(iterator it) const; - X xlslice(size_t o, size_t l) const; - X xpslice(size_t b, size_t e) const; - X xislice(iterator b, iterator e) const; - Z lstrip() const; - X rstrip() const; - X strip() const; - - bool startswith(XString x) const; - bool endswith(XString x) const; - bool startswith(char c) const; - bool endswith(char c) const; - - bool contains(char c) const; - bool contains_seq(XString s) const; - bool contains_any(XString s) const; - - bool has_print() const; - bool is_print() const; - __attribute__((deprecated)) - O to_print() const; - - bool is_graph() const; - bool has_graph() const; - - bool has_lower() const; - bool is_lower() const; - O to_lower() const; - - bool has_upper() const; - bool is_upper() const; - O to_upper() const; - - bool has_alpha() const; // equivalent to has_lower || has_upper - bool is_alpha() const; // NOT equivalent to is_lower || is_upper - - bool has_digit2() const; - bool is_digit2() const; - bool has_digit8() const; - bool is_digit8() const; - bool has_digit10() const; - bool is_digit10() const; - bool has_digit16() const; - bool is_digit16() const; - - bool has_alnum() const; // equivalent to has_alpha || has_digit10 - bool is_alnum() const; // NOT equivalent to is_alpha || is_digit10 - }; - - - /// An owning string that is still expected to change. - /// The storage might not be contiguous, but it still offers - /// random-access iterators. - /// TODO implement a special one, to avoid quirks of std::string. - class MString - { - public: - typedef std::deque::iterator iterator; - typedef std::deque::const_iterator const_iterator; - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; - private: - std::deque _hack; - public: - iterator begin() { return _hack.begin(); } - iterator end() { return _hack.end(); } - const_iterator begin() const { return _hack.begin(); } - const_iterator end() const { return _hack.end(); } - reverse_iterator rbegin() { return reverse_iterator(end()); } - reverse_iterator rend() { return reverse_iterator(begin()); } - const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } - const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } - - size_t size() const { return _hack.size(); } - explicit - operator bool() const { return size(); } - bool operator !() const { return !size(); } - - MString& operator += (MString rhs) - { - _hack.insert(_hack.end(), rhs.begin(), rhs.end()); - return *this; - } - MString& operator += (char c) - { - _hack.push_back(c); - return *this; - } - MString& operator += (XString xs); - - void pop_back(size_t n=1) - { - while (n--) - _hack.pop_back(); - } - char& front() - { - return _hack.front(); - } - char& back() - { - return _hack.back(); - } - }; - - /// An owning string that has reached its final contents. - /// The storage is NUL-terminated - /// TODO implement a special one, that guarantees refcounting. - class FString : public _crtp_string - { - std::shared_ptr> _hack2; - - template - void _assign(It b, It e) - { - if (b == e) - { - // TODO use a special empty object - // return; - } - if (!std::is_base_of::iterator_category>::value) - { - // can't use std::distance - _hack2 = std::make_shared>(); - for (; b != e; ++b) - _hack2->push_back(*b); - _hack2->push_back('\0'); - _hack2->shrink_to_fit(); - } - size_t diff = std::distance(b, e); - _hack2 = std::make_shared>(diff + 1, '\0'); - std::copy(b, e, _hack2->begin()); - } - public: - FString() - { - const char *sadness = ""; - _assign(sadness, sadness); - } - - explicit FString(const MString& s) - { - _assign(s.begin(), s.end()); - } - - template - FString(char (&s)[n]) = delete; - - template - FString(const char (&s)[n]) - { - _assign(s, s + strlen(s)); - } - - template - FString(It b, It e) - { - _assign(b, e); - } - - - iterator begin() const { return &_hack2->begin()[0]; } - iterator end() const { return &_hack2->end()[-1]; } - const FString *base() const { return this; } - const char *c_str() const { return &*begin(); } - - TString oslice_t(size_t o) const; - SString oslice_h(size_t o) const; - TString orslice_t(size_t no) const; - SString orslice_h(size_t no) const; - TString oislice_t(iterator it) const; - SString oislice_h(iterator it) const; - SString olslice(size_t o, size_t l) const; - SString opslice(size_t b, size_t e) const; - SString oislice(iterator b, iterator e) const; - }; - - /// An owning string that represents a tail slice of an FString. - /// Guaranteed to be NUL-terminated. - class TString : public _crtp_string - { - friend class SString; - FString _s; - size_t _o; - public: - TString() : _s(), _o() {} - TString(FString b, size_t i=0) : _s(std::move(b)), _o(i) {} - template - TString(char (&s)[n]) = delete; - template - TString(const char (&s)[n]) : _s(s), _o(0) {} - //template - //TString(It b, It e) : _s(b, e), _o(0) {} - - iterator begin() const { return &_s.begin()[_o]; } - iterator end() const { return &*_s.end(); } - const FString *base() const { return &_s; } - const char *c_str() const { return &*begin(); } - - TString oslice_t(size_t o) const; - SString oslice_h(size_t o) const; - TString orslice_t(size_t no) const; - SString orslice_h(size_t no) const; - TString oislice_t(iterator it) const; - SString oislice_h(iterator it) const; - SString olslice(size_t o, size_t l) const; - SString opslice(size_t b, size_t e) const; - SString oislice(iterator b, iterator e) const; - - operator FString() const - { if (_o) return FString(begin(), end()); else return _s; } - }; - - /// An owning string that represents a arbitrary slice of an FString. - /// Not guaranteed to be NUL-terminated. - class SString : public _crtp_string - { - FString _s; - size_t _b, _e; - public: - SString() : _s(), _b(), _e() {} - SString(FString f) : _s(std::move(f)), _b(), _e(_s.size()) {} - SString(TString t) : _s(t._s), _b(0), _e(_s.size()) {} - template - SString(char (&s)[n]) = delete; - template - SString(const char (&s)[n]) : _s(s), _b(0), _e(_s.size()) {} - //template - //SString(It b, It e) : _s(b, e), _b(0), _e(_s.size()) {} - SString(FString f, size_t b, size_t e) : _s(std::move(f)), _b(b), _e(e) {} - - iterator begin() const { return &_s.begin()[_b]; } - iterator end() const { return &_s.begin()[_e]; } - const FString *base() const { return &_s; } - - SString oslice_t(size_t o) const; - SString oslice_h(size_t o) const; - SString orslice_t(size_t no) const; - SString orslice_h(size_t no) const; - SString oislice_t(iterator it) const; - SString oislice_h(iterator it) const; - SString olslice(size_t o, size_t l) const; - SString opslice(size_t b, size_t e) const; - SString oislice(iterator b, iterator e) const; - - operator FString() const - { if (_b == 0 && _e == _s.size()) return _s; else return FString(begin(), end()); } - operator TString() const - { if (_e == _s.size()) return TString(_s, _b); else return FString(begin(), end()); } - }; - - /// A non-owning string that is guaranteed to be NUL-terminated. - /// This should be only used as a parameter. - class ZString : public _crtp_string - { - iterator _b, _e; - // optional - const FString *_base; - public: - enum { really_construct_from_a_pointer }; - ZString() { *this = ZString(""); } - // no MString - ZString(const FString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {} - ZString(const TString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {} - ZString(const SString&) = delete; - // dangerous - ZString(const char *b, const char *e, const FString *base_) : _b(b), _e(e), _base(base_) {} - ZString(decltype(really_construct_from_a_pointer), const char *s, const FString *base_) : _b(s), _e(s + strlen(s)), _base(base_) {} - template - ZString(char (&s)[n]) = delete; - template - ZString(const char (&s)[n], const FString *base_=nullptr) : _b(s), _e(s + strlen(s)), _base(base_) {} - - iterator begin() const { return _b; } - iterator end() const { return _e; } - const FString *base() const { return _base; } - const char *c_str() const { return &*begin(); } - - ZString oslice_t(size_t o) const; - XString oslice_h(size_t o) const; - ZString orslice_t(size_t no) const; - XString orslice_h(size_t no) const; - ZString oislice_t(iterator it) const; - XString oislice_h(iterator it) const; - XString olslice(size_t o, size_t l) const; - XString opslice(size_t b, size_t e) const; - XString oislice(iterator b, iterator e) const; - - operator FString() const - { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); } - operator TString() const - { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); } - operator SString() const - { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); } - }; - - /// A non-owning string that is not guaranteed to be NUL-terminated. - /// This should be only used as a parameter. - class XString : public _crtp_string - { - iterator _b, _e; - // optional - const FString *_base; - public: - // do I really want this? - XString() : _b(""), _e(_b), _base() {} - XString(std::nullptr_t) = delete; - // no MString - XString(const FString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {} - XString(const TString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {} - XString(const SString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {} - XString(const ZString& s) : _b(&*s.begin()), _e(&*s.end()), _base(s.base()) {} - template - XString(char (&s)[n]) = delete; - template - XString(const char (&s)[n]) : _b(s), _e(s + strlen(s)), _base(nullptr) {} - // mostly internal - XString(const char *b, const char *e, const FString *base_) : _b(b), _e(e), _base(base_) {} - XString(decltype(ZString::really_construct_from_a_pointer) e, const char *s, const FString *base_) - { - *this = ZString(e, s, base_); - } - - iterator begin() const { return _b; } - iterator end() const { return _e; } - const FString *base() const { return _base; } - - XString oslice_t(size_t o) const { return xslice_t(o); } - XString oslice_h(size_t o) const { return xslice_h(o); } - XString orslice_t(size_t no) const { return xrslice_t(no); } - XString orslice_h(size_t no) const { return xrslice_h(no); } - XString oislice_t(iterator it) const { return xislice_t(it); } - XString oislice_h(iterator it) const { return xislice_h(it); } - XString olslice(size_t o, size_t l) const { return xlslice(o, l); } - XString opslice(size_t b, size_t e) const { return xpslice(b, e); } - XString oislice(iterator b, iterator e) const { return xislice(b, e); } - - operator FString() const - { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); } - operator TString() const - { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); } - operator SString() const - { if (_base) return SString(*_base, &*_b - &*_base->begin(), &*_e - &*_base->begin()); else return FString(_b, _e); } - operator ZString() const = delete; - }; - - template - class VString : public _crtp_string, VString, ZString, XString> - { - char _data[n]; - unsigned char _special; - public: - typedef typename _crtp_string, VString, ZString, XString>::iterator iterator; - VString(XString x) : _data(), _special() - { - if (x.size() > n) - // we're hoping this doesn't happen - // hopefully there will be few enough users of this class - x = x.xslice_h(n); - char *e = std::copy(x.begin(), x.end(), std::begin(_data)); - _special = std::end(_data) - e; - assert (_special == n - x.size()); // 0 when it needs to be - } - // poor man's delegated constructors - // needed for gcc 4.6 compatibility - VString(FString f) - { - *this = XString(f); - } - VString(TString t) - { - *this = XString(t); - } - VString(SString s) - { - *this = XString(s); - } - VString(ZString z) - { - *this = XString(z); - } - template - VString(char (&s)[m]) = delete; - template - VString(const char (&s)[m]) - { - static_assert(m <= n + 1, "string would truncate"); - *this = XString(s); - } - VString(decltype(ZString::really_construct_from_a_pointer) e, const char *s) - { - *this = XString(e, s, nullptr); - } - VString(char c) - { - *this = XString(&c, &c + 1, nullptr); - } - VString() - { - *this = XString(); - } - - // hopefully this is obvious - iterator begin() const { return std::begin(_data); } - iterator end() const { return std::end(_data) - _special; } - const FString *base() const { return nullptr; } - const char *c_str() const { return &*begin(); } - - VString oslice_t(size_t o) const { return this->xslice_t(o); } - VString oslice_h(size_t o) const { return this->xslice_h(o); } - VString orslice_t(size_t no) const { return this->xrslice_t(no); } - VString orslice_h(size_t no) const { return this->xrslice_h(no); } - VString oislice_t(iterator it) const { return this->xislice_t(it); } - VString oislice_h(iterator it) const { return this->xislice_h(it); } - VString olslice(size_t o, size_t l) const { return this->xlslice(o, l); } - VString opslice(size_t b, size_t e) const { return this->xpslice(b, e); } - VString oislice(iterator b, iterator e) const { return this->xislice(b, e); } - - operator FString() const { return FString(begin(), end()); } - operator TString() const { return FString(begin(), end()); } - operator SString() const { return FString(begin(), end()); } - operator ZString() const { return ZString(_data); } - operator XString() const { return XString(&*begin(), &*end(), nullptr); } - - template - operator VString() const - { - static_assert(m > n, "can only grow"); - XString x = *this; - return VString(XString(x)); - } - }; - - // not really intended for public use - inline - int xstr_compare(XString l, XString r) - { - bool less = std::lexicographical_compare( - l.begin(), l.end(), - r.begin(), r.end()); - bool greater = std::lexicographical_compare( - r.begin(), r.end(), - l.begin(), l.end()); - return greater - less; - } - - - template - class string_comparison_allowed - { - constexpr static bool l_is_vstring_exact = std::is_same, L>::value; - constexpr static bool l_is_vstring_approx = std::is_base_of, L>::value; - constexpr static bool r_is_vstring_exact = std::is_same, R>::value; - constexpr static bool r_is_vstring_approx = std::is_base_of, R>::value; - - constexpr static bool l_is_restricted = l_is_vstring_approx && !l_is_vstring_exact; - constexpr static bool r_is_restricted = r_is_vstring_approx && !r_is_vstring_exact; - public: - constexpr static bool value = std::is_same::value || (!l_is_restricted && !r_is_restricted); - }; - - struct _test : VString<1> {}; - struct _test2 : VString<1> {}; - - static_assert(string_comparison_allowed<_test, _test>::value, "tt"); - static_assert(string_comparison_allowed, VString<1>>::value, "vv"); - static_assert(!string_comparison_allowed<_test, XString>::value, "tx"); - static_assert(!string_comparison_allowed<_test, VString<1>>::value, "tv"); - static_assert(!string_comparison_allowed<_test, _test2>::value, "t2"); - static_assert(string_comparison_allowed, XString>::value, "vx"); - static_assert(string_comparison_allowed::value, "xx"); - static_assert(string_comparison_allowed::value, "xf"); - - template::value>::type> - auto operator == (const L& l, const R& r) -> decltype((xstr_compare(l, r), true)) - { - return xstr_compare(l, r) == 0; - } - template::value>::type> - auto operator != (const L& l, const R& r) -> decltype((xstr_compare(l, r), true)) - { - return xstr_compare(l, r) != 0; - } - template::value>::type> - auto operator < (const L& l, const R& r) -> decltype((xstr_compare(l, r), true)) - { - return xstr_compare(l, r) < 0; - } - template::value>::type> - auto operator <= (const L& l, const R& r) -> decltype((xstr_compare(l, r), true)) - { - return xstr_compare(l, r) <= 0; - } - template::value>::type> - auto operator > (const L& l, const R& r) -> decltype((xstr_compare(l, r), true)) - { - return xstr_compare(l, r) > 0; - } - template::value>::type> - auto operator >= (const L& l, const R& r) -> decltype((xstr_compare(l, r), true)) - { - return xstr_compare(l, r) >= 0; - } - - namespace detail - { - constexpr - bool is_print(char c) - { - return ' ' <= c && c <= '~'; - } - constexpr - bool is_graph(char c) - { - return is_print(c) && c != ' '; - } - constexpr - bool is_lower(char c) - { - return 'a' <= c && c <= 'z'; - } - constexpr - bool is_upper(char c) - { - return 'A' <= c && c <= 'Z'; - } - constexpr - bool is_alpha(char c) - { - return is_lower(c) || is_upper(c); - } - constexpr - bool is_digit2(char c) - { - return '0' <= c && c <= '1'; - } - constexpr - bool is_digit8(char c) - { - return '0' <= c && c <= '7'; - } - constexpr - bool is_digit10(char c) - { - return '0' <= c && c <= '9'; - } - constexpr - bool is_digit16(char c) - { - return ('0' <= c && c <= '9') || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f'); - } - constexpr - bool is_alnum(char c) - { - return is_alpha(c) || is_digit10(c); - } - - constexpr - char to_lower(char c) - { - return is_upper(c) ? c | ' ' : c; - } - constexpr - char to_upper(char c) - { - return is_lower(c) ? c & ~' ' : c; - } - } - - // sadness - typedef MString MS; - typedef FString FS; - typedef SString SS; - typedef TString TS; - typedef ZString ZS; - typedef XString XS; - - // _crtp_string - template - Z _crtp_string::xslice_t(size_t o) const - { return Z(&begin()[o], &*end(), base()); } - template - X _crtp_string::xslice_h(size_t o) const - { return X(&*begin(), &begin()[o], base()); } - template - Z _crtp_string::xrslice_t(size_t no) const - { return Z(&end()[-no], &*end(), base()); } - template - X _crtp_string::xrslice_h(size_t no) const - { return X(&*begin(), &end()[-no], base()); } - template - Z _crtp_string::xislice_t(iterator it) const - { return Z(&*it, &*end(), base()); } - template - X _crtp_string::xislice_h(iterator it) const - { return X(&*begin(), &*it, base()); } - template - X _crtp_string::xlslice(size_t o, size_t l) const - { return X(&begin()[o], &begin()[o + l], base()); } - template - X _crtp_string::xpslice(size_t b, size_t e) const - { return X(&begin()[b], &begin()[e], base()); } - template - X _crtp_string::xislice(iterator b, iterator e) const - { return X(&*b, &*e, base()); } - template - Z _crtp_string::lstrip() const - { - Z z = _ref(); - while (z.startswith(' ')) - z = z.xslice_t(1); - return z; - } - template - X _crtp_string::rstrip() const - { - X x = _ref(); - while (x.endswith(' ')) - x = x.xrslice_h(1); - return x; - } - template - X _crtp_string::strip() const - { return lstrip().rstrip(); } - - template - bool _crtp_string::startswith(XS x) const - { return size() >= x.size() && xslice_h(x.size()) == x; } - template - bool _crtp_string::endswith(XS x) const - { return size() > x.size() && xrslice_t(x.size()) == x; } - template - bool _crtp_string::startswith(char c) const - { return size() && front() == c; } - template - bool _crtp_string::endswith(char c) const - { return size() && back() == c; } - template - bool _crtp_string::contains(char c) const - { return std::find(begin(), end(), c) != end(); } - template - bool _crtp_string::contains_seq(XString s) const - { return std::search(begin(), end(), s.begin(), s.end()) != end(); } - template - bool _crtp_string::contains_any(XString s) const - { return std::find_if(begin(), end(), [s](char c) { return s.contains(c); }) != end(); } - - template - bool _crtp_string::has_print() const - { return std::find_if(begin(), end(), detail::is_print) != end(); } - template - bool _crtp_string::is_print() const - { return std::find_if_not(begin(), end(), detail::is_print) == end(); } - template - O _crtp_string::to_print() const - { - if (is_print()) return _ref(); - char buf[size()]; - char *const b = buf; - char *const e = std::transform(begin(), end(), b, [](char c) { return detail::is_print(c) ? c : '_'; }); - return XString(b, e, nullptr); - } - - template - bool _crtp_string::has_graph() const - { return std::find_if(begin(), end(), detail::is_graph) != end(); } - template - bool _crtp_string::is_graph() const - { return std::find_if_not(begin(), end(), detail::is_graph) == end(); } - - template - bool _crtp_string::has_lower() const - { return std::find_if(begin(), end(), detail::is_lower) != end(); } - template - bool _crtp_string::is_lower() const - { return std::find_if_not(begin(), end(), detail::is_lower) == end(); } - template - O _crtp_string::to_lower() const - { - if (!has_upper()) return _ref(); - char buf[size()]; - char *const b = buf; - char *const e = std::transform(begin(), end(), b, detail::to_lower); - return XString(b, e, nullptr); - } - - template - bool _crtp_string::has_upper() const - { return std::find_if(begin(), end(), detail::is_upper) != end(); } - template - bool _crtp_string::is_upper() const - { return std::find_if_not(begin(), end(), detail::is_upper) == end(); } - template - O _crtp_string::to_upper() const - { - if (!has_lower()) return _ref(); - char buf[size()]; - char *const b = buf; - char *const e = std::transform(begin(), end(), b, detail::to_upper); - return XString(b, e, nullptr); - } - - template - bool _crtp_string::has_alpha() const - { return std::find_if(begin(), end(), detail::is_alpha) != end(); } - template - bool _crtp_string::is_alpha() const - { return std::find_if_not(begin(), end(), detail::is_alpha) == end(); } - - template - bool _crtp_string::has_digit2() const - { return std::find_if(begin(), end(), detail::is_digit2) != end(); } - template - bool _crtp_string::is_digit2() const - { return std::find_if_not(begin(), end(), detail::is_digit2) == end(); } - template - bool _crtp_string::has_digit8() const - { return std::find_if(begin(), end(), detail::is_digit8) != end(); } - template - bool _crtp_string::is_digit8() const - { return std::find_if_not(begin(), end(), detail::is_digit8) == end(); } - template - bool _crtp_string::has_digit10() const - { return std::find_if(begin(), end(), detail::is_digit10) != end(); } - template - bool _crtp_string::is_digit10() const - { return std::find_if_not(begin(), end(), detail::is_digit10) == end(); } - template - bool _crtp_string::has_digit16() const - { return std::find_if(begin(), end(), detail::is_digit16) != end(); } - template - bool _crtp_string::is_digit16() const - { return std::find_if_not(begin(), end(), detail::is_digit16) == end(); } - - template - bool _crtp_string::has_alnum() const - { return std::find_if(begin(), end(), detail::is_alnum) != end(); } - template - bool _crtp_string::is_alnum() const - { return std::find_if_not(begin(), end(), detail::is_alnum) == end(); } - - // MString - inline - MS& MS::operator += (XS x) - { - _hack.insert(_hack.end(), x.begin(), x.end()); - return *this; - } - - // FString - inline - TS FS::oslice_t(size_t o) const - { return TS(*this, o); } - inline - SS FS::oslice_h(size_t o) const - { return SS(*this, 0, o); } - inline - TS FS::orslice_t(size_t no) const - { return TS(*this, size() - no); } - inline - SS FS::orslice_h(size_t no) const - { return SS(*this, 0, size() - no); } - inline - TS FS::oislice_t(iterator it) const - { return TS(*this, it - begin()); } - inline - SS FS::oislice_h(iterator it) const - { return SS(*this, 0, it - begin()); } - inline - SS FS::olslice(size_t o, size_t l) const - { return SS(*this, o, o + l); } - inline - SS FS::opslice(size_t b, size_t e) const - { return SS(*this, b, e); } - inline - SS FS::oislice(iterator b, iterator e) const - { return SS(*this, b - begin(), e - begin()); } - - // TString - inline - TS TS::oslice_t(size_t o) const - { return TS(_s, _o + o); } - inline - SS TS::oslice_h(size_t o) const - { return SS(_s, _o, _o + o); } - inline - TS TS::orslice_t(size_t no) const - { return TS(_s, _s.size() - no); } - inline - SS TS::orslice_h(size_t no) const - { return SS(_s, _o, _s.size() - no); } - inline - TS TS::oislice_t(iterator it) const - { return TS(_s, _o + it - begin()); } - inline - SS TS::oislice_h(iterator it) const - { return SS(_s, _o, _o + it - begin()); } - inline - SS TS::olslice(size_t o, size_t l) const - { return SS(_s, _o + o, _o + o + l); } - inline - SS TS::opslice(size_t b, size_t e) const - { return SS(_s, _o + b, _o + e); } - inline - SS TS::oislice(iterator b, iterator e) const - { return SS(_s, _o + b - begin(), _o + e - begin()); } - - // SString - inline - SS SS::oslice_t(size_t o) const - { return SS(_s, _b + o, _e); } - inline - SS SS::oslice_h(size_t o) const - { return SS(_s, _b, _b + o); } - inline - SS SS::orslice_t(size_t no) const - { return SS(_s, _e - no, _e); } - inline - SS SS::orslice_h(size_t no) const - { return SS(_s, _b, _e - no); } - inline - SS SS::oislice_t(iterator it) const - { return SS(_s, _b + it - begin(), _e); } - inline - SS SS::oislice_h(iterator it) const - { return SS(_s, _b, _b + it - begin()); } - inline - SS SS::olslice(size_t o, size_t l) const - { return SS(_s, _b + o, _b + o + l); } - inline - SS SS::opslice(size_t b, size_t e) const - { return SS(_s, _b + b, _b + e); } - inline - SS SS::oislice(iterator b, iterator e) const - { return SS(_s, _b + b - begin(), _b + e - begin()); } - - // ZString - inline - ZS ZS::oslice_t(size_t o) const - { return ZS(really_construct_from_a_pointer, &begin()[o], base()); } - inline - XS ZS::oslice_h(size_t o) const - { return XS(&*begin(), &begin()[o], base()); } - inline - ZS ZS::orslice_t(size_t no) const - { return ZS(really_construct_from_a_pointer, &end()[-no], base()); } - inline - XS ZS::orslice_h(size_t no) const - { return XS(&*begin(), &end()[-no], base()); } - inline - ZS ZS::oislice_t(iterator it) const - { return ZS(really_construct_from_a_pointer, &*it, base()); } - inline - XS ZS::oislice_h(iterator it) const - { return XS(&*begin(), &*it, base()); } - inline - XS ZS::olslice(size_t o, size_t l) const - { return XS(&begin()[o], &begin()[o + l], base()); } - inline - XS ZS::opslice(size_t b, size_t e) const - { return XS(&begin()[b], &begin()[e], base()); } - inline - XS ZS::oislice(iterator b, iterator e) const - { return XS(&*b, &*e, base()); } - - - // cxxstdio helpers - // I think the conversion will happen automatically. TODO test this. - // Nope, it doesn't, since there's a template - // Actually, it might now. - inline - const char *decay_for_printf(const FString& fs) { return fs.c_str(); } - inline - const char *decay_for_printf(const TString& ts) { return ts.c_str(); } - inline - const char *decay_for_printf(const ZString& zs) { return zs.c_str(); } - template - inline - const char *decay_for_printf(const VString& vs) { return vs.c_str(); } - - template - inline __attribute__((format(printf, 2, 0))) - int do_vprint(VString& out, const char *fmt, va_list ap) - { - char buffer[len + 1]; - vsnprintf(buffer, len + 1, fmt, ap); - - out = const_(buffer); - return len; - } - - inline __attribute__((format(printf, 2, 0))) - int do_vprint(FString& out, const char *fmt, va_list ap) - { - int len; - { - va_list ap2; - va_copy(ap2, ap); - len = vsnprintf(nullptr, 0, fmt, ap2); - va_end(ap2); - } - char buffer[len + 1]; - vsnprintf(buffer, len + 1, fmt, ap); - - out = FString(buffer, buffer + len); - return len; - } - - inline __attribute__((format(scanf, 2, 0))) - int do_vscan(ZString in, const char *fmt, va_list ap) - { - return vsscanf(in.c_str(), fmt, ap); - } - - class StringConverter - { - FString& out; - char *mid; - public: - StringConverter(FString& s) - : out(s), mid(nullptr) - {} - ~StringConverter() - { - if (mid) - { - out = ZString(ZString::really_construct_from_a_pointer, mid, nullptr); - free(mid); - } - } - char **operator &() - { - return ∣ - } - }; - - inline - StringConverter convert_for_scanf(FString& s) - { - return StringConverter(s); - } -} // namespace strings - -// owning -using strings::MString; -using strings::FString; -using strings::SString; -using strings::TString; - -// non-owning -using strings::ZString; -using strings::XString; - -// semi-owning -using strings::VString; - -#endif // TMWA_COMMON_STRINGS_HPP diff --git a/src/common/strings2_test.cpp b/src/common/strings2_test.cpp deleted file mode 100644 index fa4dc6f..0000000 --- a/src/common/strings2_test.cpp +++ /dev/null @@ -1,118 +0,0 @@ -#include "strings.hpp" - -#include - -TEST(StringTests, traits2) -{ - ZString print_non = "\t\e"; - ZString print_mix = "n\t"; - FString print_all = "n "; - EXPECT_FALSE(print_non.has_print()); - EXPECT_TRUE(print_mix.has_print()); - EXPECT_TRUE(print_all.has_print()); - EXPECT_FALSE(print_non.is_print()); - EXPECT_FALSE(print_mix.is_print()); - EXPECT_TRUE(print_all.is_print()); - EXPECT_EQ("__", print_non.to_print()); - EXPECT_EQ("n_", print_mix.to_print()); - EXPECT_EQ("n ", print_all.to_print()); - EXPECT_EQ(print_all.begin(), print_all.to_print().begin()); - - ZString graph_non = " \e"; - ZString graph_mix = "n "; - FString graph_all = "n."; - EXPECT_FALSE(graph_non.has_graph()); - EXPECT_TRUE(graph_mix.has_graph()); - EXPECT_TRUE(graph_all.has_graph()); - EXPECT_FALSE(graph_non.is_graph()); - EXPECT_FALSE(graph_mix.is_graph()); - EXPECT_TRUE(graph_all.is_graph()); - - ZString lower_non = "0A"; - ZString lower_mix = "Oa"; - FString lower_all = "oa"; - EXPECT_FALSE(lower_non.has_lower()); - EXPECT_TRUE(lower_mix.has_lower()); - EXPECT_TRUE(lower_all.has_lower()); - EXPECT_FALSE(lower_non.is_lower()); - EXPECT_FALSE(lower_mix.is_lower()); - EXPECT_TRUE(lower_all.is_lower()); - EXPECT_EQ("0a", lower_non.to_lower()); - EXPECT_EQ("oa", lower_mix.to_lower()); - EXPECT_EQ("oa", lower_all.to_lower()); - EXPECT_EQ(lower_all.begin(), lower_all.to_lower().begin()); - - ZString upper_non = "0a"; - ZString upper_mix = "oA"; - FString upper_all = "OA"; - EXPECT_FALSE(upper_non.has_upper()); - EXPECT_TRUE(upper_mix.has_upper()); - EXPECT_TRUE(upper_all.has_upper()); - EXPECT_FALSE(upper_non.is_upper()); - EXPECT_FALSE(upper_mix.is_upper()); - EXPECT_TRUE(upper_all.is_upper()); - EXPECT_EQ("0A", upper_non.to_upper()); - EXPECT_EQ("OA", upper_mix.to_upper()); - EXPECT_EQ("OA", upper_all.to_upper()); - EXPECT_EQ(upper_all.begin(), upper_all.to_upper().begin()); - - ZString alpha_non = " 0"; - ZString alpha_mix = "n "; - FString alpha_all = "nA"; - EXPECT_FALSE(alpha_non.has_alpha()); - EXPECT_TRUE(alpha_mix.has_alpha()); - EXPECT_TRUE(alpha_all.has_alpha()); - EXPECT_FALSE(alpha_non.is_alpha()); - EXPECT_FALSE(alpha_mix.is_alpha()); - EXPECT_TRUE(alpha_all.is_alpha()); - - ZString digit2_non = "a9"; - ZString digit2_mix = "20"; - FString digit2_all = "01"; - EXPECT_FALSE(digit2_non.has_digit2()); - EXPECT_TRUE(digit2_mix.has_digit2()); - EXPECT_TRUE(digit2_all.has_digit2()); - EXPECT_FALSE(digit2_non.is_digit2()); - EXPECT_FALSE(digit2_mix.is_digit2()); - EXPECT_TRUE(digit2_all.is_digit2()); - - ZString digit8_non = "a9"; - ZString digit8_mix = "80"; - FString digit8_all = "37"; - EXPECT_FALSE(digit8_non.has_digit8()); - EXPECT_TRUE(digit8_mix.has_digit8()); - EXPECT_TRUE(digit8_all.has_digit8()); - EXPECT_FALSE(digit8_non.is_digit8()); - EXPECT_FALSE(digit8_mix.is_digit8()); - EXPECT_TRUE(digit8_all.is_digit8()); - - ZString digit10_non = "az"; - ZString digit10_mix = "a9"; - FString digit10_all = "42"; - EXPECT_FALSE(digit10_non.has_digit10()); - EXPECT_TRUE(digit10_mix.has_digit10()); - EXPECT_TRUE(digit10_all.has_digit10()); - EXPECT_FALSE(digit10_non.is_digit10()); - EXPECT_FALSE(digit10_mix.is_digit10()); - EXPECT_TRUE(digit10_all.is_digit10()); - - ZString digit16_non = "gz"; - ZString digit16_mix = "ao"; - FString digit16_all = "be"; - EXPECT_FALSE(digit16_non.has_digit16()); - EXPECT_TRUE(digit16_mix.has_digit16()); - EXPECT_TRUE(digit16_all.has_digit16()); - EXPECT_FALSE(digit16_non.is_digit16()); - EXPECT_FALSE(digit16_mix.is_digit16()); - EXPECT_TRUE(digit16_all.is_digit16()); - - ZString alnum_non = " ."; - ZString alnum_mix = "n "; - FString alnum_all = "n0"; - EXPECT_FALSE(alnum_non.has_alnum()); - EXPECT_TRUE(alnum_mix.has_alnum()); - EXPECT_TRUE(alnum_all.has_alnum()); - EXPECT_FALSE(alnum_non.is_alnum()); - EXPECT_FALSE(alnum_mix.is_alnum()); - EXPECT_TRUE(alnum_all.is_alnum()); -} diff --git a/src/common/strings_test.cpp b/src/common/strings_test.cpp deleted file mode 100644 index fa04f1c..0000000 --- a/src/common/strings_test.cpp +++ /dev/null @@ -1,276 +0,0 @@ -#include "strings.hpp" - -#include - -#include - -template -class StringTest : public ::testing::Test -{ -}; -TYPED_TEST_CASE_P(StringTest); - -TYPED_TEST_P(StringTest, basic) -{ - TypeParam hi("Hello"); - EXPECT_EQ(5, hi.size()); - EXPECT_EQ(hi, hi); - const char hi2[] = "Hello\0random garbage"; - EXPECT_EQ(hi, hi2); - TypeParam hi0; - EXPECT_EQ(0, hi0.size()); - - __attribute__((unused)) - const FString *base = hi.base(); -} - -TYPED_TEST_P(StringTest, order) -{ - TypeParam a; - TypeParam b("Hello"); - TypeParam c("Hello,"); - TypeParam d("World!"); - - // not using EXPECT_LT, etc. for better visibility - - EXPECT_FALSE(a < a); - EXPECT_TRUE(a < b); - EXPECT_TRUE(a < c); - EXPECT_TRUE(a < d); - EXPECT_FALSE(b < a); - EXPECT_FALSE(b < b); - EXPECT_TRUE(b < c); - EXPECT_TRUE(b < d); - EXPECT_FALSE(c < a); - EXPECT_FALSE(c < b); - EXPECT_FALSE(c < c); - EXPECT_TRUE(c < d); - EXPECT_FALSE(d < a); - EXPECT_FALSE(d < b); - EXPECT_FALSE(d < c); - EXPECT_FALSE(d < d); - - EXPECT_TRUE(a <= a); - EXPECT_TRUE(a <= b); - EXPECT_TRUE(a <= c); - EXPECT_TRUE(a <= d); - EXPECT_FALSE(b <= a); - EXPECT_TRUE(b <= b); - EXPECT_TRUE(b <= c); - EXPECT_TRUE(b <= d); - EXPECT_FALSE(c <= a); - EXPECT_FALSE(c <= b); - EXPECT_TRUE(c <= c); - EXPECT_TRUE(c <= d); - EXPECT_FALSE(d <= a); - EXPECT_FALSE(d <= b); - EXPECT_FALSE(d <= c); - EXPECT_TRUE(d <= d); - - EXPECT_TRUE(a >= a); - EXPECT_FALSE(a >= b); - EXPECT_FALSE(a >= c); - EXPECT_FALSE(a >= d); - EXPECT_TRUE(b >= a); - EXPECT_TRUE(b >= b); - EXPECT_FALSE(b >= c); - EXPECT_FALSE(b >= d); - EXPECT_TRUE(c >= a); - EXPECT_TRUE(c >= b); - EXPECT_TRUE(c >= c); - EXPECT_FALSE(c >= d); - EXPECT_TRUE(d >= a); - EXPECT_TRUE(d >= b); - EXPECT_TRUE(d >= c); - EXPECT_TRUE(d >= d); - - EXPECT_FALSE(a > a); - EXPECT_FALSE(a > b); - EXPECT_FALSE(a > c); - EXPECT_FALSE(a > d); - EXPECT_TRUE(b > a); - EXPECT_FALSE(b > b); - EXPECT_FALSE(b > c); - EXPECT_FALSE(b > d); - EXPECT_TRUE(c > a); - EXPECT_TRUE(c > b); - EXPECT_FALSE(c > c); - EXPECT_FALSE(c > d); - EXPECT_TRUE(d > a); - EXPECT_TRUE(d > b); - EXPECT_TRUE(d > c); - EXPECT_FALSE(d > d); - - EXPECT_TRUE(a == a); - EXPECT_FALSE(a == b); - EXPECT_FALSE(a == c); - EXPECT_FALSE(a == d); - EXPECT_FALSE(b == a); - EXPECT_TRUE(b == b); - EXPECT_FALSE(b == c); - EXPECT_FALSE(b == d); - EXPECT_FALSE(c == a); - EXPECT_FALSE(c == b); - EXPECT_TRUE(c == c); - EXPECT_FALSE(c == d); - EXPECT_FALSE(d == a); - EXPECT_FALSE(d == b); - EXPECT_FALSE(d == c); - EXPECT_TRUE(d == d); - - EXPECT_FALSE(a != a); - EXPECT_TRUE(a != b); - EXPECT_TRUE(a != c); - EXPECT_TRUE(a != d); - EXPECT_TRUE(b != a); - EXPECT_FALSE(b != b); - EXPECT_TRUE(b != c); - EXPECT_TRUE(b != d); - EXPECT_TRUE(c != a); - EXPECT_TRUE(c != b); - EXPECT_FALSE(c != c); - EXPECT_TRUE(c != d); - EXPECT_TRUE(d != a); - EXPECT_TRUE(d != b); - EXPECT_TRUE(d != c); - EXPECT_FALSE(d != d); -} - -TYPED_TEST_P(StringTest, iterators) -{ - TypeParam hi("Hello"); - EXPECT_EQ(hi.begin(), hi.begin()); - EXPECT_NE(hi.begin(), hi.end()); - EXPECT_EQ(5, std::distance(hi.begin(), hi.end())); - const char *hi2 = "Hello"; - EXPECT_TRUE(std::equal(hi.begin(), hi.end(), hi2)); -} - -TYPED_TEST_P(StringTest, xslice) -{ - TypeParam hi("Hello, World!"); - EXPECT_EQ(" World!", hi.xslice_t(6)); - EXPECT_EQ("Hello,", hi.xslice_h(6)); - EXPECT_EQ("World!", hi.xrslice_t(6)); - EXPECT_EQ("Hello, ", hi.xrslice_h(6)); - typename TypeParam::iterator it = std::find(hi.begin(), hi.end(), ' '); - EXPECT_EQ(" World!", hi.xislice_t(it)); - EXPECT_EQ("Hello,", hi.xislice_h(it)); - EXPECT_EQ("World", hi.xlslice(7, 5)); - EXPECT_EQ("World", hi.xpslice(7, 12)); - EXPECT_EQ("World", hi.xislice(hi.begin() + 7, hi.begin() + 12)); - EXPECT_TRUE(hi.startswith("Hello")); - EXPECT_TRUE(hi.endswith("World!")); -} - -TYPED_TEST_P(StringTest, oslice) -{ - TypeParam hi("Hello, World!"); - EXPECT_EQ(" World!", hi.oslice_t(6)); - EXPECT_EQ("Hello,", hi.oslice_h(6)); - EXPECT_EQ("World!", hi.orslice_t(6)); - EXPECT_EQ("Hello, ", hi.orslice_h(6)); - typename TypeParam::iterator it = std::find(hi.begin(), hi.end(), ' '); - EXPECT_EQ(" World!", hi.oislice_t(it)); - EXPECT_EQ("Hello,", hi.oislice_h(it)); - EXPECT_EQ("World", hi.olslice(7, 5)); - EXPECT_EQ("World", hi.opslice(7, 12)); - EXPECT_EQ("World", hi.oislice(hi.begin() + 7, hi.begin() + 12)); -} - -TYPED_TEST_P(StringTest, convert) -{ - constexpr bool is_zstring = std::is_same::value; - typedef typename std::conditional::type Sstring; - typedef typename std::conditional::type Xstring; - FString f = "f"; - TString t = "t"; - Sstring s = "s"; - ZString z = "z"; - Xstring x = "x"; - VString<255> v = "v"; - const char l[] = "l"; - VString<5> hi = "hello"; - - TypeParam f2 = f; - TypeParam t2 = t; - TypeParam s2 = s; - TypeParam z2 = z; - TypeParam x2 = x; - TypeParam v2 = v; - TypeParam l2 = l; - TypeParam hi2 = hi; - - EXPECT_EQ(f, f2); - EXPECT_EQ(t, t2); - EXPECT_EQ(s, s2); - EXPECT_EQ(z, z2); - EXPECT_EQ(x, x2); - EXPECT_EQ(v, v2); - EXPECT_EQ(l, l2); - EXPECT_EQ(hi, hi2); - - TypeParam f3, t3, s3, z3, x3, v3, l3, hi3; - f3 = f; - t3 = t; - s3 = s; - z3 = z; - x3 = x; - v3 = v; - l3 = l; - hi3 = hi; - - EXPECT_EQ(f, f3); - EXPECT_EQ(t, t3); - EXPECT_EQ(s, s3); - EXPECT_EQ(z, z3); - EXPECT_EQ(x, x3); - EXPECT_EQ(v, v3); - EXPECT_EQ(l, l3); - EXPECT_EQ(hi, hi3); -} - -REGISTER_TYPED_TEST_CASE_P(StringTest, - basic, order, iterators, xslice, oslice, convert); - -typedef ::testing::Types< - FString, TString, SString, ZString, XString, VString<255> -> MostStringTypes; -INSTANTIATE_TYPED_TEST_CASE_P(StringStuff, StringTest, MostStringTypes); - -TEST(VStringTest, basic) -{ - VString<5> hi = "Hello"; - EXPECT_EQ(5, hi.size()); - EXPECT_EQ(hi, hi); - // truncation - VString<5> hi2(ZString::really_construct_from_a_pointer, "Hello, world!"); - EXPECT_EQ(5, hi2.size()); - EXPECT_EQ(hi, hi2); - // short - hi = "hi"; - EXPECT_EQ(2, hi.size()); - VString<5> hi0; - EXPECT_EQ(0, hi0.size()); -} - -template -class NulStringTest : public ::testing::Test -{ -}; -TYPED_TEST_CASE_P(NulStringTest); - -TYPED_TEST_P(NulStringTest, basic) -{ - TypeParam hi("hello"); - EXPECT_EQ(hi.size(), strlen(hi.c_str())); - EXPECT_STREQ("hello", hi.c_str()); -} - -REGISTER_TYPED_TEST_CASE_P(NulStringTest, - basic); - -typedef ::testing::Types< - FString, TString, ZString, VString<255> -> NulStringTypes; -INSTANTIATE_TYPED_TEST_CASE_P(NulStringStuff, NulStringTest, NulStringTypes); diff --git a/src/common/timer.cpp b/src/common/timer.cpp index c00f06d..17c6d80 100644 --- a/src/common/timer.cpp +++ b/src/common/timer.cpp @@ -8,6 +8,8 @@ #include +#include "../strings/zstring.hpp" + #include "cxxstdio.hpp" #include "utils.hpp" diff --git a/src/common/timer.hpp b/src/common/timer.hpp index b9c9588..de867ab 100644 --- a/src/common/timer.hpp +++ b/src/common/timer.hpp @@ -5,7 +5,7 @@ # include "sanity.hpp" -# include "strings.hpp" +# include "../strings/fwd.hpp" // updated automatically when using milli_clock::now() // which is done only by core.cpp diff --git a/src/common/utils.cpp b/src/common/utils.cpp index 9ab470b..21440a4 100644 --- a/src/common/utils.cpp +++ b/src/common/utils.cpp @@ -5,6 +5,12 @@ #include +#include "../strings/fstring.hpp" +#include "../strings/tstring.hpp" +#include "../strings/sstring.hpp" +#include "../strings/zstring.hpp" +#include "../strings/xstring.hpp" + #include "cxxstdio.hpp" #include "extract.hpp" @@ -42,7 +48,7 @@ bool e_mail_check(XString email) // Return numerical value of a switch configuration // on/off, english, français, deutsch, español //------------------------------------------------- -int config_switch (ZString str) +int config_switch(ZString str) { if (str == "true" || str == "on" || str == "yes" || str == "oui" || str == "ja" diff --git a/src/common/utils.hpp b/src/common/utils.hpp index 4f6190a..66b1654 100644 --- a/src/common/utils.hpp +++ b/src/common/utils.hpp @@ -8,9 +8,11 @@ #include +#include "../strings/fwd.hpp" +#include "../strings/vstring.hpp" + #include "const_array.hpp" #include "operators.hpp" -#include "strings.hpp" #include "utils2.hpp" template -- cgit v1.2.3-70-g09d2