merged: Platinum from linuxport branches
[xbmc:xbmc-antiquated.git] / xbmc / lib / libUPnP / Platinum / ThirdParty / Neptune / Source / Core / NptStrings.h
1 /*****************************************************************\r
2 |\r
3 |   Neptune - String Objects\r
4 |\r
5 |   (c) 2001-2003 Gilles Boccon-Gibod\r
6 |   Author: Gilles Boccon-Gibod (bok@bok.net)\r
7 |\r
8  ****************************************************************/\r
9 \r
10 #ifndef _NPT_STRINGS_H_\r
11 #define _NPT_STRINGS_H_\r
12 \r
13 /*----------------------------------------------------------------------\r
14 |   includes\r
15 +---------------------------------------------------------------------*/\r
16 #include "NptConfig.h"\r
17 #if defined(NPT_CONFIG_HAVE_NEW_H)\r
18 #include <new>\r
19 #endif\r
20 #include "NptTypes.h"\r
21 #include "NptConstants.h"\r
22 #include "NptList.h"\r
23 #include "NptDebug.h"\r
24 \r
25 /*----------------------------------------------------------------------\r
26 |   constants\r
27 +---------------------------------------------------------------------*/\r
28 const int NPT_STRING_SEARCH_FAILED = -1;\r
29 \r
30 /*----------------------------------------------------------------------\r
31 |   NPT_String\r
32 +---------------------------------------------------------------------*/\r
33 class NPT_String\r
34 {\r
35 public:\r
36     // factories\r
37     static NPT_String FromInteger(NPT_Int64 value);\r
38     static NPT_String FromIntegerU(NPT_UInt64 value);\r
39 \r
40     // constructors\r
41     NPT_String(const NPT_String& str);\r
42     NPT_String(const char* str);\r
43     NPT_String(const char* str, NPT_Size length);\r
44     NPT_String(const char* str, NPT_Ordinal first, NPT_Size length);\r
45     NPT_String(char c, NPT_Cardinal repeat = 1);\r
46     NPT_String() : m_Chars(NULL) {}\r
47    ~NPT_String() { if (m_Chars) delete GetBuffer(); }\r
48 \r
49     // string info and manipulations\r
50     bool       IsEmpty() const { return m_Chars == NULL || GetBuffer()->GetLength() == 0; }\r
51     NPT_Size   GetLength()   const { return m_Chars ? GetBuffer()->GetLength() : 0;    }\r
52     NPT_Size   GetCapacity() const { return m_Chars ? GetBuffer()->GetAllocated() : 0; }\r
53     NPT_Result SetLength(NPT_Size length);\r
54     void       Assign(const char* chars, NPT_Size size);\r
55     void       Append(const char* chars, NPT_Size size);\r
56     void       Append(const char* s) { Append(s, StringLength(s)); }\r
57     int        Compare(const char* s, bool ignore_case = false) const;\r
58     static int Compare(const char* s1, const char* s2, bool ignore_case = false);\r
59     int        CompareN(const char* s, NPT_Size count, bool ignore_case = false) const;\r
60     static int CompareN(const char* s1, const char* s2, NPT_Size count, bool ignore_case = false);\r
61 \r
62     // substrings\r
63     NPT_String SubString(NPT_Ordinal first, NPT_Size length) const;\r
64     NPT_String SubString(NPT_Ordinal first) const {\r
65         return SubString(first, GetLength());\r
66     }\r
67     NPT_String Left(NPT_Size length) const {\r
68         return SubString(0, length);\r
69     }\r
70     NPT_String Right(NPT_Size length) const {\r
71         return length >= GetLength() ? \r
72                *this : \r
73                SubString(GetLength()-length, length);\r
74     }\r
75     NPT_List<NPT_String> Split(const char* separator) const;\r
76     \r
77     // buffer management\r
78     void       Reserve(NPT_Size length);\r
79 \r
80     // conversions\r
81     NPT_String ToLowercase() const;\r
82     NPT_String ToUppercase() const;\r
83     NPT_Result ToInteger(long& value, bool relaxed = true) const;\r
84     NPT_Result ToInteger(unsigned long& value, bool relaxed = true) const;\r
85     NPT_Result ToInteger(NPT_UInt64& value, bool relaxed = true) const;\r
86     NPT_Result ToFloat(float& value, bool relaxed = true) const;\r
87     \r
88     // processing\r
89     void MakeLowercase();\r
90     void MakeUppercase();\r
91     void Replace(char a, char b);\r
92 \r
93     // search\r
94     int  Find(char c, NPT_Ordinal start = 0, bool ignore_case = false) const;\r
95     int  Find(const char* s, NPT_Ordinal start = 0, bool ignore_case = false) const;\r
96     int  ReverseFind(char c, NPT_Ordinal start = 0, bool ignore_case = false) const;\r
97     int  ReverseFind(const char* s, NPT_Ordinal start = 0, bool ignore_case = false) const;\r
98     bool StartsWith(const char* s, bool ignore_case = false) const;\r
99     bool EndsWith(const char* s, bool ignore_case = false) const;\r
100 \r
101     // editing\r
102     void Insert(const char* s, NPT_Ordinal where = 0);\r
103     void Erase(NPT_Ordinal start, NPT_Cardinal count = 1);\r
104     void Replace(NPT_Ordinal start, NPT_Cardinal count, const char* s);\r
105     void TrimLeft();\r
106     void TrimLeft(char c);\r
107     void TrimLeft(const char* chars);\r
108     void TrimRight();\r
109     void TrimRight(char c);\r
110     void TrimRight(const char* chars);\r
111     void Trim();\r
112     void Trim(char c);\r
113     void Trim(const char* chars);\r
114 \r
115     // type casting\r
116     operator char*() const        { return m_Chars ? m_Chars: &EmptyString; }\r
117     operator const char* () const { return m_Chars ? m_Chars: &EmptyString; }\r
118     const char* GetChars() const  { return m_Chars ? m_Chars: &EmptyString; }\r
119     char*       UseChars()        { return m_Chars ? m_Chars: &EmptyString; }\r
120 \r
121     // operator overloading\r
122     NPT_String& operator=(const char* str);\r
123     NPT_String& operator=(const NPT_String& str);\r
124     NPT_String& operator=(char c);\r
125     const NPT_String& operator+=(const NPT_String& s) {\r
126         Append(s.GetChars(), s.GetLength());\r
127         return *this;\r
128     }\r
129     const NPT_String& operator+=(const char* s) {\r
130         Append(s);\r
131         return *this;\r
132     }\r
133     const NPT_String& operator+=(char c) {\r
134         Append(&c, 1);\r
135         return *this;\r
136     }\r
137     char operator[](int index) const {\r
138         NPT_ASSERT((unsigned int)index < GetLength());\r
139         return GetChars()[index];\r
140     }\r
141     char& operator[](int index) {\r
142         NPT_ASSERT((unsigned int)index < GetLength());\r
143         return UseChars()[index];\r
144     }\r
145 \r
146     // friend operators\r
147     friend NPT_String operator+(const NPT_String& s1, const NPT_String& s2) {\r
148         return s1+s2.GetChars();\r
149     }\r
150     friend NPT_String operator+(const NPT_String& s1, const char* s2);\r
151     friend NPT_String operator+(const char* s1, const NPT_String& s2);\r
152     friend NPT_String operator+(const NPT_String& s, char c);\r
153     friend NPT_String operator+(char c, const NPT_String& s);\r
154 \r
155 protected:\r
156     // inner classes\r
157     class Buffer {\r
158     public:\r
159         // class methods\r
160         static Buffer* Allocate(NPT_Size allocated, NPT_Size length) {\r
161             void* mem = ::operator new(sizeof(Buffer)+allocated+1);\r
162             return new(mem) Buffer(allocated, length);\r
163         }\r
164         static char* Create(NPT_Size allocated, NPT_Size length=0) {\r
165             Buffer* shared = Allocate(allocated, length);\r
166             return shared->GetChars();\r
167         }\r
168         static char* Create(const char* copy) {\r
169             NPT_Size length = StringLength(copy);\r
170             Buffer* shared = Allocate(length, length);\r
171             CopyString(shared->GetChars(), copy);\r
172             return shared->GetChars();\r
173         }\r
174         static char* Create(const char* copy, NPT_Size length) {\r
175             Buffer* shared = Allocate(length, length);\r
176             CopyBuffer(shared->GetChars(), copy, length);\r
177             shared->GetChars()[length] = '\0';\r
178             return shared->GetChars();\r
179         }\r
180         static char* Create(char c, NPT_Cardinal repeat) {\r
181             Buffer* shared = Allocate(repeat, repeat);\r
182             char* s = shared->GetChars();\r
183             while (repeat--) {\r
184                 *s++ = c;\r
185             }\r
186             *s = '\0';\r
187             return shared->GetChars();\r
188         }\r
189 \r
190         // methods\r
191         char* GetChars() { \r
192             // return a pointer to the first char\r
193             return reinterpret_cast<char*>(this+1); \r
194         }\r
195         NPT_Size GetLength() const      { return m_Length; }\r
196         void SetLength(NPT_Size length) { m_Length = length; }\r
197         NPT_Size GetAllocated() const   { return m_Allocated; }\r
198 \r
199     private:\r
200         // methods\r
201         Buffer(NPT_Size allocated, NPT_Size length = 0) : \r
202             m_Length(length),\r
203             m_Allocated(allocated) {}\r
204 \r
205         // members\r
206         NPT_Cardinal m_Length;\r
207         NPT_Cardinal m_Allocated;\r
208         // the actual string data follows\r
209 \r
210     };\r
211     \r
212     // members\r
213     char* m_Chars;\r
214 \r
215 private:\r
216     // friends\r
217     friend class Buffer;\r
218 \r
219     // static members\r
220     static char EmptyString;\r
221 \r
222     // methods\r
223     Buffer* GetBuffer() const { \r
224         return reinterpret_cast<Buffer*>(m_Chars)-1;\r
225     }\r
226     void Reset() { \r
227         if (m_Chars != NULL) {\r
228             delete GetBuffer(); \r
229             m_Chars = NULL;\r
230         }\r
231     }\r
232     char* PrepareToWrite(NPT_Size length);\r
233     void PrepareToAppend(NPT_Size length, NPT_Size allocate);\r
234 \r
235     // static methods\r
236     static void CopyString(char* dst, const char* src) {\r
237         while ((*dst++ = *src++)){}\r
238     }\r
239     \r
240     static void CopyBuffer(char* dst, const char* src, NPT_Size size) {\r
241         while (size--) *dst++ = *src++;\r
242     }\r
243     \r
244     static NPT_Size StringLength(const char* str) {\r
245         NPT_Size length = 0;\r
246         while (*str++) length++;\r
247         return length;\r
248     }\r
249 };\r
250 \r
251 /*----------------------------------------------------------------------\r
252 |   external operators\r
253 +---------------------------------------------------------------------*/\r
254 inline bool operator==(const NPT_String& s1, const NPT_String& s2) { \r
255     return s1.Compare(s2) == 0; \r
256 }\r
257 inline bool operator==(const NPT_String& s1, const char* s2) {\r
258     return s1.Compare(s2) == 0; \r
259 }\r
260 inline bool operator==(const char* s1, const NPT_String& s2) {\r
261     return s2.Compare(s1) == 0; \r
262 }\r
263 inline bool operator!=(const NPT_String& s1, const NPT_String& s2) {\r
264     return s1.Compare(s2) != 0; \r
265 }\r
266 inline bool operator!=(const NPT_String& s1, const char* s2) {\r
267     return s1.Compare(s2) != 0; \r
268 }\r
269 inline bool operator!=(const char* s1, const NPT_String& s2) {\r
270     return s2.Compare(s1) != 0; \r
271 }\r
272 inline bool operator<(const NPT_String& s1, const NPT_String& s2) {\r
273     return s1.Compare(s2) < 0; \r
274 }\r
275 inline bool operator<(const NPT_String& s1, const char* s2) {\r
276     return s1.Compare(s2) < 0; \r
277 }\r
278 inline bool operator<(const char* s1, const NPT_String& s2) {\r
279     return s2.Compare(s1) > 0; \r
280 }\r
281 inline bool operator>(const NPT_String& s1, const NPT_String& s2) {\r
282     return s1.Compare(s2) > 0; \r
283 }\r
284 inline bool operator>(const NPT_String& s1, const char* s2) {\r
285     return s1.Compare(s2) > 0; \r
286 }\r
287 inline bool operator>(const char* s1, const NPT_String& s2) {\r
288     return s2.Compare(s1) < 0; \r
289 }\r
290 inline bool operator<=(const NPT_String& s1, const NPT_String& s2) {\r
291     return s1.Compare(s2) <= 0; \r
292 }\r
293 inline bool operator<=(const NPT_String& s1, const char* s2) {\r
294     return s1.Compare(s2) <= 0; \r
295 }\r
296 inline bool operator<=(const char* s1, const NPT_String& s2) {\r
297     return s2.Compare(s1) >= 0; \r
298 }\r
299 inline bool operator>=(const NPT_String& s1, const NPT_String& s2) {\r
300     return s1.Compare(s2) >= 0; \r
301 }\r
302 inline bool operator>=(const NPT_String& s1, const char* s2) {\r
303     return s1.Compare(s2) >= 0; \r
304 }\r
305 inline bool operator>=(const char* s1, const NPT_String& s2) {\r
306     return s2.Compare(s1) <= 0; \r
307 }\r
308 \r
309 #endif // _NPT_STRINGS_H_\r