Main Page Modules C++ Classes Compound List File List Index Related Pages What is the Nebula Device? Features Downloads License Contact Us Blogroll enlight's blog Floh's Blog Documentation FAQ Getting Started Script Docs Links forums Bugs Nebula2 on Sourceforge Radon Labs Categories News Images changes Search Archives September 2008 July 2008 May 2008 April 2007 March 2007 August 2006 June 2006 March 2006 October 2005 August 2005 July 2005 Meta Login RSS Comments RSS nstring.h Go to the documentation of this file. #ifndef N_STRING_H #define N_STRING_H //------------------------------------------------------------------------------ #include <ctype.h> #include <string.h> #include <stdarg.h> #ifdef __WIN32__ #include <malloc.h> #else #include <alloca.h> #endif #include "kernel/ntypes.h" #include "util/narray.h" #include "mathlib/vector.h" #include "mathlib/matrix.h" //------------------------------------------------------------------------------ class nString { public: nString(); nString(const char* str); nString(const nString& rhs); ~nString(); nString& operator=(const nString& rhs); nString& operator=(const char* rhs); nString& operator+=(const char* rhs); nString& operator+=(const nString& rhs); friend bool operator == (const nString& a, const nString& b); friend bool operator != (const nString& a, const nString& b); friend bool operator < (const nString& a, const nString& b); friend bool operator > (const nString& a, const nString& b); friend bool operator <= (const nString& a, const nString& b); friend bool operator >= (const nString& a, const nString& b); char operator[](int i) const; char& operator[](int i); void Set(const char* ptr, int length); void Set(const char* str); void SetInt(int val); void SetFloat(float val); void SetBool(bool val); void SetVector3(const vector3& v); void SetVector4(const vector4& v); void SetMatrix44(const matrix44& m); const char* Get() const; int AsInt() const; float AsFloat() const; bool AsBool() const; vector3 AsVector3() const; vector4 AsVector4() const; matrix44 AsMatrix44() const; bool IsValidInt() const; bool IsValidFloat() const; bool IsValidBool() const; bool IsValidVector3() const; bool IsValidVector4() const; bool IsValidMatrix44() const; int Length() const; void Clear(); bool IsEmpty() const; bool IsValid() const; void Append(const char* str); void Append(const nString& str); void AppendRange(const char* str, uint numChars); void AppendInt(int val); void AppendFloat(float val); void ToLower(); void ToUpper(); const char* GetFirstToken(const char* whiteSpace); const char* GetNextToken(const char* whiteSpace); int Tokenize(const char* whiteSpace, nArray<nString>& tokens) const; int Tokenize(const char* whiteSpace, uchar fence, nArray<nString>& tokens) const; nString ExtractRange(int from, int numChars) const; void Strip(const char* charSet); int FindStringIndex(const nString& v, int startIndex) const; int FindCharIndex(unsigned char c, int startIndex) const; void TerminateAtIndex(int index); bool ContainsCharFromSet(const char* charSet) const; void StripTrailingSlash(); nString TrimLeft(const char* charSet) const; nString TrimRight(const char* charSet) const; nString Trim(const char* charSet) const; nString Substitute(const char* str, const char* substStr) const; void SubstituteCharacter(char c, char subst); void UTF8toANSI(); void ANSItoUTF8(); const char* GetExtension() const; bool CheckExtension(const char* ext) const; void ConvertBackslashes(); void StripExtension(); nString ExtractFileName() const; nString ExtractLastDirName() const; nString ExtractDirName() const; nString ExtractToLastSlash() const; bool MatchPattern(const nString& pattern) const; void __cdecl Format(const char* fmtString, ...) __attribute__((format(printf,2,3))); void FormatWithArgs(const char* fmtString, va_list args); void ReplaceIllegalFilenameChars(char replacement); bool CheckValidCharSet(const nString& charSet) const; void ReplaceChars(const char* charSet, char replacement); static nString Concatenate(const nArray<nString>& strArray, const nString& whiteSpace); static nString FromInt(int i); static nString FromFloat(float f); static nString FromBool(bool b); static nString FromVector3(const vector3& v); static nString FromVector4(const vector4& v); static nString FromMatrix44(const matrix44& m); protected: void Copy(const nString& src); void Delete(); char* GetLastSlash() const; size_t GetFormattedStringLength(const char* format, va_list argList) const; void SetLength(int); enum { LOCALSTRINGSIZE = 14, }; char* string; union { struct { char localString[LOCALSTRINGSIZE]; ushort localStrLen; }; uint strLen; }; }; //------------------------------------------------------------------------------ inline nString::nString() : string(0), strLen(0), localStrLen(0) { } //------------------------------------------------------------------------------ inline void nString::Delete() { if (this->string) { n_free((void*) this->string); this->string = 0; } this->localString[0] = 0; this->localStrLen = 0; } //------------------------------------------------------------------------------ inline nString::~nString() { this->Delete(); } //------------------------------------------------------------------------------ inline void nString::Set(const char* str, int length) { this->Delete(); if (str) { if (length >= LOCALSTRINGSIZE) { this->string = (char*)n_malloc(length + 1); memcpy(this->string, str, length); this->string[length] = 0; this->strLen = length; } else { memcpy(this->localString, str, length); this->localString[length] = 0; this->localStrLen = (ushort)length; } } } //------------------------------------------------------------------------------ inline void nString::Set(const char* str) { int len = 0; if (str) { len = (int) strlen(str); } this->Set(str, len); } //------------------------------------------------------------------------------ inline void nString::SetInt(int val) { this->Format("%d", val); } //------------------------------------------------------------------------------ inline void nString::SetFloat(float val) { this->Format("%.6f", val); } //------------------------------------------------------------------------------ inline void nString::SetBool(bool val) { if (val) { *this = "true"; } else { *this = "false"; } } //------------------------------------------------------------------------------ inline void nString::SetVector3(const vector3& v) { this->Format("%.6f,%.6f,%.6f", v.x, v.y, v.z); } //------------------------------------------------------------------------------ inline void nString::SetVector4(const vector4& v) { this->Format("%.6f,%.6f,%.6f,%.6f", v.x, v.y, v.z, v.w); } //------------------------------------------------------------------------------ inline void nString::SetMatrix44(const matrix44& m) { this->Format("%.6f, %.6f, %.6f, %.6f, " "%.6f, %.6f, %.6f, %.6f, " "%.6f, %.6f, %.6f, %.6f, " "%.6f, %.6f, %.6f, %.6f", m.M11, m.M12, m.M13, m.M14, m.M21, m.M22, m.M23, m.M24, m.M31, m.M32, m.M33, m.M34, m.M41, m.M42, m.M43, m.M44); } //------------------------------------------------------------------------------ inline void nString::Copy(const nString& src) { n_assert(0 == this->string); const char* str = src.Get(); if (str) { this->Set(str); } } //------------------------------------------------------------------------------ inline nString::nString(const char* str) : string(0), strLen(0), localStrLen(0) { this->Set(str); } //------------------------------------------------------------------------------ inline nString::nString(const nString& rhs) : string(0), strLen(0) { this->localString[0] = 0; this->Copy(rhs); } //------------------------------------------------------------------------------ inline const char* nString::Get() const { if (this->string) { return this->string; } if (this->localString[0]) { return this->localString; } return ""; } //------------------------------------------------------------------------------ inline nString& nString::operator=(const nString& rhs) { if (&rhs != this) { this->Delete(); this->Copy(rhs); } return *this; } //------------------------------------------------------------------------------ inline nString& nString::operator=(const char* rhs) { if (rhs != this->Get()) { this->Set(rhs); } return *this; } //------------------------------------------------------------------------------ inline void nString::AppendRange(const char* str, uint numChars) { n_assert(str); if (numChars > 0) { uint rlen = numChars; uint tlen = this->Length() + rlen; if (this->string) { char* ptr = (char*)n_malloc(tlen + 1); strcpy(ptr, this->string); strncat(ptr, str, numChars); n_free((void*)this->string); this->string = ptr; this->strLen = tlen; } else if (this->localString[0]) { if (tlen >= LOCALSTRINGSIZE) { char* ptr = (char*)n_malloc(tlen + 1); strcpy(ptr, this->localString); strncat(ptr, str, numChars); this->localString[0] = 0; this->string = ptr; this->strLen = tlen; } else { strncat(this->localString, str, numChars); this->localStrLen = (ushort)tlen; } } else { this->Set(str, numChars); } } } //------------------------------------------------------------------------------ inline void nString::Append(const char* str) { n_assert(str); uint rlen = strlen(str); this->AppendRange(str, rlen); } //------------------------------------------------------------------------------ inline void nString::Append(const nString& str) { this->Append(str.Get()); } //------------------------------------------------------------------------------ inline void nString::AppendInt(int val) { nString str; str.SetInt(val); this->Append(str); } //------------------------------------------------------------------------------ inline void nString::AppendFloat(float val) { nString str; str.SetFloat(val); this->Append(str); } //------------------------------------------------------------------------------ inline nString& nString::operator+=(const char* rhs) { this->Append(rhs); return *this; } //------------------------------------------------------------------------------ inline nString& nString::operator+=(const nString& rhs) { this->Append(rhs.Get()); return *this; } //------------------------------------------------------------------------------ inline bool operator == (const nString& a, const nString& b) { return strcmp(a.Get(), b.Get()) == 0; } //------------------------------------------------------------------------------ inline bool operator != (const nString& a, const nString& b) { return strcmp(a.Get(), b.Get()) != 0; } //------------------------------------------------------------------------------ inline bool operator < (const nString& a, const nString& b) { return strcmp(a.Get(), b.Get()) < 0; } //------------------------------------------------------------------------------ inline bool operator > (const nString& a, const nString& b) { return strcmp(a.Get(), b.Get()) > 0; } //------------------------------------------------------------------------------ inline bool operator <= (const nString& a, const nString& b) { return strcmp(a.Get(), b.Get()) <= 0; } //------------------------------------------------------------------------------ inline bool operator >= (const nString& a, const nString& b) { return strcmp(a.Get(), b.Get()) >= 0; } //------------------------------------------------------------------------------ inline char nString::operator[](int i) const { n_assert((0 <= i) && (i <= this->Length())); if (this->string != 0) { return this->string[i]; } return this->localString[i]; } //------------------------------------------------------------------------------ inline char& nString::operator[](int i) { n_assert((0 <= i) && (i <= this->Length())); if (this->string != 0) { return this->string[i]; } else { return this->localString[i]; } } //------------------------------------------------------------------------------ inline int nString::Length() const { if (this->string != 0) { return this->strLen; } return this->localStrLen; } //------------------------------------------------------------------------------ inline void nString::Clear() { this->Delete(); } //------------------------------------------------------------------------------ inline bool nString::IsEmpty() const { if (this->string && (this->string[0] != 0)) { return false; } if (this->localString[0] != 0) { return false; } return true; } //------------------------------------------------------------------------------ inline bool nString::IsValid() const { return !this->IsEmpty(); } //------------------------------------------------------------------------------ inline void nString::ToLower() { char* str = (char*)(this->string ? this->string : this->localString); if (str) { char c; char* ptr = (char*)str; while ((c = *ptr)) { *ptr++ = tolower(c); } } } //------------------------------------------------------------------------------ inline void nString::ToUpper() { char* str = (char*)(this->string ? this->string : this->localString); if (str) { char c; char* ptr = (char*)str; while ((c = *ptr)) { *ptr++ = toupper(c); } } } //------------------------------------------------------------------------------ static inline nString operator+(const nString& s0, const nString& s1) { nString newString = s0; newString.Append(s1.Get()); return newString; } //------------------------------------------------------------------------------ inline const char* nString::GetFirstToken(const char* whiteSpace) { n_assert(whiteSpace); return strtok((char*)this->Get(), whiteSpace); } //------------------------------------------------------------------------------ inline const char* nString::GetNextToken(const char* whiteSpace) { n_assert(whiteSpace); return strtok(0, whiteSpace); } //------------------------------------------------------------------------------ inline int nString::Tokenize(const char* whiteSpace, nArray<nString>& tokens) const { int numTokens = 0; // create a temporary string, which will be destroyed during the operation nString str(*this); char* ptr = (char*)str.Get(); const char* token; while (0 != (token = strtok(ptr, whiteSpace))) { tokens.Append(token); ptr = 0; numTokens++; } return numTokens; } //------------------------------------------------------------------------------ inline int nString::Tokenize(const char* whiteSpace, uchar fence, nArray<nString>& tokens) const { // create a temporary string, which will be destroyed during the operation nString str(*this); char* ptr = (char*)str.Get(); char* end = ptr + strlen(ptr); while (ptr < end) { char* c; // skip white space while (*ptr && strchr(whiteSpace, *ptr)) { ptr++; } if (*ptr) { // check for fenced area if ((fence == *ptr) && (c = strchr(++ptr, fence))) { *c++ = 0; tokens.Append(ptr); ptr = c; } else if ((c = strpbrk(ptr, whiteSpace))) { *c++ = 0; tokens.Append(ptr); ptr = c; } else { tokens.Append(ptr); break; } } } return tokens.Size(); } //------------------------------------------------------------------------------ inline nString nString::ExtractRange(int from, int numChars) const { n_assert(from <= this->Length()); n_assert((from + numChars) <= this->Length()); const char* str = this->Get(); nString newString; newString.Set(&(str[from]), numChars); return newString; } //------------------------------------------------------------------------------ inline void nString::Strip(const char* charSet) { n_assert(charSet); char* str = (char*)this->Get(); char* ptr = strpbrk(str, charSet); if (ptr) { *ptr = 0; } this->SetLength(strlen(str)); } //------------------------------------------------------------------------------ inline bool nString::ContainsCharFromSet(const char* charSet) const { n_assert(charSet); char* str = (char*)this->Get(); char* ptr = strpbrk(str, charSet); return (0 != ptr); } //------------------------------------------------------------------------------ inline int nString::FindStringIndex(const nString& v, int startIndex) const { n_assert(0 <= startIndex && startIndex <= Length() - 1); n_assert(!v.IsEmpty()); for (int i = startIndex; i < Length(); i++) { if (Length() - i < v.Length()) { break; } if (strncmp(&(Get()[i]), v.Get(), v.Length()) == 0) { return i; } } return -1; } //------------------------------------------------------------------------------ inline int nString::FindCharIndex(unsigned char c, int startIndex) const { if (this->Length() > 0) { n_assert(startIndex < this->Length()); const char* ptr = strchr(this->Get() + startIndex, c); if (ptr) { return ptr - this->Get(); } } return -1; } //------------------------------------------------------------------------------ inline void nString::TerminateAtIndex(int index) { n_assert(index < this->Length()); char* ptr = (char*)this->Get(); ptr[index] = 0; this->SetLength(strlen(this->Get())); } //------------------------------------------------------------------------------ inline void nString::StripTrailingSlash() { if (this->Length() > 0) { int pos = Length() - 1; char* str = (char*)this->Get(); if ((str[pos] == '/') || (str[pos] == '\\')) { str[pos] = 0; if (this->string != 0) { this->strLen--; } else { this->localStrLen--; } } this->SetLength(strlen(this->Get())); } } //------------------------------------------------------------------------------ inline nString nString::TrimLeft(const char* charSet) const { n_assert(charSet); if (this->IsEmpty()) { return *this; } int charSetLen = strlen(charSet); int thisIndex = 0; bool stopped = false; while (!stopped && (thisIndex < this->Length())) { int charSetIndex; bool match = false; for (charSetIndex = 0; charSetIndex < charSetLen; charSetIndex++) { if ((*this)[thisIndex] == charSet[charSetIndex]) { // a match match = true; break; } } if (!match) { // stop if no match stopped = true; } else { // a match, advance to next character ++thisIndex; } } nString trimmedString(&(this->Get()[thisIndex])); return trimmedString; } //------------------------------------------------------------------------------ inline nString nString::TrimRight(const char* charSet) const { n_assert(charSet); if (this->IsEmpty()) { return *this; } int charSetLen = strlen(charSet); int thisIndex = this->Length() - 1; bool stopped = false; while (!stopped && (thisIndex < this->Length())) { int charSetIndex; bool match = false; for (charSetIndex = 0; charSetIndex < charSetLen; charSetIndex++) { if ((*this)[thisIndex] == charSet[charSetIndex]) { // a match match = true; break; } } if (!match) { // stop if no match stopped = true; } else { // a match, advance to next character --thisIndex; } } nString trimmedString; trimmedString.Set(this->Get(), thisIndex + 1); return trimmedString; } //------------------------------------------------------------------------------ inline nString nString::Trim(const char* charSet) const { return this->TrimLeft(charSet).TrimRight(charSet); } //------------------------------------------------------------------------------ inline nString nString::Substitute(const char* matchStr, const char* substStr) const { n_assert(matchStr && substStr); const char* ptr = this->Get(); int matchStrLen = strlen(matchStr); nString dest; // walk original string for occurrences of str const char* occur; while ((occur = strstr(ptr, matchStr))) { // append string fragment until match dest.AppendRange(ptr, occur - ptr); // append replacement string dest.Append(substStr); // adjust source pointer ptr = occur + matchStrLen; } dest.Append(ptr); return dest; } //------------------------------------------------------------------------------ inline void nString::UTF8toANSI() { uchar* src = (uchar*)this->Get(); uchar* dst = src; uchar c; while ((c = *src++)) { if (c >= 0x80) { if ((c & 0xE0) == 0xC0) { // a 2 byte sequence with 11 bits of information ushort wide = ((c & 0x1F) << 6) | (*src++ & 0x3F); if (wide > 0xff) { c = '?'; } else { c = (uchar) wide; } } else if ((c & 0xF0) == 0xE0) { // a 3 byte sequence with 16 bits of information c = '?'; src += 2; } else if ((c & 0xF8) == 0xF0) { // a 4 byte sequence with 21 bits of information c = '?'; src += 3; } else if ((c & 0xFC) == 0xF8) { // a 5 byte sequence with 26 bits of information c = '?'; src += 4; } else if ((c & 0xFE) == 0xFC) { // a 6 byte sequence with 31 bits of information c = '?'; src += 5; } } *dst++ = c; } *dst = 0; } //------------------------------------------------------------------------------ inline void nString::ANSItoUTF8() { n_assert(!this->IsEmpty()); int bufSize = this->Length() * 2 + 1; char* buffer = n_new_array(char, bufSize); char* dstPtr = buffer; const char* srcPtr = this->Get(); unsigned char c; while ((c = *srcPtr++)) { // note: this only covers the 2 cases that the character // is between 0 and 127 and between 128 and 255 if (c < 128) { *dstPtr++ = c; } else { *dstPtr++ = 192 + (c / 64); *dstPtr++ = 128 + (c % 64); } } *dstPtr = 0; this->Set(buffer); n_delete_array(buffer); } //------------------------------------------------------------------------------ inline void nString::SubstituteCharacter(char c, char subst) { char* ptr = (char*)this->Get(); int i; for (i = 0; i <= this->Length(); i++) { if (ptr[i] == c) { ptr[i] = subst; } } } //------------------------------------------------------------------------------ inline void nString::ConvertBackslashes() { this->SubstituteCharacter('\\', '/'); } //------------------------------------------------------------------------------ inline const char* nString::GetExtension() const { const char* str = this->Get(); const char* ext = strrchr(str, '.'); if (ext) { ext++; if (ext[0] != 0) { return ext; } } return 0; } //------------------------------------------------------------------------------ inline bool nString::CheckExtension(const char* ext) const { n_assert(ext); const char* extStr = this->GetExtension(); if (0 == extStr) { return false; } return (0 == (strcmp(ext, extStr))); } //------------------------------------------------------------------------------ inline void nString::StripExtension() { char* ext = (char*)this->GetExtension(); if (ext) { ext[-1] = 0; } this->SetLength(strlen(this->Get())); } //------------------------------------------------------------------------------ inline char* nString::GetLastSlash() const { char* s = (char*)this->Get(); char* lastSlash = strrchr(s, '/'); if (0 == lastSlash) lastSlash = strrchr(s, '\\'); if (0 == lastSlash) lastSlash = strrchr(s, ':'); return lastSlash; } //------------------------------------------------------------------------------ inline nString nString::ExtractFileName() const { nString pathString; char* lastSlash = this->GetLastSlash(); if (lastSlash) { pathString = &(lastSlash[1]); } else { pathString = this->Get(); } return pathString; } //------------------------------------------------------------------------------ inline nString nString::ExtractLastDirName() const { nString pathString(*this); char* lastSlash = pathString.GetLastSlash(); // special case if path ends with a slash if (lastSlash) { if (0 == lastSlash[1]) { *lastSlash = 0; lastSlash = pathString.GetLastSlash(); } char* secLastSlash = 0; if (0 != lastSlash) { *lastSlash = 0; // cut filename secLastSlash = pathString.GetLastSlash(); if (secLastSlash) { *secLastSlash = 0; return nString(secLastSlash+1); } } } return ""; } //------------------------------------------------------------------------------ inline nString nString::ExtractDirName() const { nString pathString(*this); char* lastSlash = pathString.GetLastSlash(); // special case if path ends with a slash if (lastSlash) { if (0 == lastSlash[1]) { *lastSlash = 0; lastSlash = pathString.GetLastSlash(); } if (lastSlash) { *++lastSlash = 0; } } pathString.SetLength(strlen(pathString.Get())); return pathString; } //------------------------------------------------------------------------------ inline nString nString::ExtractToLastSlash() const { nString pathString(*this); char* lastSlash = pathString.GetLastSlash(); if (lastSlash) { lastSlash[1] = 0; } else { pathString = ""; } return pathString; } //------------------------------------------------------------------------------ inline bool nString::MatchPattern(const nString& pattern) const { return n_strmatch(this->Get(), pattern.Get()); } //------------------------------------------------------------------------------ inline void nString::ReplaceChars(const char* charSet, char replacement) { n_assert(charSet); char* ptr = (char*)this->Get(); char c; while (0 != (c = *ptr)) { if (strchr(charSet, c)) { *ptr = replacement; } ptr++; } } //------------------------------------------------------------------------------ inline bool nString::CheckValidCharSet(const nString& charSet) const { int i; int len = this->Length(); for (i = 0; i < len; i++) { if (-1 == charSet.FindCharIndex((*this)[i], 0)) { return false; } } return true; } //------------------------------------------------------------------------------ inline bool nString::IsValidInt() const { return this->CheckValidCharSet(" \t-+01234567890"); } //------------------------------------------------------------------------------ inline bool nString::IsValidFloat() const { return this->CheckValidCharSet(" \t-+.e1234567890"); } //------------------------------------------------------------------------------ inline bool nString::IsValidBool() const { static const char* bools[] = { "no", "yes", "off", "on", "false", "tr