all repos — openbox @ eb752bc9c559a1242f22f702dbf67cf6c56a8665

openbox fork - make it a bit more like ryudo

otk/userstring.hh (raw)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
#ifndef   __userstring_hh
#define   __userstring_hh

#include <string>
#include <vector>

extern "C" {
#include <assert.h>
}

namespace otk {

//! userstring is a std::string with an extra flag specifying if the string is
//! UTF-8 encoded.
class userstring : public std::string
{
public:
  //! A vector of userstrings
  typedef std::vector<userstring> vector;
  
private:
  bool _utf8;

public:
  userstring(bool utf8) : std::string(), _utf8(utf8) {}
  userstring(const userstring& s, size_type pos = 0,
	     size_type n = npos) : std::string(s, pos, n), _utf8(s._utf8) {}
  userstring(const char *s, bool utf8) : std::string(s), _utf8(utf8) {}
  userstring(const char *s, size_type n, bool utf8) : std::string(s, n),
						      _utf8(utf8) {}
  userstring(size_type n, char c, bool utf8) : std::string(n, c),
					       _utf8(utf8) {}
  userstring(const_iterator first, const_iterator last, bool utf8) :
    std::string(first, last), _utf8(utf8) {}

  //! Returns if the string is encoded in UTF-8 or not
  inline bool utf8() const { return _utf8; }

  inline void setUtf8(bool u) { _utf8 = u; }

  inline userstring& insert(size_type pos, const userstring& s) {
    assert(s._utf8 == _utf8);
    std::string::insert(pos, s);
    return *this;
  }

  inline userstring& insert(size_type pos,
			    const userstring& s,
			    size_type pos1, size_type n) {
    assert(s._utf8 == _utf8);
    std::string::insert(pos, s, pos1, n);
    return *this;
  }

  inline userstring& append(const userstring& s) {
    assert(s._utf8 == _utf8);
    std::string::append(s);
    return *this;
  }

  inline userstring& append(const userstring& s,
			    size_type pos, size_type n) {
    assert(s._utf8 == _utf8);
    std::string::append(s, pos, n);
    return *this;
  }

  inline userstring& assign(const userstring& s) {
    assert(s._utf8 == _utf8);
    std::string::assign(s);
    return *this;
  }
  
  inline userstring& assign(const userstring& s,
			    size_type pos, size_type n) {
    assert(s._utf8 == _utf8);
    std::string::assign(s, pos, n);
    return *this;
  }

  inline userstring& replace(size_type pos, size_type n,
			     const userstring& s) {
    assert(s._utf8 == _utf8);
    std::string::replace(pos, n, s);
    return *this;
  }

  inline userstring& replace(size_type pos, size_type n,
			     const userstring& s,
			     size_type pos1, size_type n1) {
    assert(s._utf8 == _utf8);
    std::string::replace(pos, n, s, pos1, n1);
    return *this;
  }

  inline userstring& operator=(const userstring& s) {
    return assign(s);
  }
  
  inline userstring& operator+=(const userstring& s) {
    return append(s);
  }
};

}

#endif // __userstring_hh