put userstring in otk::
[mikachu/openbox.git] / otk / userstring.hh
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2 #ifndef   __userstring_hh
3 #define   __userstring_hh
4
5 #include <string>
6 #include <vector>
7
8 extern "C" {
9 #include <assert.h>
10 }
11
12 namespace otk {
13
14 //! userstring is a std::string with an extra flag specifying if the string is
15 //! UTF-8 encoded.
16 class userstring : public std::string
17 {
18 public:
19   //! A vector of userstrings
20   typedef std::vector<userstring> vector;
21   
22 private:
23   bool _utf8;
24
25 public:
26   userstring(bool utf8) : std::string(), _utf8(utf8) {}
27   userstring(const userstring& s, size_type pos = 0,
28              size_type n = npos) : std::string(s, pos, n), _utf8(s._utf8) {}
29   userstring(const char *s, bool utf8) : std::string(s), _utf8(utf8) {}
30   userstring(const char *s, size_type n, bool utf8) : std::string(s, n),
31                                                       _utf8(utf8) {}
32   userstring(size_type n, char c, bool utf8) : std::string(n, c),
33                                                _utf8(utf8) {}
34   userstring(const_iterator first, const_iterator last, bool utf8) :
35     std::string(first, last), _utf8(utf8) {}
36
37   //! Returns if the string is encoded in UTF-8 or not
38   inline bool utf8() const { return _utf8; }
39
40   inline void setUtf8(bool u) { _utf8 = u; }
41
42   inline userstring& insert(size_type pos, const userstring& s) {
43     assert(s._utf8 == _utf8);
44     std::string::insert(pos, s);
45     return *this;
46   }
47
48   inline userstring& insert(size_type pos,
49                             const userstring& s,
50                             size_type pos1, size_type n) {
51     assert(s._utf8 == _utf8);
52     std::string::insert(pos, s, pos1, n);
53     return *this;
54   }
55
56   inline userstring& append(const userstring& s) {
57     assert(s._utf8 == _utf8);
58     std::string::append(s);
59     return *this;
60   }
61
62   inline userstring& append(const userstring& s,
63                             size_type pos, size_type n) {
64     assert(s._utf8 == _utf8);
65     std::string::append(s, pos, n);
66     return *this;
67   }
68
69   inline userstring& assign(const userstring& s) {
70     assert(s._utf8 == _utf8);
71     std::string::assign(s);
72     return *this;
73   }
74   
75   inline userstring& assign(const userstring& s,
76                             size_type pos, size_type n) {
77     assert(s._utf8 == _utf8);
78     std::string::assign(s, pos, n);
79     return *this;
80   }
81
82   inline userstring& replace(size_type pos, size_type n,
83                              const userstring& s) {
84     assert(s._utf8 == _utf8);
85     std::string::replace(pos, n, s);
86     return *this;
87   }
88
89   inline userstring& replace(size_type pos, size_type n,
90                              const userstring& s,
91                              size_type pos1, size_type n1) {
92     assert(s._utf8 == _utf8);
93     std::string::replace(pos, n, s, pos1, n1);
94     return *this;
95   }
96
97   inline userstring& operator=(const userstring& s) {
98     return assign(s);
99   }
100   
101   inline userstring& operator+=(const userstring& s) {
102     return append(s);
103   }
104 };
105
106 }
107
108 #endif // __userstring_hh