summaryrefslogtreecommitdiffstats
path: root/lib/libUPnP/Neptune/Source/Core/NptStrings.h
diff options
context:
space:
mode:
Diffstat (limited to 'lib/libUPnP/Neptune/Source/Core/NptStrings.h')
-rw-r--r--lib/libUPnP/Neptune/Source/Core/NptStrings.h358
1 files changed, 358 insertions, 0 deletions
diff --git a/lib/libUPnP/Neptune/Source/Core/NptStrings.h b/lib/libUPnP/Neptune/Source/Core/NptStrings.h
new file mode 100644
index 0000000..c445b33
--- /dev/null
+++ b/lib/libUPnP/Neptune/Source/Core/NptStrings.h
@@ -0,0 +1,358 @@
+/*****************************************************************
+|
+| Neptune - String Objects
+|
+| Copyright (c) 2002-2008, Axiomatic Systems, LLC.
+| All rights reserved.
+|
+| Redistribution and use in source and binary forms, with or without
+| modification, are permitted provided that the following conditions are met:
+| * Redistributions of source code must retain the above copyright
+| notice, this list of conditions and the following disclaimer.
+| * Redistributions in binary form must reproduce the above copyright
+| notice, this list of conditions and the following disclaimer in the
+| documentation and/or other materials provided with the distribution.
+| * Neither the name of Axiomatic Systems nor the
+| names of its contributors may be used to endorse or promote products
+| derived from this software without specific prior written permission.
+|
+| THIS SOFTWARE IS PROVIDED BY AXIOMATIC SYSTEMS ''AS IS'' AND ANY
+| EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+| WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+| DISCLAIMED. IN NO EVENT SHALL AXIOMATIC SYSTEMS BE LIABLE FOR ANY
+| DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+| ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+| SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+|
+ ****************************************************************/
+
+#ifndef _NPT_STRINGS_H_
+#define _NPT_STRINGS_H_
+
+/*----------------------------------------------------------------------
+| includes
++---------------------------------------------------------------------*/
+#include "NptConfig.h"
+#if defined(NPT_CONFIG_HAVE_NEW_H)
+#include <new>
+#endif
+#include "NptTypes.h"
+#include "NptConstants.h"
+#include "NptList.h"
+#include "NptArray.h"
+#include "NptDebug.h"
+#include "NptHash.h"
+
+/*----------------------------------------------------------------------
+| constants
++---------------------------------------------------------------------*/
+const int NPT_STRING_SEARCH_FAILED = -1;
+
+/*----------------------------------------------------------------------
+| NPT_String
++---------------------------------------------------------------------*/
+class NPT_String
+{
+public:
+ // factories
+ static NPT_String FromInteger(NPT_Int64 value);
+ static NPT_String FromIntegerU(NPT_UInt64 value);
+ static NPT_String Format(const char* format, ...);
+
+ // constructors
+ NPT_String(const NPT_String& str);
+ NPT_String(const char* str);
+ NPT_String(const char* str, NPT_Size length);
+ NPT_String(char c, NPT_Cardinal repeat = 1);
+ NPT_String() : m_Chars(NULL) {}
+ ~NPT_String() { if (m_Chars) GetBuffer()->Destroy(); }
+
+ // string info and manipulations
+ bool IsEmpty() const { return m_Chars == NULL || GetBuffer()->GetLength() == 0; }
+ NPT_Size GetLength() const { return m_Chars ? GetBuffer()->GetLength() : 0; }
+ NPT_Size GetCapacity() const { return m_Chars ? GetBuffer()->GetAllocated() : 0; }
+ NPT_Result SetLength(NPT_Size length, bool pad = false);
+ void Assign(const char* chars, NPT_Size size);
+ void Append(const char* chars, NPT_Size size);
+ void Append(const char* s) { Append(s, StringLength(s)); }
+ int Compare(const char* s, bool ignore_case = false) const;
+ static int Compare(const char* s1, const char* s2, bool ignore_case = false);
+ int CompareN(const char* s, NPT_Size count, bool ignore_case = false) const;
+ static int CompareN(const char* s1, const char* s2, NPT_Size count, bool ignore_case = false);
+
+ // substrings
+ NPT_String SubString(NPT_Ordinal first, NPT_Size length) const;
+ NPT_String SubString(NPT_Ordinal first) const {
+ return SubString(first, GetLength());
+ }
+ NPT_String Left(NPT_Size length) const {
+ return SubString(0, length);
+ }
+ NPT_String Right(NPT_Size length) const {
+ return length >= GetLength() ?
+ *this :
+ SubString(GetLength()-length, length);
+ }
+ NPT_List<NPT_String> Split(const char* separator) const;
+ NPT_Array<NPT_String> SplitAny(const char* separator) const;
+ static NPT_String Join(NPT_List<NPT_String>& args, const char* separator);
+
+ // buffer management
+ void Reserve(NPT_Size length);
+
+ // hashing
+ NPT_UInt32 GetHash32() const;
+ NPT_UInt64 GetHash64() const;
+
+ // conversions
+ NPT_String ToLowercase() const;
+ NPT_String ToUppercase() const;
+ NPT_Result ToInteger(int& value, bool relaxed = true) const;
+ NPT_Result ToInteger(unsigned int& value, bool relaxed = true) const;
+ NPT_Result ToInteger(long& value, bool relaxed = true) const;
+ NPT_Result ToInteger(unsigned long& value, bool relaxed = true) const;
+ NPT_Result ToInteger32(NPT_Int32& value, bool relaxed = true) const;
+ NPT_Result ToInteger32(NPT_UInt32& value, bool relaxed = true) const;
+ NPT_Result ToInteger64(NPT_Int64& value, bool relaxed = true) const;
+ NPT_Result ToInteger64(NPT_UInt64& value, bool relaxed = true) const;
+ NPT_Result ToFloat(float& value, bool relaxed = true) const;
+
+ // processing
+ void MakeLowercase();
+ void MakeUppercase();
+ const NPT_String& Replace(char a, char b);
+ const NPT_String& Replace(char a, const char* b);
+
+ // search
+ int Find(char c, NPT_Ordinal start = 0, bool ignore_case = false) const;
+ int Find(const char* s, NPT_Ordinal start = 0, bool ignore_case = false) const;
+ int FindAny(const char* s, NPT_Ordinal start, bool ignore_case = false) const;
+ int ReverseFind(char c, NPT_Ordinal start = 0, bool ignore_case = false) const;
+ int ReverseFind(const char* s, NPT_Ordinal start = 0, bool ignore_case = false) const;
+ bool StartsWith(const char* s, bool ignore_case = false) const;
+ bool EndsWith(const char* s, bool ignore_case = false) const;
+
+ // editing
+ const NPT_String& Insert(const char* s, NPT_Ordinal where = 0);
+ const NPT_String& Erase(NPT_Ordinal start, NPT_Cardinal count = 1);
+ const NPT_String& Replace(const char* before, const char* after);
+ // void Replace(NPT_Ordinal start, NPT_Cardinal count, const char* s);
+ const NPT_String& TrimLeft();
+ const NPT_String& TrimLeft(char c);
+ const NPT_String& TrimLeft(const char* chars);
+ const NPT_String& TrimRight();
+ const NPT_String& TrimRight(char c);
+ const NPT_String& TrimRight(const char* chars);
+ const NPT_String& Trim();
+ const NPT_String& Trim(char c);
+ const NPT_String& Trim(const char* chars);
+
+ // type casting
+ operator char*() const { return m_Chars ? m_Chars: &EmptyString; }
+ operator const char* () const { return m_Chars ? m_Chars: &EmptyString; }
+ const char* GetChars() const { return m_Chars ? m_Chars: &EmptyString; }
+ char* UseChars() { return m_Chars ? m_Chars: &EmptyString; }
+
+ // operator overloading
+ NPT_String& operator=(const char* str);
+ NPT_String& operator=(const NPT_String& str);
+ NPT_String& operator=(char c);
+ const NPT_String& operator+=(const NPT_String& s) {
+ Append(s.GetChars(), s.GetLength());
+ return *this;
+ }
+ const NPT_String& operator+=(const char* s) {
+ Append(s);
+ return *this;
+ }
+ const NPT_String& operator+=(char c) {
+ Append(&c, 1);
+ return *this;
+ }
+ char operator[](int index) const {
+ NPT_ASSERT((unsigned int)index < GetLength());
+ return GetChars()[index];
+ }
+ char& operator[](int index) {
+ NPT_ASSERT((unsigned int)index < GetLength());
+ return UseChars()[index];
+ }
+
+ // friend operators
+ friend NPT_String operator+(const NPT_String& s1, const NPT_String& s2) {
+ return s1+s2.GetChars();
+ }
+ friend NPT_String operator+(const NPT_String& s1, const char* s2);
+ friend NPT_String operator+(const char* s1, const NPT_String& s2);
+ friend NPT_String operator+(const NPT_String& s, char c);
+ friend NPT_String operator+(char c, const NPT_String& s);
+
+protected:
+ // inner classes
+ class Buffer {
+ public:
+ // class methods
+ static Buffer* Allocate(NPT_Size allocated, NPT_Size length) {
+ void* mem = ::operator new(sizeof(Buffer)+allocated+1);
+ return new(mem) Buffer(allocated, length);
+ }
+ static char* Create(NPT_Size allocated, NPT_Size length=0) {
+ Buffer* shared = Allocate(allocated, length);
+ return shared->GetChars();
+ }
+ static char* Create(const char* copy) {
+ NPT_Size length = StringLength(copy);
+ Buffer* shared = Allocate(length, length);
+ CopyString(shared->GetChars(), copy);
+ return shared->GetChars();
+ }
+ static char* Create(const char* copy, NPT_Size length) {
+ Buffer* shared = Allocate(length, length);
+ CopyBuffer(shared->GetChars(), copy, length);
+ shared->GetChars()[length] = '\0';
+ return shared->GetChars();
+ }
+ static char* Create(char c, NPT_Cardinal repeat) {
+ Buffer* shared = Allocate(repeat, repeat);
+ char* s = shared->GetChars();
+ while (repeat--) {
+ *s++ = c;
+ }
+ *s = '\0';
+ return shared->GetChars();
+ }
+
+ // methods
+ char* GetChars() {
+ // return a pointer to the first char
+ return reinterpret_cast<char*>(this+1);
+ }
+ NPT_Size GetLength() const { return m_Length; }
+ void SetLength(NPT_Size length) { m_Length = length; }
+ NPT_Size GetAllocated() const { return m_Allocated; }
+ void Destroy() { ::operator delete((void*)this); }
+
+ private:
+ // methods
+ Buffer(NPT_Size allocated, NPT_Size length = 0) :
+ m_Length(length),
+ m_Allocated(allocated) {}
+
+ // members
+ NPT_Cardinal m_Length;
+ NPT_Cardinal m_Allocated;
+ // the actual string data follows
+
+ };
+
+ // members
+ char* m_Chars;
+
+private:
+ // friends
+ friend class Buffer;
+
+ // static members
+ static char EmptyString;
+
+ // methods
+ Buffer* GetBuffer() const {
+ return reinterpret_cast<Buffer*>(m_Chars)-1;
+ }
+ void Reset() {
+ if (m_Chars != NULL) {
+ delete GetBuffer();
+ m_Chars = NULL;
+ }
+ }
+ char* PrepareToWrite(NPT_Size length);
+ void PrepareToAppend(NPT_Size length, NPT_Size allocate);
+
+ // static methods
+ static void CopyString(char* dst, const char* src) {
+ while ((*dst++ = *src++)){}
+ }
+
+ static void CopyBuffer(char* dst, const char* src, NPT_Size size) {
+ while (size--) *dst++ = *src++;
+ }
+
+ static NPT_Size StringLength(const char* str) {
+ NPT_Size length = 0;
+ while (*str++) length++;
+ return length;
+ }
+};
+
+/*----------------------------------------------------------------------
+| external operators
++---------------------------------------------------------------------*/
+inline bool operator==(const NPT_String& s1, const NPT_String& s2) {
+ return s1.Compare(s2) == 0;
+}
+inline bool operator==(const NPT_String& s1, const char* s2) {
+ return s1.Compare(s2) == 0;
+}
+inline bool operator==(const char* s1, const NPT_String& s2) {
+ return s2.Compare(s1) == 0;
+}
+inline bool operator!=(const NPT_String& s1, const NPT_String& s2) {
+ return s1.Compare(s2) != 0;
+}
+inline bool operator!=(const NPT_String& s1, const char* s2) {
+ return s1.Compare(s2) != 0;
+}
+inline bool operator!=(const char* s1, const NPT_String& s2) {
+ return s2.Compare(s1) != 0;
+}
+inline bool operator<(const NPT_String& s1, const NPT_String& s2) {
+ return s1.Compare(s2) < 0;
+}
+inline bool operator<(const NPT_String& s1, const char* s2) {
+ return s1.Compare(s2) < 0;
+}
+inline bool operator<(const char* s1, const NPT_String& s2) {
+ return s2.Compare(s1) > 0;
+}
+inline bool operator>(const NPT_String& s1, const NPT_String& s2) {
+ return s1.Compare(s2) > 0;
+}
+inline bool operator>(const NPT_String& s1, const char* s2) {
+ return s1.Compare(s2) > 0;
+}
+inline bool operator>(const char* s1, const NPT_String& s2) {
+ return s2.Compare(s1) < 0;
+}
+inline bool operator<=(const NPT_String& s1, const NPT_String& s2) {
+ return s1.Compare(s2) <= 0;
+}
+inline bool operator<=(const NPT_String& s1, const char* s2) {
+ return s1.Compare(s2) <= 0;
+}
+inline bool operator<=(const char* s1, const NPT_String& s2) {
+ return s2.Compare(s1) >= 0;
+}
+inline bool operator>=(const NPT_String& s1, const NPT_String& s2) {
+ return s1.Compare(s2) >= 0;
+}
+inline bool operator>=(const NPT_String& s1, const char* s2) {
+ return s1.Compare(s2) >= 0;
+}
+inline bool operator>=(const char* s1, const NPT_String& s2) {
+ return s2.Compare(s1) <= 0;
+}
+
+/*----------------------------------------------------------------------
+| hashing
++---------------------------------------------------------------------*/
+template <>
+struct NPT_Hash<NPT_String>
+{
+ NPT_UInt32 operator()(const NPT_String& s) const { return s.GetHash32(); }
+};
+
+
+#endif // _NPT_STRINGS_H_
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-02 15:17:27 +0000