-/*\r
-Copyright (c) 2001, Loki software, inc.\r
-All rights reserved.\r
-\r
-Redistribution and use in source and binary forms, with or without modification, \r
-are permitted provided that the following conditions are met:\r
-\r
-Redistributions of source code must retain the above copyright notice, this list \r
-of conditions and the following disclaimer.\r
-\r
-Redistributions in binary form must reproduce the above copyright notice, this\r
-list of conditions and the following disclaimer in the documentation and/or\r
-other materials provided with the distribution.\r
-\r
-Neither the name of Loki software nor the names of its contributors may be used \r
-to endorse or promote products derived from this software without specific prior \r
-written permission. \r
-\r
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' \r
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE \r
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE \r
-DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY \r
-DIRECT,INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES \r
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; \r
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS \r
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \r
-*/\r
-\r
-#ifndef __STR__\r
-#define __STR__\r
-\r
-//\r
-// class Str\r
-// loose replacement for CString from MFC\r
-//\r
-\r
-#include <string.h>\r
-#include <ctype.h>\r
-#include <stdarg.h>\r
-\r
-#ifdef __APPLE__\r
- #ifdef NULL\r
- #undef NULL\r
- #define NULL 0\r
- #endif\r
-#endif\r
-\r
-\r
-#ifdef _WIN32\r
-#define strcasecmp strcmpi\r
-#endif\r
-\r
-// NOTE TTimo __StrDup was initially implemented in pakstuff.cpp\r
-// causing a bunch of issues for broader targets that use Str.h (such as plugins and modules)\r
-// Q_StrDup should be used now, using a #define __StrDup for easy transition\r
-\r
-#define __StrDup Q_StrDup\r
-\r
-inline char* Q_StrDup(char* pStr)\r
-{\r
- if (pStr == NULL)\r
- pStr = "";\r
-\r
- return strcpy(new char[strlen(pStr)+1], pStr); \r
-}\r
-\r
-inline char* Q_StrDup(const char* pStr)\r
-{ \r
- if (pStr == NULL)\r
- pStr = "";\r
-\r
- return strcpy(new char[strlen(pStr)+1], pStr); \r
-}\r
-\r
-#if defined (__linux__) || defined (__APPLE__)\r
-#define strcmpi strcasecmp\r
-#define stricmp strcasecmp\r
-#define strnicmp strncasecmp\r
-\r
-inline char* strlwr(char* string)\r
-{\r
- char *cp;\r
- for (cp = string; *cp; ++cp)\r
- {\r
- if ('A' <= *cp && *cp <= 'Z')\r
- *cp += 'a' - 'A';\r
- }\r
-\r
- return string;\r
-}\r
-\r
-inline char* strupr(char* string)\r
-{\r
- char *cp;\r
- for (cp = string; *cp; ++cp)\r
- {\r
- if ('a' <= *cp && *cp <= 'z')\r
- *cp += 'A' - 'a';\r
- }\r
-\r
- return string;\r
-}\r
-#endif\r
-\r
-static char *g_pStrWork = NULL;\r
-\r
-class Str\r
-{\r
-protected:\r
- bool m_bIgnoreCase;\r
- char *m_pStr;\r
-\r
-public:\r
- Str()\r
- {\r
- m_bIgnoreCase = true;\r
- m_pStr = new char[1];\r
- m_pStr[0] = '\0';\r
- }\r
-\r
- Str(char *p)\r
- {\r
- m_bIgnoreCase = true;\r
- m_pStr = __StrDup(p);\r
- }\r
-\r
- Str(const char *p)\r
- {\r
- m_bIgnoreCase = true;\r
- m_pStr = __StrDup(p);\r
- }\r
-\r
- Str(const unsigned char *p)\r
- {\r
- m_bIgnoreCase = true;\r
- m_pStr = __StrDup((const char *)p);\r
- }\r
-\r
- Str(const char c)\r
- {\r
- m_bIgnoreCase = true;\r
- m_pStr = new char[2];\r
- m_pStr[0] = c;\r
- m_pStr[1] = '\0'; \r
- }\r
-\r
- const char* GetBuffer() const\r
- {\r
- return m_pStr;\r
- }\r
-\r
- Str(const Str &s)\r
- {\r
- m_bIgnoreCase = true;\r
- m_pStr = __StrDup(s.GetBuffer());\r
- }\r
-\r
- void Deallocate()\r
- {\r
- delete []m_pStr;\r
- m_pStr = NULL;\r
- }\r
-\r
- void Allocate(int n)\r
- {\r
- Deallocate();\r
- m_pStr = new char[n];\r
- }\r
-\r
- void MakeEmpty()\r
- {\r
- Deallocate();\r
- m_pStr = __StrDup("");\r
- }\r
-\r
- virtual ~Str()\r
- {\r
- Deallocate();\r
- // NOTE TTimo: someone explain this g_pStrWork to me?\r
- if (g_pStrWork)\r
- delete []g_pStrWork;\r
- g_pStrWork = NULL;\r
- }\r
-\r
- void MakeLower()\r
- {\r
- if (m_pStr)\r
- {\r
- strlwr(m_pStr);\r
- }\r
- }\r
-\r
- void MakeUpper()\r
- {\r
- if (m_pStr)\r
- {\r
- strupr(m_pStr);\r
- }\r
- }\r
-\r
- void TrimRight()\r
- {\r
- char* lpsz = m_pStr;\r
- char* lpszLast = NULL;\r
- while (*lpsz != '\0')\r
- {\r
- if (isspace(*lpsz))\r
- {\r
- if (lpszLast == NULL)\r
- lpszLast = lpsz;\r
- }\r
- else\r
- lpszLast = NULL;\r
- lpsz++;\r
- }\r
- \r
- if (lpszLast != NULL)\r
- {\r
- // truncate at trailing space start\r
- *lpszLast = '\0';\r
- }\r
- }\r
-\r
- void TrimLeft()\r
- {\r
- // find first non-space character\r
- char* lpsz = m_pStr;\r
- while (isspace(*lpsz))\r
- lpsz++;\r
- \r
- // fix up data and length\r
- int nDataLength = GetLength() - (lpsz - m_pStr);\r
- memmove(m_pStr, lpsz, (nDataLength+1));\r
- }\r
-\r
- int Find(const char *p)\r
- {\r
- char *pf = strstr(m_pStr, p);\r
- return (pf) ? (pf - m_pStr) : -1;\r
- }\r
-\r
- // search starting at a given offset\r
- int Find(const char *p, int offset)\r
- {\r
- char *pf = strstr(m_pStr+offset, p);\r
- return (pf) ? (pf - m_pStr) : -1;\r
- }\r
-\r
- int Find(const char ch)\r
- {\r
- char *pf = strchr (m_pStr, ch);\r
- return (pf) ? (pf - m_pStr) : -1;\r
- }\r
-\r
- int ReverseFind(const char ch)\r
- {\r
- char *pf = strrchr(m_pStr, ch);\r
- return (pf) ? (pf - m_pStr) : -1;\r
- }\r
-\r
- int Compare (const char* str) const\r
- {\r
- return strcmp (m_pStr, str);\r
- }\r
- \r
- int CompareNoCase (const char* str) const\r
- {\r
- return strcasecmp (m_pStr, str);\r
- }\r
-\r
- int GetLength()\r
- {\r
- return (m_pStr) ? strlen(m_pStr) : 0;\r
- }\r
-\r
- const char* Left(int n)\r
- {\r
- delete []g_pStrWork;\r
- if (n > 0)\r
- {\r
- g_pStrWork = new char[n+1];\r
- strncpy(g_pStrWork, m_pStr, n);\r
- g_pStrWork[n] = '\0';\r
- }\r
- else\r
- {\r
- g_pStrWork = "";\r
- g_pStrWork = new char[1];\r
- g_pStrWork[0] = '\0';\r
- }\r
- return g_pStrWork;\r
- }\r
-\r
- const char* Right(int n)\r
- {\r
- delete []g_pStrWork;\r
- if (n > 0)\r
- {\r
- g_pStrWork = new char[n+1];\r
- int nStart = GetLength() - n;\r
- strncpy(g_pStrWork, &m_pStr[nStart], n);\r
- g_pStrWork[n] = '\0';\r
- }\r
- else\r
- {\r
- g_pStrWork = new char[1];\r
- g_pStrWork[0] = '\0';\r
- }\r
- return g_pStrWork;\r
- }\r
-\r
- const char* Mid(int nFirst) const\r
- {\r
- return Mid(nFirst, strlen (m_pStr) - nFirst);\r
- }\r
-\r
- const char* Mid(int first, int n) const\r
- {\r
- delete []g_pStrWork;\r
- if (n > 0)\r
- {\r
- g_pStrWork = new char[n+1];\r
- strncpy(g_pStrWork, m_pStr+first, n);\r
- g_pStrWork[n] = '\0';\r
- }\r
- else\r
- {\r
- g_pStrWork = "";\r
- g_pStrWork = new char[1];\r
- g_pStrWork[0] = '\0';\r
- }\r
- return g_pStrWork;\r
- }\r
-\r
-#ifdef __G_LIB_H__\r
- void Format(const char* fmt, ...)\r
- {\r
- va_list args;\r
- char *buffer;\r
- \r
- va_start (args, fmt);\r
- buffer = g_strdup_vprintf (fmt, args);\r
- va_end (args);\r
-\r
- delete[] m_pStr;\r
- m_pStr = __StrDup(buffer);\r
- g_free (buffer);\r
- }\r
-#else\r
- void Format(const char* fmt, ...)\r
- {\r
- va_list args;\r
- m_pStr = new char[1024];\r
-\r
- va_start (args, fmt);\r
- vsprintf (m_pStr, fmt, args);\r
- va_end (args);\r
- }\r
-#endif\r
-\r
- void SetAt(int n, char ch)\r
- {\r
- if (n >= 0 && n < GetLength ())\r
- m_pStr[n] = ch;\r
- }\r
-\r
- // NOTE: unlike CString, this looses the pointer\r
- void ReleaseBuffer(int n = -1)\r
- {\r
- if (n == -1)\r
- n = GetLength ();\r
-\r
- char* tmp = m_pStr;\r
- tmp[n] = '\0';\r
- m_pStr = __StrDup(tmp);\r
- delete []tmp;\r
- }\r
-\r
- char* GetBufferSetLength(int n)\r
- {\r
- if (n < 0)\r
- n = 0;\r
-\r
- char *p = new char[n+1];\r
- strncpy (p, m_pStr, n);\r
- p[n] = '\0';\r
- delete []m_pStr;\r
- m_pStr = p;\r
- return m_pStr;\r
- }\r
-\r
- // char& operator *() { return *m_pStr; }\r
- // char& operator *() const { return *const_cast<Str*>(this)->m_pStr; }\r
- operator void*() { return m_pStr; }\r
- operator char*() { return m_pStr; }\r
- operator const char*(){ return reinterpret_cast<const char*>(m_pStr); }\r
- operator unsigned char*() { return reinterpret_cast<unsigned char*>(m_pStr); }\r
- operator const unsigned char*() { return reinterpret_cast<const unsigned char*>(m_pStr); }\r
- Str& operator =(const Str& rhs)\r
- {\r
- if (&rhs != this)\r
- {\r
- delete[] m_pStr;\r
- m_pStr = __StrDup(rhs.m_pStr);\r
- }\r
- return *this;\r
- }\r
- \r
- Str& operator =(const char* pStr)\r
- {\r
- if (m_pStr != pStr)\r
- {\r
- delete[] m_pStr;\r
- m_pStr = __StrDup(pStr);\r
- }\r
- return *this;\r
- }\r
-\r
- Str& operator +=(const char ch)\r
- {\r
- int len = GetLength ();\r
- char *p = new char[len + 1 + 1];\r
-\r
- if (m_pStr)\r
- {\r
- strcpy(p, m_pStr);\r
- delete[] m_pStr;\r
- }\r
-\r
- m_pStr = p;\r
- m_pStr[len] = ch;\r
- m_pStr[len+1] = '\0';\r
-\r
- return *this;\r
- }\r
-\r
- Str& operator +=(const char *pStr)\r
- {\r
- if (pStr)\r
- {\r
- if (m_pStr)\r
- {\r
- char *p = new char[strlen(m_pStr) + strlen(pStr) + 1];\r
- strcpy(p, m_pStr);\r
- strcat(p, pStr);\r
- delete[] m_pStr;\r
- m_pStr = p;\r
- }\r
- else\r
- {\r
- m_pStr = __StrDup(pStr);\r
- }\r
- }\r
- return *this;\r
- }\r
- \r
-\r
- bool operator ==(const Str& rhs) const { return (m_bIgnoreCase) ? stricmp(m_pStr, rhs.m_pStr) == 0 : strcmp(m_pStr, rhs.m_pStr) == 0; }\r
- bool operator ==(char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) == 0 : strcmp(m_pStr, pStr) == 0; }\r
- bool operator ==(const char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) == 0 : strcmp(m_pStr, pStr) == 0; }\r
- bool operator !=(Str& rhs) const { return (m_bIgnoreCase) ? stricmp(m_pStr, rhs.m_pStr) != 0 : strcmp(m_pStr, rhs.m_pStr) != 0; }\r
- bool operator !=(char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) != 0 : strcmp(m_pStr, pStr) != 0; }\r
- bool operator !=(const char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) != 0 : strcmp(m_pStr, pStr) != 0; }\r
- bool operator <(const Str& rhs) const { return (m_bIgnoreCase) ? stricmp(m_pStr, rhs.m_pStr) < 0 : strcmp(m_pStr, rhs.m_pStr) < 0; }\r
- bool operator <(char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) < 0 : strcmp(m_pStr, pStr) < 0; }\r
- bool operator <(const char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) < 0 : strcmp(m_pStr, pStr) < 0; }\r
- bool operator >(const Str& rhs) const { return (m_bIgnoreCase) ? stricmp(m_pStr, rhs.m_pStr) > 0 : strcmp(m_pStr, rhs.m_pStr) > 0; }\r
- bool operator >(char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) > 0 : strcmp(m_pStr, pStr) > 0; }\r
- bool operator >(const char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) > 0 : strcmp(m_pStr, pStr) > 0; }\r
- char& operator [](int nIndex) { return m_pStr[nIndex]; }\r
- char& operator [](int nIndex) const { return m_pStr[nIndex]; }\r
- const char GetAt (int nIndex) { return m_pStr[nIndex]; }\r
-};\r
-\r
-\r
-\r
-#endif\r
+/*
+Copyright (c) 2001, Loki software, inc.
+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 Loki software 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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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 __STR__
+#define __STR__
+
+//
+// class Str
+// loose replacement for CString from MFC
+//
+
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+
+#ifdef __APPLE__
+ #ifdef NULL
+ #undef NULL
+ #define NULL 0
+ #endif
+#endif
+
+
+#ifdef _WIN32
+#define strcasecmp strcmpi
+#endif
+
+// NOTE TTimo __StrDup was initially implemented in pakstuff.cpp
+// causing a bunch of issues for broader targets that use Str.h (such as plugins and modules)
+// Q_StrDup should be used now, using a #define __StrDup for easy transition
+
+#define __StrDup Q_StrDup
+
+inline char* Q_StrDup(char* pStr)
+{
+ if (pStr == NULL)
+ pStr = "";
+
+ return strcpy(new char[strlen(pStr)+1], pStr);
+}
+
+inline char* Q_StrDup(const char* pStr)
+{
+ if (pStr == NULL)
+ pStr = "";
+
+ return strcpy(new char[strlen(pStr)+1], pStr);
+}
+
+#if defined (__linux__) || defined (__APPLE__)
+#define strcmpi strcasecmp
+#define stricmp strcasecmp
+#define strnicmp strncasecmp
+
+inline char* strlwr(char* string)
+{
+ char *cp;
+ for (cp = string; *cp; ++cp)
+ {
+ if ('A' <= *cp && *cp <= 'Z')
+ *cp += 'a' - 'A';
+ }
+
+ return string;
+}
+
+inline char* strupr(char* string)
+{
+ char *cp;
+ for (cp = string; *cp; ++cp)
+ {
+ if ('a' <= *cp && *cp <= 'z')
+ *cp += 'A' - 'a';
+ }
+
+ return string;
+}
+#endif
+
+static char *g_pStrWork = NULL;
+
+class Str
+{
+protected:
+ bool m_bIgnoreCase;
+ char *m_pStr;
+
+public:
+ Str()
+ {
+ m_bIgnoreCase = true;
+ m_pStr = new char[1];
+ m_pStr[0] = '\0';
+ }
+
+ Str(char *p)
+ {
+ m_bIgnoreCase = true;
+ m_pStr = __StrDup(p);
+ }
+
+ Str(const char *p)
+ {
+ m_bIgnoreCase = true;
+ m_pStr = __StrDup(p);
+ }
+
+ Str(const unsigned char *p)
+ {
+ m_bIgnoreCase = true;
+ m_pStr = __StrDup((const char *)p);
+ }
+
+ Str(const char c)
+ {
+ m_bIgnoreCase = true;
+ m_pStr = new char[2];
+ m_pStr[0] = c;
+ m_pStr[1] = '\0';
+ }
+
+ const char* GetBuffer() const
+ {
+ return m_pStr;
+ }
+
+ Str(const Str &s)
+ {
+ m_bIgnoreCase = true;
+ m_pStr = __StrDup(s.GetBuffer());
+ }
+
+ void Deallocate()
+ {
+ delete []m_pStr;
+ m_pStr = NULL;
+ }
+
+ void Allocate(int n)
+ {
+ Deallocate();
+ m_pStr = new char[n];
+ }
+
+ void MakeEmpty()
+ {
+ Deallocate();
+ m_pStr = __StrDup("");
+ }
+
+ virtual ~Str()
+ {
+ Deallocate();
+ // NOTE TTimo: someone explain this g_pStrWork to me?
+ if (g_pStrWork)
+ delete []g_pStrWork;
+ g_pStrWork = NULL;
+ }
+
+ void MakeLower()
+ {
+ if (m_pStr)
+ {
+ strlwr(m_pStr);
+ }
+ }
+
+ void MakeUpper()
+ {
+ if (m_pStr)
+ {
+ strupr(m_pStr);
+ }
+ }
+
+ void TrimRight()
+ {
+ char* lpsz = m_pStr;
+ char* lpszLast = NULL;
+ while (*lpsz != '\0')
+ {
+ if (isspace(*lpsz))
+ {
+ if (lpszLast == NULL)
+ lpszLast = lpsz;
+ }
+ else
+ lpszLast = NULL;
+ lpsz++;
+ }
+
+ if (lpszLast != NULL)
+ {
+ // truncate at trailing space start
+ *lpszLast = '\0';
+ }
+ }
+
+ void TrimLeft()
+ {
+ // find first non-space character
+ char* lpsz = m_pStr;
+ while (isspace(*lpsz))
+ lpsz++;
+
+ // fix up data and length
+ int nDataLength = GetLength() - (lpsz - m_pStr);
+ memmove(m_pStr, lpsz, (nDataLength+1));
+ }
+
+ int Find(const char *p)
+ {
+ char *pf = strstr(m_pStr, p);
+ return (pf) ? (pf - m_pStr) : -1;
+ }
+
+ // search starting at a given offset
+ int Find(const char *p, int offset)
+ {
+ char *pf = strstr(m_pStr+offset, p);
+ return (pf) ? (pf - m_pStr) : -1;
+ }
+
+ int Find(const char ch)
+ {
+ char *pf = strchr (m_pStr, ch);
+ return (pf) ? (pf - m_pStr) : -1;
+ }
+
+ int ReverseFind(const char ch)
+ {
+ char *pf = strrchr(m_pStr, ch);
+ return (pf) ? (pf - m_pStr) : -1;
+ }
+
+ int Compare (const char* str) const
+ {
+ return strcmp (m_pStr, str);
+ }
+
+ int CompareNoCase (const char* str) const
+ {
+ return strcasecmp (m_pStr, str);
+ }
+
+ int GetLength()
+ {
+ return (m_pStr) ? strlen(m_pStr) : 0;
+ }
+
+ const char* Left(int n)
+ {
+ delete []g_pStrWork;
+ if (n > 0)
+ {
+ g_pStrWork = new char[n+1];
+ strncpy(g_pStrWork, m_pStr, n);
+ g_pStrWork[n] = '\0';
+ }
+ else
+ {
+ g_pStrWork = "";
+ g_pStrWork = new char[1];
+ g_pStrWork[0] = '\0';
+ }
+ return g_pStrWork;
+ }
+
+ const char* Right(int n)
+ {
+ delete []g_pStrWork;
+ if (n > 0)
+ {
+ g_pStrWork = new char[n+1];
+ int nStart = GetLength() - n;
+ strncpy(g_pStrWork, &m_pStr[nStart], n);
+ g_pStrWork[n] = '\0';
+ }
+ else
+ {
+ g_pStrWork = new char[1];
+ g_pStrWork[0] = '\0';
+ }
+ return g_pStrWork;
+ }
+
+ const char* Mid(int nFirst) const
+ {
+ return Mid(nFirst, strlen (m_pStr) - nFirst);
+ }
+
+ const char* Mid(int first, int n) const
+ {
+ delete []g_pStrWork;
+ if (n > 0)
+ {
+ g_pStrWork = new char[n+1];
+ strncpy(g_pStrWork, m_pStr+first, n);
+ g_pStrWork[n] = '\0';
+ }
+ else
+ {
+ g_pStrWork = "";
+ g_pStrWork = new char[1];
+ g_pStrWork[0] = '\0';
+ }
+ return g_pStrWork;
+ }
+
+#ifdef __G_LIB_H__
+ void Format(const char* fmt, ...)
+ {
+ va_list args;
+ char *buffer;
+
+ va_start (args, fmt);
+ buffer = g_strdup_vprintf (fmt, args);
+ va_end (args);
+
+ delete[] m_pStr;
+ m_pStr = __StrDup(buffer);
+ g_free (buffer);
+ }
+#else
+ void Format(const char* fmt, ...)
+ {
+ va_list args;
+ m_pStr = new char[1024];
+
+ va_start (args, fmt);
+ vsprintf (m_pStr, fmt, args);
+ va_end (args);
+ }
+#endif
+
+ void SetAt(int n, char ch)
+ {
+ if (n >= 0 && n < GetLength ())
+ m_pStr[n] = ch;
+ }
+
+ // NOTE: unlike CString, this looses the pointer
+ void ReleaseBuffer(int n = -1)
+ {
+ if (n == -1)
+ n = GetLength ();
+
+ char* tmp = m_pStr;
+ tmp[n] = '\0';
+ m_pStr = __StrDup(tmp);
+ delete []tmp;
+ }
+
+ char* GetBufferSetLength(int n)
+ {
+ if (n < 0)
+ n = 0;
+
+ char *p = new char[n+1];
+ strncpy (p, m_pStr, n);
+ p[n] = '\0';
+ delete []m_pStr;
+ m_pStr = p;
+ return m_pStr;
+ }
+
+ // char& operator *() { return *m_pStr; }
+ // char& operator *() const { return *const_cast<Str*>(this)->m_pStr; }
+ operator void*() { return m_pStr; }
+ operator char*() { return m_pStr; }
+ operator const char*(){ return reinterpret_cast<const char*>(m_pStr); }
+ operator unsigned char*() { return reinterpret_cast<unsigned char*>(m_pStr); }
+ operator const unsigned char*() { return reinterpret_cast<const unsigned char*>(m_pStr); }
+ Str& operator =(const Str& rhs)
+ {
+ if (&rhs != this)
+ {
+ delete[] m_pStr;
+ m_pStr = __StrDup(rhs.m_pStr);
+ }
+ return *this;
+ }
+
+ Str& operator =(const char* pStr)
+ {
+ if (m_pStr != pStr)
+ {
+ delete[] m_pStr;
+ m_pStr = __StrDup(pStr);
+ }
+ return *this;
+ }
+
+ Str& operator +=(const char ch)
+ {
+ int len = GetLength ();
+ char *p = new char[len + 1 + 1];
+
+ if (m_pStr)
+ {
+ strcpy(p, m_pStr);
+ delete[] m_pStr;
+ }
+
+ m_pStr = p;
+ m_pStr[len] = ch;
+ m_pStr[len+1] = '\0';
+
+ return *this;
+ }
+
+ Str& operator +=(const char *pStr)
+ {
+ if (pStr)
+ {
+ if (m_pStr)
+ {
+ char *p = new char[strlen(m_pStr) + strlen(pStr) + 1];
+ strcpy(p, m_pStr);
+ strcat(p, pStr);
+ delete[] m_pStr;
+ m_pStr = p;
+ }
+ else
+ {
+ m_pStr = __StrDup(pStr);
+ }
+ }
+ return *this;
+ }
+
+
+ bool operator ==(const Str& rhs) const { return (m_bIgnoreCase) ? stricmp(m_pStr, rhs.m_pStr) == 0 : strcmp(m_pStr, rhs.m_pStr) == 0; }
+ bool operator ==(char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) == 0 : strcmp(m_pStr, pStr) == 0; }
+ bool operator ==(const char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) == 0 : strcmp(m_pStr, pStr) == 0; }
+ bool operator !=(Str& rhs) const { return (m_bIgnoreCase) ? stricmp(m_pStr, rhs.m_pStr) != 0 : strcmp(m_pStr, rhs.m_pStr) != 0; }
+ bool operator !=(char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) != 0 : strcmp(m_pStr, pStr) != 0; }
+ bool operator !=(const char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) != 0 : strcmp(m_pStr, pStr) != 0; }
+ bool operator <(const Str& rhs) const { return (m_bIgnoreCase) ? stricmp(m_pStr, rhs.m_pStr) < 0 : strcmp(m_pStr, rhs.m_pStr) < 0; }
+ bool operator <(char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) < 0 : strcmp(m_pStr, pStr) < 0; }
+ bool operator <(const char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) < 0 : strcmp(m_pStr, pStr) < 0; }
+ bool operator >(const Str& rhs) const { return (m_bIgnoreCase) ? stricmp(m_pStr, rhs.m_pStr) > 0 : strcmp(m_pStr, rhs.m_pStr) > 0; }
+ bool operator >(char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) > 0 : strcmp(m_pStr, pStr) > 0; }
+ bool operator >(const char* pStr) const { return (m_bIgnoreCase) ? stricmp(m_pStr, pStr) > 0 : strcmp(m_pStr, pStr) > 0; }
+ char& operator [](int nIndex) { return m_pStr[nIndex]; }
+ char& operator [](int nIndex) const { return m_pStr[nIndex]; }
+ const char GetAt (int nIndex) { return m_pStr[nIndex]; }
+};
+
+
+
+#endif
projects / xonotic / netradiant.git / blobdiff