| // This file is part of the ustl library, an STL implementation. |
| // |
| // Copyright (C) 2005 by Mike Sharov <msharov@users.sourceforge.net> |
| // This file is free software, distributed under the MIT License. |
| // |
| // ustring.h |
| // |
| |
| #ifndef USTRING_H_1249CB7A098A9010763AAC6D37B133CF |
| #define USTRING_H_1249CB7A098A9010763AAC6D37B133CF |
| |
| #include "memblock.h" |
| #include "utf8.h" |
| #include <stdarg.h> // for va_list, va_start, and va_end (in string::format) |
| |
| namespace ustl { |
| |
| /// \class string ustring.h ustl.h |
| /// \ingroup Sequences |
| /// |
| /// \brief STL basic_string<char> equivalent. |
| /// |
| /// An STL container for text string manipulation. |
| /// Differences from C++ standard: |
| /// - string is a class, not a template. Wide characters are assumed to be |
| /// encoded with utf8 at all times except when rendering or editing, |
| /// where you would use a utf8 iterator. |
| /// - format member function - you can, of course use an \ref ostringstream, |
| /// which also have format functions, but most of the time this way |
| /// is more convenient. Because uSTL does not implement locales, |
| /// format is the only way to create localized strings. |
| /// - const char* cast operator. It is much clearer to use this than having |
| /// to type .c_str() every time. |
| /// - length returns the number of _characters_, not bytes. |
| /// This function is O(N), so use wisely. |
| /// |
| class string : public memblock { |
| public: |
| typedef char value_type; |
| typedef value_type* pointer; |
| typedef const value_type* const_pointer; |
| typedef wchar_t wvalue_type; |
| typedef wvalue_type* wpointer; |
| typedef const wvalue_type* const_wpointer; |
| typedef pointer iterator; |
| typedef const_pointer const_iterator; |
| typedef value_type& reference; |
| typedef value_type const_reference; |
| typedef ::ustl::reverse_iterator<iterator> reverse_iterator; |
| typedef ::ustl::reverse_iterator<const_iterator> const_reverse_iterator; |
| typedef utf8in_iterator<const_iterator> utf8_iterator; |
| public: |
| static const uoff_t npos = static_cast<uoff_t>(-1); ///< Value that means the end of string. |
| static const value_type c_Terminator = 0; ///< String terminator |
| static const size_type size_Terminator = sizeof(c_Terminator); ///< Most systems terminate strings with '\\0' |
| static const char empty_string [size_Terminator]; ///< An empty string. |
| public: |
| string (void); |
| string (const string& s); |
| inline string (const string& s, uoff_t o, size_type n); |
| inline explicit string (const cmemlink& l); |
| string (const_pointer s); |
| inline string (const_pointer s, size_type len); |
| inline string (const_pointer s1, const_pointer s2); |
| explicit string (size_type n, value_type c = c_Terminator); |
| inline pointer data (void) { return (string::pointer (memblock::data())); } |
| inline const_pointer c_str (void) const { return (string::const_pointer (memblock::cdata())); } |
| inline size_type max_size (void) const { size_type s (memblock::max_size()); return (s - !!s); } |
| inline size_type capacity (void) const { size_type c (memblock::capacity()); return (c - !!c); } |
| void resize (size_type n); |
| inline void clear (void) { resize (0); } |
| inline const_iterator begin (void) const { return (const_iterator (memblock::begin())); } |
| inline iterator begin (void) { return (iterator (memblock::begin())); } |
| inline const_iterator end (void) const { return (const_iterator (memblock::end())); } |
| inline iterator end (void) { return (iterator (memblock::end())); } |
| inline const_reverse_iterator rbegin (void) const { return (const_reverse_iterator (end())); } |
| inline reverse_iterator rbegin (void) { return (reverse_iterator (end())); } |
| inline const_reverse_iterator rend (void) const { return (const_reverse_iterator (begin())); } |
| inline reverse_iterator rend (void) { return (reverse_iterator (begin())); } |
| inline utf8_iterator utf8_begin (void) const { return (utf8_iterator (begin())); } |
| inline utf8_iterator utf8_end (void) const { return (utf8_iterator (end())); } |
| inline const_reference at (uoff_t pos) const { assert (pos <= size() && begin()); return (begin()[pos]); } |
| inline reference at (uoff_t pos) { assert (pos <= size() && begin()); return (begin()[pos]); } |
| inline const_iterator iat (uoff_t pos) const { return (begin() + min (pos, size())); } |
| inline iterator iat (uoff_t pos) { return (begin() + min (pos, size())); } |
| inline size_type length (void) const { return (distance (utf8_begin(), utf8_end())); } |
| inline void append (const_iterator i1, const_iterator i2) { append (i1, distance (i1, i2)); } |
| void append (const_pointer s, size_type len); |
| void append (const_pointer s); |
| void append (size_type n, const_reference c); |
| inline void append (size_type n, wvalue_type c) { insert (size(), c, n); } |
| inline void append (const_wpointer s1, const_wpointer s2) { insert (size(), s1, s2); } |
| inline void append (const_wpointer s) { const_wpointer se (s); for (;se&&*se;++se); append (s, se); } |
| inline void append (const string& s) { append (s.begin(), s.end()); } |
| inline void append (const string& s, uoff_t o, size_type n) { append (s.iat(o), s.iat(o+n)); } |
| inline void assign (const_iterator i1, const_iterator i2) { assign (i1, distance (i1, i2)); } |
| void assign (const_pointer s, size_type len); |
| void assign (const_pointer s); |
| inline void assign (const_wpointer s1, const_wpointer s2) { clear(); append (s1, s2); } |
| inline void assign (const_wpointer s1) { clear(); append (s1); } |
| inline void assign (const string& s) { assign (s.begin(), s.end()); } |
| inline void assign (const string& s, uoff_t o, size_type n) { assign (s.iat(o), s.iat(o+n)); } |
| size_type copyto (pointer p, size_type n, const_iterator start = NULL) const; |
| inline int compare (const string& s) const { return (compare (begin(), end(), s.begin(), s.end())); } |
| inline int compare (const_pointer s) const { return (compare (begin(), end(), s, s + strlen(s))); } |
| static int compare (const_iterator first1, const_iterator last1, const_iterator first2, const_iterator last2); |
| inline operator const value_type* (void) const; |
| inline operator value_type* (void); |
| inline const string& operator= (const string& s) { assign (s.begin(), s.end()); return (*this); } |
| inline const string& operator= (const_reference c) { assign (&c, 1); return (*this); } |
| inline const string& operator= (const_pointer s) { assign (s); return (*this); } |
| inline const string& operator= (const_wpointer s) { assign (s); return (*this); } |
| inline const string& operator+= (const string& s) { append (s.begin(), s.size()); return (*this); } |
| inline const string& operator+= (const_reference c) { append (1, c); return (*this); } |
| inline const string& operator+= (const_pointer s) { append (s); return (*this); } |
| inline const string& operator+= (wvalue_type c) { append (1, c); return (*this); } |
| inline const string& operator+= (const_wpointer s) { append (s); return (*this); } |
| inline string operator+ (const string& s) const; |
| inline bool operator== (const string& s) const { return (memblock::operator== (s)); } |
| bool operator== (const_pointer s) const; |
| inline bool operator== (const_reference c) const { return (size() == 1 && c == at(0)); } |
| inline bool operator!= (const string& s) const { return (!operator== (s)); } |
| inline bool operator!= (const_pointer s) const { return (!operator== (s)); } |
| inline bool operator!= (const_reference c) const { return (!operator== (c)); } |
| inline bool operator< (const string& s) const { return (0 > compare (s)); } |
| inline bool operator< (const_pointer s) const { return (0 > compare (s)); } |
| inline bool operator< (const_reference c) const { return (0 > compare (begin(), end(), &c, &c + 1)); } |
| inline bool operator> (const_pointer s) const { return (0 < compare (s)); } |
| void insert (const uoff_t ip, wvalue_type c, size_type n = 1); |
| void insert (const uoff_t ip, const_wpointer first, const_wpointer last, const size_type n = 1); |
| iterator insert (iterator start, const_reference c, size_type n = 1); |
| iterator insert (iterator start, const_pointer s, size_type n = 1); |
| iterator insert (iterator start, const_pointer first, const_iterator last, size_type n = 1); |
| inline void insert (uoff_t ip, const_pointer s, size_type nlen) { insert (iat(ip), s, s + nlen); } |
| inline void insert (uoff_t ip, size_type n, value_type c) { insert (iat(ip), c, n); } |
| inline void insert (uoff_t ip, const string& s, uoff_t sp, size_type slen) { insert (iat(ip), s.iat(sp), s.iat(sp + slen)); } |
| iterator erase (iterator start, size_type size = 1); |
| void erase (uoff_t start, size_type size = 1); |
| inline iterator erase (iterator first, const_iterator last) { return (erase (first, size_type(distance(first,last)))); } |
| OVERLOAD_POINTER_AND_SIZE_T_V2(erase, iterator) |
| inline void push_back (const_reference c) { append (1, c); } |
| inline void push_back (wvalue_type c) { append (1, c); } |
| inline void pop_back (void) { resize (size() - 1); } |
| void replace (iterator first, iterator last, const_pointer s); |
| void replace (iterator first, iterator last, const_pointer i1, const_pointer i2, size_type n = 1); |
| inline void replace (iterator first, iterator last, const string& s) { replace (first, last, s.begin(), s.end()); } |
| inline void replace (iterator first, iterator last, const_pointer s, size_type slen) { replace (first, last, s, s + slen); } |
| inline void replace (iterator first, iterator last, size_type n, value_type c) { replace (first, last, &c, &c + 1, n); } |
| inline void replace (uoff_t rp, size_type n, const string& s) { replace (iat(rp), iat(rp + n), s); } |
| inline void replace (uoff_t rp, size_type n, const string& s, uoff_t sp, size_type slen) { replace (iat(rp), iat(rp + n), s.iat(sp), s.iat(sp + slen)); } |
| inline void replace (uoff_t rp, size_type n, const_pointer s, size_type slen) { replace (iat(rp), iat(rp + n), s, s + slen); } |
| inline void replace (uoff_t rp, size_type n, const_pointer s) { replace (iat(rp), iat(rp + n), string(s)); } |
| inline void replace (uoff_t rp, size_type n, size_type count, value_type c) { replace (iat(rp), iat(rp + n), count, c); } |
| inline string substr (uoff_t o, size_type n) const { return (string (*this, o, n)); } |
| uoff_t find (const_reference c, uoff_t pos = 0) const; |
| uoff_t find (const string& s, uoff_t pos = 0) const; |
| uoff_t rfind (const_reference c, uoff_t pos = npos) const; |
| uoff_t rfind (const string& s, uoff_t pos = npos) const; |
| uoff_t find_first_of (const string& s, uoff_t pos = 0) const; |
| uoff_t find_first_not_of (const string& s, uoff_t pos = 0) const; |
| uoff_t find_last_of (const string& s, uoff_t pos = npos) const; |
| uoff_t find_last_not_of (const string& s, uoff_t pos = npos) const; |
| int vformat (const char* fmt, va_list args); |
| int format (const char* fmt, ...) __attribute__((__format__(__printf__, 2, 3))); |
| void read (istream&); |
| void write (ostream& os) const; |
| size_t stream_size (void) const; |
| static hashvalue_t hash (const char* f1, const char* l1); |
| private: |
| DLL_LOCAL iterator utf8_iat (uoff_t i); |
| protected: |
| inline virtual size_type minimumFreeCapacity (void) const { return (size_Terminator); } |
| }; |
| |
| //---------------------------------------------------------------------- |
| |
| /// Assigns itself the value of string \p s |
| inline string::string (const cmemlink& s) |
| : memblock () |
| { |
| assign (const_iterator (s.begin()), s.size()); |
| } |
| |
| /// Assigns itself a [o,o+n) substring of \p s. |
| inline string::string (const string& s, uoff_t o, size_type n) |
| : memblock() |
| { |
| assign (s, o, n); |
| } |
| |
| /// Copies the value of \p s of length \p len into itself. |
| inline string::string (const_pointer s, size_type len) |
| : memblock () |
| { |
| assign (s, len); |
| } |
| |
| /// Copies into itself the string data between \p s1 and \p s2 |
| inline string::string (const_pointer s1, const_pointer s2) |
| : memblock () |
| { |
| assert (s1 <= s2 && "Negative ranges result in memory allocation errors."); |
| assign (s1, s2); |
| } |
| |
| /// Returns the pointer to the first character. |
| inline string::operator const string::value_type* (void) const |
| { |
| assert ((!end() || *end() == c_Terminator) && "This string is linked to data that is not 0-terminated. This may cause serious security problems. Please assign the data instead of linking."); |
| return (begin()); |
| } |
| |
| /// Returns the pointer to the first character. |
| inline string::operator string::value_type* (void) |
| { |
| assert ((end() && *end() == c_Terminator) && "This string is linked to data that is not 0-terminated. This may cause serious security problems. Please assign the data instead of linking."); |
| return (begin()); |
| } |
| |
| /// Concatenates itself with \p s |
| inline string string::operator+ (const string& s) const |
| { |
| string result (*this); |
| result += s; |
| return (result); |
| } |
| |
| //---------------------------------------------------------------------- |
| // Operators needed to avoid comparing pointer to pointer |
| |
| #define PTR_STRING_CMP(op, impl) \ |
| inline bool op (const char* s1, const string& s2) { return impl; } |
| PTR_STRING_CMP (operator==, (s2 == s1)) |
| PTR_STRING_CMP (operator!=, (s2 != s1)) |
| PTR_STRING_CMP (operator<, (s2 > s1)) |
| PTR_STRING_CMP (operator<=, (s2 >= s1)) |
| PTR_STRING_CMP (operator>, (s2 < s1)) |
| PTR_STRING_CMP (operator>=, (s2 <= s1)) |
| #undef PTR_STRING_CMP |
| |
| //---------------------------------------------------------------------- |
| |
| template <typename T> |
| inline hashvalue_t hash_value (const T& v) |
| { return (string::hash (v.begin(), v.end())); } |
| |
| template <> |
| inline hashvalue_t hash_value (const string::const_pointer& v) |
| { return (string::hash (v, v + strlen(v))); } |
| |
| template <> |
| inline hashvalue_t hash_value (const string::pointer& v) |
| { return (string::hash (v, v + strlen(v))); } |
| |
| //---------------------------------------------------------------------- |
| |
| } // namespace ustl |
| |
| // Specialization for stream alignment |
| ALIGNOF (ustl::string, alignof (string::value_type())) |
| |
| #endif |
| |
