Modified code to remove compiler warnings.
[dyninst.git] / common / h / String.h
1 /************************************************************************
2  * String.h: a simple character string class.
3 ************************************************************************/
4
5
6 \f
7
8
9 #if !defined(_String_h_)
10 #define _String_h_
11
12
13 \f
14
15
16 /************************************************************************
17  * header files.
18 ************************************************************************/
19
20 #include <iostream.h>
21 #include "util/h/headers.h"
22
23 \f
24
25
26 /************************************************************************
27  * class string
28 ************************************************************************/
29
30 class string {
31 public:
32      string ();
33      string (const char *);
34      string (const string &);
35     ~string ();
36
37     string&       operator= (const char *);
38     string&       operator= (const string &);
39     string&      operator+= (const string &);
40     string        operator+ (const string &)         const;
41
42     bool         operator== (const string &)         const;
43     bool         operator!= (const string &)         const;
44     bool          operator< (const string &)         const;
45     bool         operator<= (const string &)         const;
46     bool          operator> (const string &)         const;
47     bool         operator>= (const string &)         const;
48
49     bool          prefix_of (const char *, unsigned) const;
50     bool          prefix_of (const char *)           const;
51     bool          prefix_of (const string &)         const;
52
53     bool        prefixed_by (const char *, unsigned) const;
54     bool        prefixed_by (const char *)           const;
55     bool        prefixed_by (const string &)         const;
56
57     const char*   string_of ()                       const;
58     unsigned         length ()                       const;
59
60     friend ostream& operator<< (ostream &os, const string &s) {
61       return os << s.str_;
62     }
63
64     static unsigned       hash (const string &);
65
66 private:
67     static unsigned      hashs (const char *);
68
69     static unsigned     STRLEN (const char *);
70     static char*        STRDUP (const char *);
71
72     static bool          STREQ (const char *, const char *);
73     static bool         STREQN (const char *, const char *, unsigned);
74     static bool          STRNE (const char *, const char *);
75     static bool          STRLT (const char *, const char *);
76     static bool          STRLE (const char *, const char *);
77     static bool          STRGT (const char *, const char *);
78     static bool          STRGE (const char *, const char *);
79
80     char*    str_;
81     unsigned len_;
82     unsigned key_;
83 };
84
85 inline
86 string::string()
87     : str_(0), len_(0), key_(0) {
88 }
89
90 inline
91 string::string(const char* str)
92     : str_(STRDUP(str)), len_(STRLEN(str)), key_(hashs(str)) {
93 }
94
95 inline
96 string::string(const string& s)
97     : str_(STRDUP(s.str_)), len_(s.len_), key_(s.key_) {
98 }
99
100 inline
101 string::~string() {
102     delete str_; str_ = 0;
103 }
104
105 inline
106 string&
107 string::operator=(const char* str) {
108     if (str_ == str) {
109         return *this;
110     }
111
112     delete str_; str_ = 0;
113
114     str_ = STRDUP(str);
115     len_ = STRLEN(str);
116     key_ = hashs(str);
117
118     return *this;
119 }
120
121 inline
122 string&
123 string::operator=(const string& s) {
124     if (this == &s) {
125         return *this;
126     }
127
128     delete str_; str_ = 0;
129
130     str_ = STRDUP(s.str_);
131     len_ = s.len_;
132     key_ = s.key_;
133
134     return *this;
135 }
136
137 inline
138 string&
139 string::operator+=(const string& s) {
140     unsigned nlen = len_ + s.len_;
141     char*    ptr  = new char[nlen+1];
142
143     memcpy(ptr, str_, len_);
144     memcpy(&ptr[len_], s.str_, s.len_);
145     ptr[nlen] = '\0';
146
147     delete[] str_; str_ = 0;
148     str_ = ptr;
149     len_ = nlen;
150     key_ = hashs(str_);
151
152     return *this;
153 }
154
155 inline
156 string
157 string::operator+(const string& s) const {
158     string ret = *this;
159     return ret += s;
160 }
161
162 inline
163 bool
164 string::operator==(const string& s) const {
165     return ((&s == this)
166         || ((key_ == s.key_)
167         && (len_ == s.len_)
168         && STREQ(str_, s.str_)));
169 }
170
171 inline
172 bool
173 string::operator!=(const string& s) const {
174     return ((!(&s == this)) && (len_ != s.len_)
175         || STRNE(str_, s.str_));
176 }
177
178 inline
179 bool
180 string::operator<(const string& s) const {
181     return STRLT(str_, s.str_);
182 }
183
184 inline
185 bool
186 string::operator<=(const string& s) const {
187     return ((&s == this) || STRLE(str_, s.str_));
188 }
189
190 inline
191 bool
192 string::operator>(const string& s) const {
193     return STRGT(str_, s.str_);
194 }
195
196 inline
197 bool
198 string::operator>=(const string& s) const {
199     return ((&s == this) || STRGE(str_, s.str_));
200 }
201
202 inline
203 bool
204 string::prefix_of(const char* s, unsigned sl) const {
205     return ((len_ > sl) ? false : STREQN(str_, s, len_));
206 }
207
208 inline
209 bool
210 string::prefix_of(const char* s) const {
211     return prefix_of(s, STRLEN(s));
212 }
213
214 inline
215 bool
216 string::prefix_of(const string& s) const {
217     return ((&s == this) || prefix_of(s.str_, s.len_));
218 }
219
220 inline
221 bool
222 string::prefixed_by(const char* s, unsigned sl) const {
223     return ((sl > len_) ? false : STREQN(str_, s, sl));
224 }
225
226 inline
227 bool
228 string::prefixed_by(const char* s) const {
229     return prefixed_by(s, STRLEN(s));
230 }
231
232 inline
233 bool
234 string::prefixed_by(const string& s) const {
235     return ((&s == this) || prefixed_by(s.str_, s.len_));
236 }
237
238 inline
239 unsigned
240 string::length() const {
241     return len_;
242 }
243
244 inline
245 const char*
246 string::string_of() const {
247     return str_;
248 }
249
250 inline
251 unsigned
252 string::hash(const string& s) {
253     return s.key_;
254 }
255
256 inline
257 unsigned
258 string::hashs(const char* str) {
259     if (!str) {
260         return 0;
261     }
262
263     unsigned h = 5381;
264     while (*str) {
265         h = (h << 5) + h + (unsigned) (*str);
266         str++;
267     }
268     return h;
269 }
270
271 inline
272 unsigned
273 string::STRLEN(const char* str) {
274     return ((str)?(P_strlen(str)):(0));
275 }
276
277 inline
278 char*
279 string::STRDUP(const char* str) {
280     if (!str) {
281         return 0;
282     }
283
284     unsigned size = P_strlen(str)+1;
285     char*    p    = new char[size];
286
287     (void) P_memcpy(p, str, size);
288     return p;
289 }
290
291 inline
292 bool
293 string::STREQ(const char* s1, const char* s2) {
294     return ((s1&&s2)?(P_strcmp(s1,s2)==0):(!(s1||s2)));
295 }
296
297 inline
298 bool
299 string::STREQN(const char* s1, const char* s2, unsigned len) {
300     return ((s1&&s2)?(P_strncmp(s1,s2,len)==0):(!(s1||s2)));
301 }
302
303 inline
304 bool
305 string::STRNE(const char* s1, const char* s2) {
306     return ((s1&&s2)?(P_strcmp(s1,s2)!=0):(false));
307 }
308
309 inline
310 bool
311 string::STRLT(const char* s1, const char* s2) {
312     return ((s1&&s2)?(P_strcmp(s1,s2)<0):(false));
313 }
314
315 inline
316 bool
317 string::STRLE(const char* s1, const char* s2) {
318     return ((s1&&s2)?(P_strcmp(s1,s2)<=0):(!(s1||s2)));
319 }
320
321 inline
322 bool
323 string::STRGT(const char* s1, const char* s2) {
324     return ((s1&&s2)?(P_strcmp(s1,s2)>0):(false));
325 }
326
327 inline
328 bool
329 string::STRGE(const char* s1, const char* s2) {
330     return ((s1&&s2)?(P_strcmp(s1,s2)>=0):(!(s1||s2)));
331 }
332
333
334 \f
335
336
337 #endif /* !defined(_String_h_) */