kodi
NptStrings.h
1 /*****************************************************************
2 |
3 | Neptune - String Objects
4 |
5 | Copyright (c) 2002-2008, Axiomatic Systems, LLC.
6 | All rights reserved.
7 |
8 | Redistribution and use in source and binary forms, with or without
9 | modification, are permitted provided that the following conditions are met:
10 | * Redistributions of source code must retain the above copyright
11 | notice, this list of conditions and the following disclaimer.
12 | * Redistributions in binary form must reproduce the above copyright
13 | notice, this list of conditions and the following disclaimer in the
14 | documentation and/or other materials provided with the distribution.
15 | * Neither the name of Axiomatic Systems nor the
16 | names of its contributors may be used to endorse or promote products
17 | derived from this software without specific prior written permission.
18 |
19 | THIS SOFTWARE IS PROVIDED BY AXIOMATIC SYSTEMS ''AS IS'' AND ANY
20 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 | DISCLAIMED. IN NO EVENT SHALL AXIOMATIC SYSTEMS BE LIABLE FOR ANY
23 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 |
30  ****************************************************************/
31 
32 #ifndef _NPT_STRINGS_H_
33 #define _NPT_STRINGS_H_
34 
35 /*----------------------------------------------------------------------
36 | includes
37 +---------------------------------------------------------------------*/
38 #include "NptConfig.h"
39 #if defined(NPT_CONFIG_HAVE_NEW_H)
40 #include <new>
41 #endif
42 #include "NptTypes.h"
43 #include "NptConstants.h"
44 #include "NptList.h"
45 #include "NptArray.h"
46 #include "NptDebug.h"
47 #include "NptHash.h"
48 
49 /*----------------------------------------------------------------------
50 | constants
51 +---------------------------------------------------------------------*/
52 const int NPT_STRING_SEARCH_FAILED = -1;
53 
54 /*----------------------------------------------------------------------
55 | NPT_String
56 +---------------------------------------------------------------------*/
57 class NPT_String
58 {
59 public:
60  // factories
61  static NPT_String FromInteger(NPT_Int64 value);
62  static NPT_String FromIntegerU(NPT_UInt64 value);
63  static NPT_String Format(const char* format, ...);
64 
65  // constructors
66  NPT_String(const NPT_String& str);
67  NPT_String(const char* str);
68  NPT_String(const char* str, NPT_Size length);
69  NPT_String(char c, NPT_Cardinal repeat = 1);
70  NPT_String() : m_Chars(NULL) {}
71  ~NPT_String() { if (m_Chars) GetBuffer()->Destroy(); }
72 
73  // string info and manipulations
74  bool IsEmpty() const { return m_Chars == NULL || GetBuffer()->GetLength() == 0; }
75  NPT_Size GetLength() const { return m_Chars ? GetBuffer()->GetLength() : 0; }
76  NPT_Size GetCapacity() const { return m_Chars ? GetBuffer()->GetAllocated() : 0; }
77  NPT_Result SetLength(NPT_Size length, bool pad = false);
78  void Assign(const char* chars, NPT_Size size);
79  void Append(const char* chars, NPT_Size size);
80  void Append(const char* s) { Append(s, StringLength(s)); }
81  int Compare(const char* s, bool ignore_case = false) const;
82  static int Compare(const char* s1, const char* s2, bool ignore_case = false);
83  int CompareN(const char* s, NPT_Size count, bool ignore_case = false) const;
84  static int CompareN(const char* s1, const char* s2, NPT_Size count, bool ignore_case = false);
85 
86  // substrings
87  NPT_String SubString(NPT_Ordinal first, NPT_Size length) const;
88  NPT_String SubString(NPT_Ordinal first) const {
89  return SubString(first, GetLength());
90  }
91  NPT_String Left(NPT_Size length) const {
92  return SubString(0, length);
93  }
94  NPT_String Right(NPT_Size length) const {
95  return length >= GetLength() ?
96  *this :
97  SubString(GetLength()-length, length);
98  }
99  NPT_List<NPT_String> Split(const char* separator) const;
100  NPT_Array<NPT_String> SplitAny(const char* separator) const;
101  static NPT_String Join(NPT_List<NPT_String>& args, const char* separator);
102 
103  // buffer management
104  void Reserve(NPT_Size length);
105 
106  // hashing
107  NPT_UInt32 GetHash32() const;
108  NPT_UInt64 GetHash64() const;
109 
110  // conversions
111  NPT_String ToLowercase() const;
112  NPT_String ToUppercase() const;
113  NPT_Result ToInteger(int& value, bool relaxed = true) const;
114  NPT_Result ToInteger(unsigned int& value, bool relaxed = true) const;
115  NPT_Result ToInteger(long& value, bool relaxed = true) const;
116  NPT_Result ToInteger(unsigned long& value, bool relaxed = true) const;
117  NPT_Result ToInteger32(NPT_Int32& value, bool relaxed = true) const;
118  NPT_Result ToInteger32(NPT_UInt32& value, bool relaxed = true) const;
119  NPT_Result ToInteger64(NPT_Int64& value, bool relaxed = true) const;
120  NPT_Result ToInteger64(NPT_UInt64& value, bool relaxed = true) const;
121  NPT_Result ToFloat(float& value, bool relaxed = true) const;
122 
123  // processing
124  void MakeLowercase();
125  void MakeUppercase();
126  const NPT_String& Replace(char a, char b);
127  const NPT_String& Replace(char a, const char* b);
128 
129  // search
130  int Find(char c, NPT_Ordinal start = 0, bool ignore_case = false) const;
131  int Find(const char* s, NPT_Ordinal start = 0, bool ignore_case = false) const;
132  int FindAny(const char* s, NPT_Ordinal start, bool ignore_case = false) const;
133  int ReverseFind(char c, NPT_Ordinal start = 0, bool ignore_case = false) const;
134  int ReverseFind(const char* s, NPT_Ordinal start = 0, bool ignore_case = false) const;
135  bool StartsWith(const char* s, bool ignore_case = false) const;
136  bool EndsWith(const char* s, bool ignore_case = false) const;
137 
138  // editing
139  const NPT_String& Insert(const char* s, NPT_Ordinal where = 0);
140  const NPT_String& Erase(NPT_Ordinal start, NPT_Cardinal count = 1);
141  const NPT_String& Replace(const char* before, const char* after);
142  // void Replace(NPT_Ordinal start, NPT_Cardinal count, const char* s);
143  const NPT_String& TrimLeft();
144  const NPT_String& TrimLeft(char c);
145  const NPT_String& TrimLeft(const char* chars);
146  const NPT_String& TrimRight();
147  const NPT_String& TrimRight(char c);
148  const NPT_String& TrimRight(const char* chars);
149  const NPT_String& Trim();
150  const NPT_String& Trim(char c);
151  const NPT_String& Trim(const char* chars);
152 
153  // type casting
154  operator char*() const { return m_Chars ? m_Chars: &EmptyString; }
155  operator const char* () const { return m_Chars ? m_Chars: &EmptyString; }
156  const char* GetChars() const { return m_Chars ? m_Chars: &EmptyString; }
157  char* UseChars() { return m_Chars ? m_Chars: &EmptyString; }
158 
159  // operator overloading
160  NPT_String& operator=(const char* str);
161  NPT_String& operator=(const NPT_String& str);
162  NPT_String& operator=(char c);
163  const NPT_String& operator+=(const NPT_String& s) {
164  Append(s.GetChars(), s.GetLength());
165  return *this;
166  }
167  const NPT_String& operator+=(const char* s) {
168  Append(s);
169  return *this;
170  }
171  const NPT_String& operator+=(char c) {
172  Append(&c, 1);
173  return *this;
174  }
175  char operator[](int index) const {
176  NPT_ASSERT((unsigned int)index < GetLength());
177  return GetChars()[index];
178  }
179  char& operator[](int index) {
180  NPT_ASSERT((unsigned int)index < GetLength());
181  return UseChars()[index];
182  }
183 
184  // friend operators
185  friend NPT_String operator+(const NPT_String& s1, const NPT_String& s2) {
186  return s1+s2.GetChars();
187  }
188  friend NPT_String operator+(const NPT_String& s1, const char* s2);
189  friend NPT_String operator+(const char* s1, const NPT_String& s2);
190  friend NPT_String operator+(const NPT_String& s, char c);
191  friend NPT_String operator+(char c, const NPT_String& s);
192 
193 protected:
194  // inner classes
195  class Buffer {
196  public:
197  // class methods
198  static Buffer* Allocate(NPT_Size allocated, NPT_Size length) {
199  void* mem = ::operator new(sizeof(Buffer)+allocated+1);
200  return new(mem) Buffer(allocated, length);
201  }
202  static char* Create(NPT_Size allocated, NPT_Size length=0) {
203  Buffer* shared = Allocate(allocated, length);
204  return shared->GetChars();
205  }
206  static char* Create(const char* copy) {
207  NPT_Size length = StringLength(copy);
208  Buffer* shared = Allocate(length, length);
209  CopyString(shared->GetChars(), copy);
210  return shared->GetChars();
211  }
212  static char* Create(const char* copy, NPT_Size length) {
213  Buffer* shared = Allocate(length, length);
214  CopyBuffer(shared->GetChars(), copy, length);
215  shared->GetChars()[length] = '\0';
216  return shared->GetChars();
217  }
218  static char* Create(char c, NPT_Cardinal repeat) {
219  Buffer* shared = Allocate(repeat, repeat);
220  char* s = shared->GetChars();
221  while (repeat--) {
222  *s++ = c;
223  }
224  *s = '\0';
225  return shared->GetChars();
226  }
227 
228  // methods
229  char* GetChars() {
230  // return a pointer to the first char
231  return reinterpret_cast<char*>(this+1);
232  }
233  NPT_Size GetLength() const { return m_Length; }
234  void SetLength(NPT_Size length) { m_Length = length; }
235  NPT_Size GetAllocated() const { return m_Allocated; }
236  void Destroy() { ::operator delete((void*)this); }
237 
238  private:
239  // methods
240  Buffer(NPT_Size allocated, NPT_Size length = 0) :
241  m_Length(length),
242  m_Allocated(allocated) {}
243 
244  // members
245  NPT_Cardinal m_Length;
246  NPT_Cardinal m_Allocated;
247  // the actual string data follows
248 
249  };
250 
251  // members
252  char* m_Chars;
253 
254 private:
255  // friends
256  friend class Buffer;
257 
258  // static members
259  static char EmptyString;
260 
261  // methods
262  Buffer* GetBuffer() const {
263  return reinterpret_cast<Buffer*>(m_Chars)-1;
264  }
265  void Reset() {
266  if (m_Chars != NULL) {
267  delete GetBuffer();
268  m_Chars = NULL;
269  }
270  }
271  char* PrepareToWrite(NPT_Size length);
272  void PrepareToAppend(NPT_Size length, NPT_Size allocate);
273 
274  // static methods
275  static void CopyString(char* dst, const char* src) {
276  while ((*dst++ = *src++)){}
277  }
278 
279  static void CopyBuffer(char* dst, const char* src, NPT_Size size) {
280  while (size--) *dst++ = *src++;
281  }
282 
283  static NPT_Size StringLength(const char* str) {
284  NPT_Size length = 0;
285  while (*str++) length++;
286  return length;
287  }
288 };
289 
290 /*----------------------------------------------------------------------
291 | external operators
292 +---------------------------------------------------------------------*/
293 inline bool operator==(const NPT_String& s1, const NPT_String& s2) {
294  return s1.Compare(s2) == 0;
295 }
296 inline bool operator==(const NPT_String& s1, const char* s2) {
297  return s1.Compare(s2) == 0;
298 }
299 inline bool operator==(const char* s1, const NPT_String& s2) {
300  return s2.Compare(s1) == 0;
301 }
302 inline bool operator!=(const NPT_String& s1, const NPT_String& s2) {
303  return s1.Compare(s2) != 0;
304 }
305 inline bool operator!=(const NPT_String& s1, const char* s2) {
306  return s1.Compare(s2) != 0;
307 }
308 inline bool operator!=(const char* s1, const NPT_String& s2) {
309  return s2.Compare(s1) != 0;
310 }
311 inline bool operator<(const NPT_String& s1, const NPT_String& s2) {
312  return s1.Compare(s2) < 0;
313 }
314 inline bool operator<(const NPT_String& s1, const char* s2) {
315  return s1.Compare(s2) < 0;
316 }
317 inline bool operator<(const char* s1, const NPT_String& s2) {
318  return s2.Compare(s1) > 0;
319 }
320 inline bool operator>(const NPT_String& s1, const NPT_String& s2) {
321  return s1.Compare(s2) > 0;
322 }
323 inline bool operator>(const NPT_String& s1, const char* s2) {
324  return s1.Compare(s2) > 0;
325 }
326 inline bool operator>(const char* s1, const NPT_String& s2) {
327  return s2.Compare(s1) < 0;
328 }
329 inline bool operator<=(const NPT_String& s1, const NPT_String& s2) {
330  return s1.Compare(s2) <= 0;
331 }
332 inline bool operator<=(const NPT_String& s1, const char* s2) {
333  return s1.Compare(s2) <= 0;
334 }
335 inline bool operator<=(const char* s1, const NPT_String& s2) {
336  return s2.Compare(s1) >= 0;
337 }
338 inline bool operator>=(const NPT_String& s1, const NPT_String& s2) {
339  return s1.Compare(s2) >= 0;
340 }
341 inline bool operator>=(const NPT_String& s1, const char* s2) {
342  return s1.Compare(s2) >= 0;
343 }
344 inline bool operator>=(const char* s1, const NPT_String& s2) {
345  return s2.Compare(s1) <= 0;
346 }
347 
348 /*----------------------------------------------------------------------
349 | hashing
350 +---------------------------------------------------------------------*/
351 template <>
352 struct NPT_Hash<NPT_String>
353 {
354  NPT_UInt32 operator()(const NPT_String& s) const { return s.GetHash32(); }
355 };
356 
357 
358 #endif // _NPT_STRINGS_H_
NPT_Hash
Definition: NptHash.h:55
NPT_String::Buffer
Definition: NptStrings.h:195
NPT_Array< NPT_String >
NPT_String
Definition: NptStrings.h:57
NPT_List< NPT_String >
Generated by   doxygen 1.8.13