ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

3 files changed, 604 insertions, 543 deletions

diff --git a/intern/string/CMakeLists.txt b/intern/string/CMakeLists.txt
index 3f436c79a69..8c400f320ae 100644
--- a/intern/string/CMakeLists.txt
+++ b/intern/string/CMakeLists.txt
@@ -19,7 +19,7 @@
 # ***** END GPL LICENSE BLOCK *****
 
 set(INC
-	.
+  .
 )
 
 set(INC_SYS
@@ -27,9 +27,9 @@ set(INC_SYS
 )
 
 set(SRC
-	intern/STR_String.cpp
+  intern/STR_String.cpp
 
-	STR_String.h
+  STR_String.h
 )
 
 set(LIB
diff --git a/intern/string/STR_String.h b/intern/string/STR_String.h
index 27db035429c..5516f14bafa 100644
--- a/intern/string/STR_String.h
+++ b/intern/string/STR_String.h
@@ -25,8 +25,8 @@
 #define __STR_STRING_H__
 
 #ifndef STR_NO_ASSERTD
-#undef  assertd
-#define	assertd(exp)			((void)NULL)
+#  undef assertd
+#  define assertd(exp) ((void)NULL)
 #endif
 
 #include <vector>
@@ -36,174 +36,331 @@
 #include <cstdlib>
 
 #ifdef WITH_CXX_GUARDEDALLOC
-#include "MEM_guardedalloc.h"
+#  include "MEM_guardedalloc.h"
 #endif
 
 #ifdef _WIN32
-#define stricmp _stricmp
+#  define stricmp _stricmp
 #endif
 
 class STR_String;
 
-typedef  unsigned long dword;
-typedef const STR_String& rcSTR_String;
+typedef unsigned long dword;
+typedef const STR_String &rcSTR_String;
 typedef unsigned char byte;
 
 /**
  * Smart String Value class. Is used by parser when an expression tree is build containing string.
  */
 
-class STR_String
-{
-public:
-	// Initialization
-	STR_String();
-	STR_String(char c);
-	STR_String(char c, int len);
-	STR_String(const char *str);
-	STR_String(const char *str, int len);
-	STR_String(const STR_String &str);
-	STR_String(const STR_String & str, int len);
-	STR_String(const char *src1, int src1_len, const char *src2, int src2_len);
-	explicit STR_String(int val);
-	explicit STR_String(dword val);
-	explicit STR_String(float val);
-	explicit STR_String(double val);
-	inline ~STR_String()											{ delete[] this->m_data; }
-
-	// Operations
-	STR_String&			Format(const char *fmt, ...)				// Set formatted text to string
+class STR_String {
+ public:
+  // Initialization
+  STR_String();
+  STR_String(char c);
+  STR_String(char c, int len);
+  STR_String(const char *str);
+  STR_String(const char *str, int len);
+  STR_String(const STR_String &str);
+  STR_String(const STR_String &str, int len);
+  STR_String(const char *src1, int src1_len, const char *src2, int src2_len);
+  explicit STR_String(int val);
+  explicit STR_String(dword val);
+  explicit STR_String(float val);
+  explicit STR_String(double val);
+  inline ~STR_String()
+  {
+    delete[] this->m_data;
+  }
+
+  // Operations
+  STR_String &Format(const char *fmt, ...)  // Set formatted text to string
 #ifdef __GNUC__
-	__attribute__ ((format(printf, 2, 3)))
+      __attribute__((format(printf, 2, 3)))
 #endif
-	;
-	STR_String&			FormatAdd(const char *fmt, ...)				// Add formatted text to string
+      ;
+  STR_String &FormatAdd(const char *fmt, ...)  // Add formatted text to string
 #ifdef __GNUC__
-	__attribute__ ((format(printf, 2, 3)))
+      __attribute__((format(printf, 2, 3)))
 #endif
-	;
-	inline void			Clear()										{ this->m_len = this->m_data[0] = 0; }
-	inline const STR_String	& Reverse()
-	{
-		for (int i1 = 0, i2 = this->m_len - 1; i1 < i2; i1++, i2--) {
-			std::swap(this->m_data[i1], this->m_data[i2]);
-		}
-		return *this;
-	}
-
-	// Properties
-	bool				IsUpper() const;
-	bool				IsLower() const;
-	inline bool			IsEmpty() const								{ return this->m_len == 0; }
-	inline int			Length() const								{ return this->m_len; }
-
-	// Data access
-	inline STR_String&	SetLength(int len)							{ AllocBuffer(len, true); this->m_len = len; this->m_data[len] = 0; return *this; }
-	inline char			GetAt(int pos) const						{ assertd(pos<this->m_len); return this->m_data[pos]; }
-	inline void			SetAt(int pos, char c)						{ assertd(pos<this->m_len); this->m_data[pos] = c; }
-	inline void			SetAt(int pos, rcSTR_String str);
-	inline void			SetAt(int pos, int num, rcSTR_String str);
-	void				Replace(int pos, rcSTR_String str);
-	void				Replace(int pos, int num, rcSTR_String str);
-
-	// Substrings
-	inline STR_String	Left(int num) const							{ num = (num < this->m_len ? num:this->m_len ); return STR_String(this->m_data, num); }
-	inline STR_String	Right(int num) const						{ num = (num < this->m_len ? num:this->m_len ); return STR_String(this->m_data + this->m_len - num, num); }
-	inline STR_String	Mid(int pos, int num = INT_MAX) const		{ pos = (pos < this->m_len ? pos:this->m_len ); num = (num < (this->m_len - pos) ? num : (this->m_len - pos)); return STR_String(this->m_data + pos, num); }
-
-	// Comparison
-	int					Compare(rcSTR_String rhs) const;
-	int					CompareNoCase(rcSTR_String rhs) const;
-	inline bool			IsEqual(rcSTR_String rhs) const				{ return (Compare(rhs) == 0); }
-	inline bool			IsEqualNoCase(rcSTR_String rhs) const		{ return (CompareNoCase(rhs) == 0); }
-
-	// Search/replace
-	int					Find(char c, int pos = 0) const;
-	int					Find(const char *str, int pos = 0) const;
-	int					Find(rcSTR_String str, int pos = 0) const;
-	int					RFind(char c) const;
-	int					FindOneOf(const char *set, int pos = 0) const;
-	int					RFindOneOf(const char *set, int pos = 0) const;
-
-	std::vector<STR_String> Explode(char c) const;
-
-	// Formatting
-	STR_String&			Upper();
-	STR_String&			Lower();
-	STR_String&			Capitalize();
-	STR_String&			TrimLeft();
-	STR_String&			TrimLeft(char *set);
-	STR_String&			TrimRight();
-	STR_String&			TrimRight(char *set);
-	STR_String&			Trim();
-	STR_String&			Trim(char *set);
-	STR_String&			TrimQuotes();
-
-	// Conversions
-//	inline operator char*()								{ return this->m_data; }
-	inline operator const char *() const				{ return this->m_data; }
-	inline char *Ptr()									{ return this->m_data; }
-	inline const char *ReadPtr() const					{ return this->m_data; }
-	inline float	ToFloat() const						{ float x=(float)(atof(this->m_data)); return x; }
-	inline int		ToInt() const						{ return atoi(this->m_data); }
-
-	// Operators
-	inline rcSTR_String	operator=(const byte *rhs)		{ return Copy((const char *)rhs, strlen((const char *)rhs)); }
-	inline rcSTR_String	operator=(rcSTR_String rhs)		{ return Copy(rhs.ReadPtr(), rhs.Length()); }
-	inline rcSTR_String	operator=(char rhs)				{ return Copy(&rhs, 1); }
-	inline rcSTR_String	operator=(const char *rhs)		{ return Copy(rhs, strlen(rhs)); }
-
-	inline rcSTR_String	operator+=(const char *rhs)		{ return Concat(rhs, strlen(rhs)); }
-	inline rcSTR_String	operator+=(rcSTR_String rhs)	{ return Concat(rhs.ReadPtr(), rhs.Length()); }
-	inline rcSTR_String	operator+=(char rhs)			{ return Concat(&rhs, 1); }
-
-
-	inline friend bool operator<(rcSTR_String      lhs, rcSTR_String     rhs)	{ return (strcmp(lhs, rhs)<0); }
-	inline friend bool operator<(rcSTR_String      lhs, const char      *rhs)	{ return (strcmp(lhs, rhs)<0); }
-	inline friend bool operator<(const char       *lhs, rcSTR_String     rhs)	{ return (strcmp(lhs, rhs)<0); }
-	inline friend bool operator>(rcSTR_String      lhs, rcSTR_String     rhs)	{ return (strcmp(lhs, rhs)>0); }
-	inline friend bool operator>(rcSTR_String      lhs, const char      *rhs)	{ return (strcmp(lhs, rhs)>0); }
-	inline friend bool operator>(const char       *lhs, rcSTR_String     rhs)	{ return (strcmp(lhs, rhs)>0); }
-	inline friend bool operator<=(rcSTR_String     lhs, rcSTR_String     rhs)	{ return (strcmp(lhs, rhs)<=0); }
-	inline friend bool operator<=(rcSTR_String     lhs, const char      *rhs)	{ return (strcmp(lhs, rhs)<=0); }
-	inline friend bool operator<=(const char      *lhs, rcSTR_String     rhs)	{ return (strcmp(lhs, rhs)<=0); }
-	inline friend bool operator>=(rcSTR_String     lhs, rcSTR_String     rhs)	{ return (strcmp(lhs, rhs)>=0); }
-	inline friend bool operator>=(rcSTR_String     lhs, const char      *rhs)	{ return (strcmp(lhs, rhs)>=0); }
-	inline friend bool operator>=(const char      *lhs, rcSTR_String     rhs)	{ return (strcmp(lhs, rhs)>=0); }
-	inline friend bool operator==(rcSTR_String     lhs, rcSTR_String     rhs)	{ return ((lhs.Length() == rhs.Length()) && (memcmp(lhs, rhs, lhs.Length()) == 0)); }
-	inline friend bool operator==(rcSTR_String     lhs, const char      *rhs)	{ return (strncmp(lhs, rhs, lhs.Length() + 1) == 0); }
-	inline friend bool operator==(const char      *lhs, rcSTR_String     rhs)	{ return (strncmp(lhs, rhs, rhs.Length() + 1) == 0); }
-	inline friend bool operator!=(rcSTR_String     lhs, rcSTR_String     rhs)	{ return ((lhs.Length() != rhs.Length()) || (memcmp(lhs, rhs, lhs.Length()) != 0)); }
-	inline friend bool operator!=(rcSTR_String     lhs, const char      *rhs)	{ return (strncmp(lhs, rhs, lhs.Length() + 1) != 0); }
-	inline friend bool operator!=(const char       *lhs, rcSTR_String    rhs)	{ return (strncmp(lhs, rhs, rhs.Length() + 1) != 0); }
-
-	// serializing
-	//int			Serialize(pCStream stream);
-
-protected:
-	// Implementation
-	void	AllocBuffer(int len, bool keep_contents);
-	rcSTR_String Copy(const char *src, int len);
-	rcSTR_String Concat(const char *data, int len);
-
-	static bool		isLower(char c)									{ return !isUpper(c); }
-	static bool		isUpper(char c)									{ return (c>='A') && (c <= 'Z'); }
-	static bool		isSpace(char c)									{ return (c==' ') || (c=='\t'); }
-
-	char  *m_data;													// -> STR_String data
-	int    m_len;													//z Data length
-	int    m_max;													// Space in data buffer
-
+      ;
+  inline void Clear()
+  {
+    this->m_len = this->m_data[0] = 0;
+  }
+  inline const STR_String &Reverse()
+  {
+    for (int i1 = 0, i2 = this->m_len - 1; i1 < i2; i1++, i2--) {
+      std::swap(this->m_data[i1], this->m_data[i2]);
+    }
+    return *this;
+  }
+
+  // Properties
+  bool IsUpper() const;
+  bool IsLower() const;
+  inline bool IsEmpty() const
+  {
+    return this->m_len == 0;
+  }
+  inline int Length() const
+  {
+    return this->m_len;
+  }
+
+  // Data access
+  inline STR_String &SetLength(int len)
+  {
+    AllocBuffer(len, true);
+    this->m_len = len;
+    this->m_data[len] = 0;
+    return *this;
+  }
+  inline char GetAt(int pos) const
+  {
+    assertd(pos < this->m_len);
+    return this->m_data[pos];
+  }
+  inline void SetAt(int pos, char c)
+  {
+    assertd(pos < this->m_len);
+    this->m_data[pos] = c;
+  }
+  inline void SetAt(int pos, rcSTR_String str);
+  inline void SetAt(int pos, int num, rcSTR_String str);
+  void Replace(int pos, rcSTR_String str);
+  void Replace(int pos, int num, rcSTR_String str);
+
+  // Substrings
+  inline STR_String Left(int num) const
+  {
+    num = (num < this->m_len ? num : this->m_len);
+    return STR_String(this->m_data, num);
+  }
+  inline STR_String Right(int num) const
+  {
+    num = (num < this->m_len ? num : this->m_len);
+    return STR_String(this->m_data + this->m_len - num, num);
+  }
+  inline STR_String Mid(int pos, int num = INT_MAX) const
+  {
+    pos = (pos < this->m_len ? pos : this->m_len);
+    num = (num < (this->m_len - pos) ? num : (this->m_len - pos));
+    return STR_String(this->m_data + pos, num);
+  }
+
+  // Comparison
+  int Compare(rcSTR_String rhs) const;
+  int CompareNoCase(rcSTR_String rhs) const;
+  inline bool IsEqual(rcSTR_String rhs) const
+  {
+    return (Compare(rhs) == 0);
+  }
+  inline bool IsEqualNoCase(rcSTR_String rhs) const
+  {
+    return (CompareNoCase(rhs) == 0);
+  }
+
+  // Search/replace
+  int Find(char c, int pos = 0) const;
+  int Find(const char *str, int pos = 0) const;
+  int Find(rcSTR_String str, int pos = 0) const;
+  int RFind(char c) const;
+  int FindOneOf(const char *set, int pos = 0) const;
+  int RFindOneOf(const char *set, int pos = 0) const;
+
+  std::vector<STR_String> Explode(char c) const;
+
+  // Formatting
+  STR_String &Upper();
+  STR_String &Lower();
+  STR_String &Capitalize();
+  STR_String &TrimLeft();
+  STR_String &TrimLeft(char *set);
+  STR_String &TrimRight();
+  STR_String &TrimRight(char *set);
+  STR_String &Trim();
+  STR_String &Trim(char *set);
+  STR_String &TrimQuotes();
+
+  // Conversions
+  //  inline operator char*()                             { return this->m_data; }
+  inline operator const char *() const
+  {
+    return this->m_data;
+  }
+  inline char *Ptr()
+  {
+    return this->m_data;
+  }
+  inline const char *ReadPtr() const
+  {
+    return this->m_data;
+  }
+  inline float ToFloat() const
+  {
+    float x = (float)(atof(this->m_data));
+    return x;
+  }
+  inline int ToInt() const
+  {
+    return atoi(this->m_data);
+  }
+
+  // Operators
+  inline rcSTR_String operator=(const byte *rhs)
+  {
+    return Copy((const char *)rhs, strlen((const char *)rhs));
+  }
+  inline rcSTR_String operator=(rcSTR_String rhs)
+  {
+    return Copy(rhs.ReadPtr(), rhs.Length());
+  }
+  inline rcSTR_String operator=(char rhs)
+  {
+    return Copy(&rhs, 1);
+  }
+  inline rcSTR_String operator=(const char *rhs)
+  {
+    return Copy(rhs, strlen(rhs));
+  }
+
+  inline rcSTR_String operator+=(const char *rhs)
+  {
+    return Concat(rhs, strlen(rhs));
+  }
+  inline rcSTR_String operator+=(rcSTR_String rhs)
+  {
+    return Concat(rhs.ReadPtr(), rhs.Length());
+  }
+  inline rcSTR_String operator+=(char rhs)
+  {
+    return Concat(&rhs, 1);
+  }
+
+  inline friend bool operator<(rcSTR_String lhs, rcSTR_String rhs)
+  {
+    return (strcmp(lhs, rhs) < 0);
+  }
+  inline friend bool operator<(rcSTR_String lhs, const char *rhs)
+  {
+    return (strcmp(lhs, rhs) < 0);
+  }
+  inline friend bool operator<(const char *lhs, rcSTR_String rhs)
+  {
+    return (strcmp(lhs, rhs) < 0);
+  }
+  inline friend bool operator>(rcSTR_String lhs, rcSTR_String rhs)
+  {
+    return (strcmp(lhs, rhs) > 0);
+  }
+  inline friend bool operator>(rcSTR_String lhs, const char *rhs)
+  {
+    return (strcmp(lhs, rhs) > 0);
+  }
+  inline friend bool operator>(const char *lhs, rcSTR_String rhs)
+  {
+    return (strcmp(lhs, rhs) > 0);
+  }
+  inline friend bool operator<=(rcSTR_String lhs, rcSTR_String rhs)
+  {
+    return (strcmp(lhs, rhs) <= 0);
+  }
+  inline friend bool operator<=(rcSTR_String lhs, const char *rhs)
+  {
+    return (strcmp(lhs, rhs) <= 0);
+  }
+  inline friend bool operator<=(const char *lhs, rcSTR_String rhs)
+  {
+    return (strcmp(lhs, rhs) <= 0);
+  }
+  inline friend bool operator>=(rcSTR_String lhs, rcSTR_String rhs)
+  {
+    return (strcmp(lhs, rhs) >= 0);
+  }
+  inline friend bool operator>=(rcSTR_String lhs, const char *rhs)
+  {
+    return (strcmp(lhs, rhs) >= 0);
+  }
+  inline friend bool operator>=(const char *lhs, rcSTR_String rhs)
+  {
+    return (strcmp(lhs, rhs) >= 0);
+  }
+  inline friend bool operator==(rcSTR_String lhs, rcSTR_String rhs)
+  {
+    return ((lhs.Length() == rhs.Length()) && (memcmp(lhs, rhs, lhs.Length()) == 0));
+  }
+  inline friend bool operator==(rcSTR_String lhs, const char *rhs)
+  {
+    return (strncmp(lhs, rhs, lhs.Length() + 1) == 0);
+  }
+  inline friend bool operator==(const char *lhs, rcSTR_String rhs)
+  {
+    return (strncmp(lhs, rhs, rhs.Length() + 1) == 0);
+  }
+  inline friend bool operator!=(rcSTR_String lhs, rcSTR_String rhs)
+  {
+    return ((lhs.Length() != rhs.Length()) || (memcmp(lhs, rhs, lhs.Length()) != 0));
+  }
+  inline friend bool operator!=(rcSTR_String lhs, const char *rhs)
+  {
+    return (strncmp(lhs, rhs, lhs.Length() + 1) != 0);
+  }
+  inline friend bool operator!=(const char *lhs, rcSTR_String rhs)
+  {
+    return (strncmp(lhs, rhs, rhs.Length() + 1) != 0);
+  }
+
+  // serializing
+  //int           Serialize(pCStream stream);
+
+ protected:
+  // Implementation
+  void AllocBuffer(int len, bool keep_contents);
+  rcSTR_String Copy(const char *src, int len);
+  rcSTR_String Concat(const char *data, int len);
+
+  static bool isLower(char c)
+  {
+    return !isUpper(c);
+  }
+  static bool isUpper(char c)
+  {
+    return (c >= 'A') && (c <= 'Z');
+  }
+  static bool isSpace(char c)
+  {
+    return (c == ' ') || (c == '\t');
+  }
+
+  char *m_data;  // -> STR_String data
+  int m_len;     //z Data length
+  int m_max;     // Space in data buffer
 
 #ifdef WITH_CXX_GUARDEDALLOC
-	MEM_CXX_CLASS_ALLOC_FUNCS("CXX:STR_String")
+  MEM_CXX_CLASS_ALLOC_FUNCS("CXX:STR_String")
 #endif
 };
 
-inline  STR_String operator+(rcSTR_String    lhs, rcSTR_String rhs)	{ return STR_String(lhs.ReadPtr(), lhs.Length(), rhs.ReadPtr(), rhs.Length()); }
-inline  STR_String operator+(rcSTR_String    lhs, char         rhs)	{ return STR_String(lhs.ReadPtr(), lhs.Length(), &rhs, 1); }
-inline  STR_String operator+(char            lhs, rcSTR_String rhs)	{ return STR_String(&lhs, 1, rhs.ReadPtr(), rhs.Length()); }
-inline  STR_String operator+(rcSTR_String    lhs, const char  *rhs)	{ return STR_String(lhs.ReadPtr(), lhs.Length(), rhs, strlen(rhs)); }
-inline  STR_String operator+(const char     *lhs, rcSTR_String rhs)	{ return STR_String(lhs, strlen(lhs), rhs.ReadPtr(), rhs.Length()); }
+inline STR_String operator+(rcSTR_String lhs, rcSTR_String rhs)
+{
+  return STR_String(lhs.ReadPtr(), lhs.Length(), rhs.ReadPtr(), rhs.Length());
+}
+inline STR_String operator+(rcSTR_String lhs, char rhs)
+{
+  return STR_String(lhs.ReadPtr(), lhs.Length(), &rhs, 1);
+}
+inline STR_String operator+(char lhs, rcSTR_String rhs)
+{
+  return STR_String(&lhs, 1, rhs.ReadPtr(), rhs.Length());
+}
+inline STR_String operator+(rcSTR_String lhs, const char *rhs)
+{
+  return STR_String(lhs.ReadPtr(), lhs.Length(), rhs, strlen(rhs));
+}
+inline STR_String operator+(const char *lhs, rcSTR_String rhs)
+{
+  return STR_String(lhs, strlen(lhs), rhs.ReadPtr(), rhs.Length());
+}
 
-#endif //__STR_STRING_H__
+#endif  //__STR_STRING_H__
diff --git a/intern/string/intern/STR_String.cpp b/intern/string/intern/STR_String.cpp
index b674871fbf3..b2134550ea9 100644
--- a/intern/string/intern/STR_String.cpp
+++ b/intern/string/intern/STR_String.cpp
@@ -32,700 +32,604 @@
 #include "STR_String.h"
 
 /*-------------------------------------------------------------------------------------------------
-	Construction / destruction
+  Construction / destruction
 -------------------------------------------------------------------------------------------------*/
 
-#define STR_STRING_SIZE_DEFAULT_WORD 32  /* default size for a new word */
-#define STR_STRING_SIZE_DEFAULT_CHAR 9   /* default size for a new char */
+#define STR_STRING_SIZE_DEFAULT_WORD 32 /* default size for a new word */
+#define STR_STRING_SIZE_DEFAULT_CHAR 9  /* default size for a new char */
 
 //
 // Construct an empty string
 //
-STR_String::STR_String() :
-	m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]),
-	m_len(0),
-	m_max(STR_STRING_SIZE_DEFAULT_WORD)
+STR_String::STR_String()
+    : m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]), m_len(0), m_max(STR_STRING_SIZE_DEFAULT_WORD)
 {
-	this->m_data[0] = 0;
+  this->m_data[0] = 0;
 }
 
-
-
 //
 // Construct a string of one character
 //
-STR_String::STR_String(char c) :
-	m_data(new char[STR_STRING_SIZE_DEFAULT_CHAR]),
-	m_len(1),
-	m_max(STR_STRING_SIZE_DEFAULT_CHAR)
+STR_String::STR_String(char c)
+    : m_data(new char[STR_STRING_SIZE_DEFAULT_CHAR]), m_len(1), m_max(STR_STRING_SIZE_DEFAULT_CHAR)
 {
-	this->m_data[0] = c;
-	this->m_data[1] = 0;
+  this->m_data[0] = c;
+  this->m_data[1] = 0;
 }
 
-
-
 //
 // Construct a string of multiple repeating characters
 //
-STR_String::STR_String(char c, int len) :
-	m_data(new char[len + 8]),
-	m_len(len),
-	m_max(len + 8)
+STR_String::STR_String(char c, int len) : m_data(new char[len + 8]), m_len(len), m_max(len + 8)
 {
-	assertd(this->m_data != NULL);
-	memset(this->m_data, c, len);
-	this->m_data[len] = 0;
+  assertd(this->m_data != NULL);
+  memset(this->m_data, c, len);
+  this->m_data[len] = 0;
 }
 
-
-
 //
 // Construct a string from a pointer-to-ASCIIZ-string
 //
 // MAART: Changed to test for null strings
 STR_String::STR_String(const char *str)
 {
-	if (str) {
-		this->m_len = ::strlen(str);
-		this->m_max = this->m_len + 8;
-		this->m_data = new char[this->m_max];
-		assertd(this->m_data != NULL);
-		::memcpy(this->m_data, str, this->m_len);
-		this->m_data[this->m_len] = 0;
-	}
-	else {
-		this->m_data = NULL;
-		this->m_len = 0;
-		this->m_max = 8;
-	}
+  if (str) {
+    this->m_len = ::strlen(str);
+    this->m_max = this->m_len + 8;
+    this->m_data = new char[this->m_max];
+    assertd(this->m_data != NULL);
+    ::memcpy(this->m_data, str, this->m_len);
+    this->m_data[this->m_len] = 0;
+  }
+  else {
+    this->m_data = NULL;
+    this->m_len = 0;
+    this->m_max = 8;
+  }
 }
 
-
-
 //
 // Construct a string from a pointer-to-ASCII-string and a length
 //
-STR_String::STR_String(const char *str, int len) :
-	m_data(new char[len + 8]),
-	m_len(len),
-	m_max(len + 8)
+STR_String::STR_String(const char *str, int len)
+    : m_data(new char[len + 8]), m_len(len), m_max(len + 8)
 {
-	assertd(this->m_data != NULL);
-	memcpy(this->m_data, str, len);
-	this->m_data[len] = 0;
+  assertd(this->m_data != NULL);
+  memcpy(this->m_data, str, len);
+  this->m_data[len] = 0;
 }
 
-
-
 //
 // Construct a string from another string
 //
-STR_String::STR_String(rcSTR_String str) :
-	m_data(new char[str.Length() + 8]),
-	m_len(str.Length()),
-	m_max(str.Length() + 8)
+STR_String::STR_String(rcSTR_String str)
+    : m_data(new char[str.Length() + 8]), m_len(str.Length()), m_max(str.Length() + 8)
 {
-	assertd(this->m_data != NULL);
-	assertd(str.this->m_data != NULL);
-	memcpy(this->m_data, str.ReadPtr(), str.Length());
-	this->m_data[str.Length()] = 0;
+  assertd(this->m_data != NULL);
+  assertd(str.this->m_data != NULL);
+  memcpy(this->m_data, str.ReadPtr(), str.Length());
+  this->m_data[str.Length()] = 0;
 }
 
-
-
 //
 // Construct a string from the first number of characters in another string
 //
-STR_String::STR_String(rcSTR_String str, int len) :
-	m_data(new char[len + 8]),
-	m_len(len),
-	m_max(len + 8)
+STR_String::STR_String(rcSTR_String str, int len)
+    : m_data(new char[len + 8]), m_len(len), m_max(len + 8)
 {
-	assertd(this->m_data != NULL);
-	assertd(str.this->m_data != NULL);
-	memcpy(this->m_data, str.ReadPtr(), str.Length());
-	this->m_data[str.Length()] = 0;
+  assertd(this->m_data != NULL);
+  assertd(str.this->m_data != NULL);
+  memcpy(this->m_data, str.ReadPtr(), str.Length());
+  this->m_data[str.Length()] = 0;
 }
 
-
-
 //
 // Create a string by concatenating two sources
 //
-STR_String::STR_String(const char *src1, int len1, const char *src2, int len2) :
-	m_data(new char[len1 + len2 + 8]),
-	m_len(len1 + len2),
-	m_max(len1 + len2 + 8)
+STR_String::STR_String(const char *src1, int len1, const char *src2, int len2)
+    : m_data(new char[len1 + len2 + 8]), m_len(len1 + len2), m_max(len1 + len2 + 8)
 {
-	assertd(this->m_data != NULL);
-	memcpy(this->m_data, src1, len1);
-	memcpy(this->m_data + len1, src2, len2);
-	this->m_data[len1 + len2] = 0;
+  assertd(this->m_data != NULL);
+  memcpy(this->m_data, src1, len1);
+  memcpy(this->m_data + len1, src2, len2);
+  this->m_data[len1 + len2] = 0;
 }
 
-
-
 //
 // Create a string with an integer value
 //
-STR_String::STR_String(int val) :
-	m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]),
-	m_max(STR_STRING_SIZE_DEFAULT_WORD)
+STR_String::STR_String(int val)
+    : m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]), m_max(STR_STRING_SIZE_DEFAULT_WORD)
 {
-	assertd(this->m_data != NULL);
-	this->m_len = sprintf(this->m_data, "%d", val);
+  assertd(this->m_data != NULL);
+  this->m_len = sprintf(this->m_data, "%d", val);
 }
 
-
-
-
 //
 // Create a string with a dword value
 //
-STR_String::STR_String(dword val) :
-	m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]),
-	m_max(STR_STRING_SIZE_DEFAULT_WORD)
+STR_String::STR_String(dword val)
+    : m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]), m_max(STR_STRING_SIZE_DEFAULT_WORD)
 {
-	assertd(this->m_data != NULL);
-	this->m_len = sprintf(this->m_data, "%lu", val);
+  assertd(this->m_data != NULL);
+  this->m_len = sprintf(this->m_data, "%lu", val);
 }
 
-
-
 //
 // Create a string with a floating point value
 //
-STR_String::STR_String(float val) :
-	m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]),
-	m_max(STR_STRING_SIZE_DEFAULT_WORD)
+STR_String::STR_String(float val)
+    : m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]), m_max(STR_STRING_SIZE_DEFAULT_WORD)
 {
-	assertd(this->m_data != NULL);
-	this->m_len = sprintf(this->m_data, "%g", val);
+  assertd(this->m_data != NULL);
+  this->m_len = sprintf(this->m_data, "%g", val);
 }
 
-
-
 //
 // Create a string with a double value
 //
-STR_String::STR_String(double val) :
-	m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]),
-	m_max(STR_STRING_SIZE_DEFAULT_WORD)
+STR_String::STR_String(double val)
+    : m_data(new char[STR_STRING_SIZE_DEFAULT_WORD]), m_max(STR_STRING_SIZE_DEFAULT_WORD)
 {
-	assertd(this->m_data != NULL);
-	this->m_len = sprintf(this->m_data, "%g", val);
+  assertd(this->m_data != NULL);
+  this->m_len = sprintf(this->m_data, "%g", val);
 }
 
-
-
 /*-------------------------------------------------------------------------------------------------
-	Buffer management
+  Buffer management
 -------------------------------------------------------------------------------------------------*/
 
-
-
 //
 // Make sure that the allocated buffer is at least <len> in size
 //
 void STR_String::AllocBuffer(int len, bool keep_contents)
 {
-	// Check if we have enough space
-	if (len + 1 <= this->m_max) return;
+  // Check if we have enough space
+  if (len + 1 <= this->m_max)
+    return;
 
-	// Reallocate string
-	char *new_data = new char[len + 8];
-	if (keep_contents) {
-		memcpy(new_data, this->m_data, this->m_len);
-	}
-	delete[] this->m_data;
+  // Reallocate string
+  char *new_data = new char[len + 8];
+  if (keep_contents) {
+    memcpy(new_data, this->m_data, this->m_len);
+  }
+  delete[] this->m_data;
 
-	// Accept new data
-	this->m_max = len + 8;
-	this->m_data = new_data;
-	assertd(this->m_data != NULL);
+  // Accept new data
+  this->m_max = len + 8;
+  this->m_data = new_data;
+  assertd(this->m_data != NULL);
 }
 
-
-
 /*-------------------------------------------------------------------------------------------------
-	Basic string operations
+  Basic string operations
 -------------------------------------------------------------------------------------------------*/
 
-
-
 //
 // Format string (as does sprintf)
 //
-STR_String& STR_String::Format(const char *fmt, ...)
+STR_String &STR_String::Format(const char *fmt, ...)
 {
-	AllocBuffer(2048, false);
+  AllocBuffer(2048, false);
 
-	assertd(this->m_data != NULL);
-	// Expand arguments and format to string
-	va_list args;
-	va_start(args, fmt);
-	this->m_len = vsprintf(this->m_data, fmt, args);
-	assertd(this->m_len <= 2048);
-	va_end(args);
+  assertd(this->m_data != NULL);
+  // Expand arguments and format to string
+  va_list args;
+  va_start(args, fmt);
+  this->m_len = vsprintf(this->m_data, fmt, args);
+  assertd(this->m_len <= 2048);
+  va_end(args);
 
-	return *this;
+  return *this;
 }
 
-
-
 //
 // Format string (as does sprintf)
 //
-STR_String& STR_String::FormatAdd(const char *fmt, ...)
+STR_String &STR_String::FormatAdd(const char *fmt, ...)
 {
-	AllocBuffer(2048, false);
+  AllocBuffer(2048, false);
 
-	assertd(this->m_data != NULL);
-	// Expand arguments and format to string
-	va_list args;
-	va_start(args, fmt);
-	this->m_len += vsprintf(this->m_data + this->m_len, fmt, args);
-	assertd(this->m_len <= 2048);
-	va_end(args);
+  assertd(this->m_data != NULL);
+  // Expand arguments and format to string
+  va_list args;
+  va_start(args, fmt);
+  this->m_len += vsprintf(this->m_data + this->m_len, fmt, args);
+  assertd(this->m_len <= 2048);
+  va_end(args);
 
-	return *this;
+  return *this;
 }
 
-
-
 /*-------------------------------------------------------------------------------------------------
-	Properties
+  Properties
 -------------------------------------------------------------------------------------------------*/
 
-
-
 //
 // Check if string is entirely in UPPERCase
 //
 bool STR_String::IsUpper() const
 {
-	for (int i = 0; i < this->m_len; i++)
-		if (isLower(this->m_data[i]))
-			return false;
+  for (int i = 0; i < this->m_len; i++)
+    if (isLower(this->m_data[i]))
+      return false;
 
-	return true;
+  return true;
 }
 
-
-
 //
 // Check if string is entirely in lowerCase
 //
 bool STR_String::IsLower() const
 {
-	for (int i = 0; i < this->m_len; i++)
-		if (isUpper(this->m_data[i]))
-			return false;
+  for (int i = 0; i < this->m_len; i++)
+    if (isUpper(this->m_data[i]))
+      return false;
 
-	return true;
+  return true;
 }
 
-
-
 /*-------------------------------------------------------------------------------------------------
-	Search/Replace
+  Search/Replace
 -------------------------------------------------------------------------------------------------*/
 
-
-
 //
 // Find the first orccurence of <c> in the string
 //
 int STR_String::Find(char c, int pos) const
 {
-	assertd(pos >= 0);
-	assertd(this->m_len == 0 || pos < this->m_len);
-	assertd(this->m_data != NULL);
-	char *find_pos = strchr(this->m_data + pos, c);
-	return (find_pos) ? (find_pos - this->m_data) : -1;
+  assertd(pos >= 0);
+  assertd(this->m_len == 0 || pos < this->m_len);
+  assertd(this->m_data != NULL);
+  char *find_pos = strchr(this->m_data + pos, c);
+  return (find_pos) ? (find_pos - this->m_data) : -1;
 }
 
-
-
 //
 // Find the first occurrence of <str> in the string
 //
 int STR_String::Find(const char *str, int pos) const
 {
-	assertd(pos >= 0);
-	assertd(this->m_len == 0 || pos < this->m_len);
-	assertd(this->m_data != NULL);
-	char *find_pos = strstr(this->m_data + pos, str);
-	return (find_pos) ? (find_pos - this->m_data) : -1;
+  assertd(pos >= 0);
+  assertd(this->m_len == 0 || pos < this->m_len);
+  assertd(this->m_data != NULL);
+  char *find_pos = strstr(this->m_data + pos, str);
+  return (find_pos) ? (find_pos - this->m_data) : -1;
 }
 
-
-
 //
 // Find the first occurrence of <str> in the string
 //
 int STR_String::Find(rcSTR_String str, int pos) const
 {
-	assertd(pos >= 0);
-	assertd(this->m_len == 0 || pos < this->m_len);
-	assertd(this->m_data != NULL);
-	char *find_pos = strstr(this->m_data + pos, str.ReadPtr());
-	return (find_pos) ? (find_pos - this->m_data) : -1;
+  assertd(pos >= 0);
+  assertd(this->m_len == 0 || pos < this->m_len);
+  assertd(this->m_data != NULL);
+  char *find_pos = strstr(this->m_data + pos, str.ReadPtr());
+  return (find_pos) ? (find_pos - this->m_data) : -1;
 }
 
-
-
 //
 // Find the last occurrence of <c> in the string
 //
 int STR_String::RFind(char c) const
 {
-	assertd(this->m_data != NULL);
-	char *pos = strrchr(this->m_data, c);
-	return (pos) ? (pos - this->m_data) : -1;
+  assertd(this->m_data != NULL);
+  char *pos = strrchr(this->m_data, c);
+  return (pos) ? (pos - this->m_data) : -1;
 }
 
-
-
 //
 // Find the first occurrence of any character in character set <set> in the string
 //
 int STR_String::FindOneOf(const char *set, int pos) const
 {
-	assertd(pos >= 0);
-	assertd(this->m_len == 0 || pos < this->m_len);
-	assertd(this->m_data != NULL);
-	char *find_pos = strpbrk(this->m_data + pos, set);
-	return (find_pos) ? (find_pos - this->m_data) : -1;
+  assertd(pos >= 0);
+  assertd(this->m_len == 0 || pos < this->m_len);
+  assertd(this->m_data != NULL);
+  char *find_pos = strpbrk(this->m_data + pos, set);
+  return (find_pos) ? (find_pos - this->m_data) : -1;
 }
 
-
-
 //
 // Replace a character in this string with another string
 //
 void STR_String::Replace(int pos, rcSTR_String str)
 {
-	//bounds(pos, 0, Length()-1);
+  //bounds(pos, 0, Length()-1);
 
-	if (str.Length() < 1)
-	{
-		// Remove one character from the string
-		memcpy(this->m_data + pos, this->m_data + pos + 1, this->m_len - pos);
-	}
-	else {
-		// Insert zero or more characters into the string
-		AllocBuffer(this->m_len + str.Length() - 1, true);
-		if (str.Length() != 1) memcpy(this->m_data + pos + str.Length(), this->m_data + pos + 1, Length() - pos);
-		memcpy(this->m_data + pos, str.ReadPtr(), str.Length());
-	}
+  if (str.Length() < 1) {
+    // Remove one character from the string
+    memcpy(this->m_data + pos, this->m_data + pos + 1, this->m_len - pos);
+  }
+  else {
+    // Insert zero or more characters into the string
+    AllocBuffer(this->m_len + str.Length() - 1, true);
+    if (str.Length() != 1)
+      memcpy(this->m_data + pos + str.Length(), this->m_data + pos + 1, Length() - pos);
+    memcpy(this->m_data + pos, str.ReadPtr(), str.Length());
+  }
 
-	this->m_len += str.Length() - 1;
+  this->m_len += str.Length() - 1;
 }
 
-
-
 //
 // Replace a substring of this string with another string
 //
 void STR_String::Replace(int pos, int num, rcSTR_String str)
 {
-	//bounds(pos, 0, Length()-1);
-	//bounds(pos+num, 0, Length());
-	assertd(num >= 1);
+  //bounds(pos, 0, Length()-1);
+  //bounds(pos+num, 0, Length());
+  assertd(num >= 1);
 
-	if (str.Length() < num)
-	{
-		// Remove some data from the string by replacement
-		memcpy(this->m_data + pos + str.Length(), this->m_data + pos + num, this->m_len - pos - num + 1);
-		memcpy(this->m_data + pos, str.ReadPtr(), str.Length());
-	}
-	else {
-		// Insert zero or more characters into the string
-		AllocBuffer(this->m_len + str.Length() - num, true);
-		if (str.Length() != num) memcpy(this->m_data + pos + str.Length(), this->m_data + pos + num, Length() - pos - num + 1);
-		memcpy(this->m_data + pos, str.ReadPtr(), str.Length());
-	}
+  if (str.Length() < num) {
+    // Remove some data from the string by replacement
+    memcpy(
+        this->m_data + pos + str.Length(), this->m_data + pos + num, this->m_len - pos - num + 1);
+    memcpy(this->m_data + pos, str.ReadPtr(), str.Length());
+  }
+  else {
+    // Insert zero or more characters into the string
+    AllocBuffer(this->m_len + str.Length() - num, true);
+    if (str.Length() != num)
+      memcpy(
+          this->m_data + pos + str.Length(), this->m_data + pos + num, Length() - pos - num + 1);
+    memcpy(this->m_data + pos, str.ReadPtr(), str.Length());
+  }
 
-	this->m_len += str.Length() - num;
+  this->m_len += str.Length() - num;
 }
 
-
-
 /*-------------------------------------------------------------------------------------------------
-	Comparison
+  Comparison
 -------------------------------------------------------------------------------------------------*/
 
-
-
 //
 // Compare two strings and return the result, <0 if *this<rhs, >0 if *this>rhs or 0 if *this==rhs
 //
 int STR_String::Compare(rcSTR_String rhs) const
 {
-	return strcmp(this->ReadPtr(), rhs.ReadPtr());
+  return strcmp(this->ReadPtr(), rhs.ReadPtr());
 }
 
-
-
 //
 // Compare two strings without respecting case and return the result, <0 if *this<rhs, >0 if *this>rhs or 0 if *this==rhs
 //
 int STR_String::CompareNoCase(rcSTR_String rhs) const
 {
 #ifdef WIN32
-	return stricmp(this->ReadPtr(), rhs.ReadPtr());
+  return stricmp(this->ReadPtr(), rhs.ReadPtr());
 #else
-	return strcasecmp(this->ReadPtr(), rhs.ReadPtr());
+  return strcasecmp(this->ReadPtr(), rhs.ReadPtr());
 #endif
 }
 
-
-
 /*-------------------------------------------------------------------------------------------------
-	Formatting
+  Formatting
 -------------------------------------------------------------------------------------------------*/
 
-
-
 //
 // Capitalize string, "heLLo" -> "HELLO"
 //
-STR_String& STR_String::Upper()
+STR_String &STR_String::Upper()
 {
-	assertd(this->m_data != NULL);
+  assertd(this->m_data != NULL);
 #ifdef WIN32
-	_strupr(this->m_data);
+  _strupr(this->m_data);
 #else
-	for (int i = 0; i < this->m_len; i++)
-		this->m_data[i] = (this->m_data[i] >= 'a' && this->m_data[i] <= 'z') ? this->m_data[i] + 'A' - 'a' : this->m_data[i];
+  for (int i = 0; i < this->m_len; i++)
+    this->m_data[i] = (this->m_data[i] >= 'a' && this->m_data[i] <= 'z') ?
+                          this->m_data[i] + 'A' - 'a' :
+                          this->m_data[i];
 #endif
-	return *this;
+  return *this;
 }
 
-
-
 //
 // Lower string, "heLLo" -> "hello"
 //
-STR_String& STR_String::Lower()
+STR_String &STR_String::Lower()
 {
-	assertd(this->m_data != NULL);
+  assertd(this->m_data != NULL);
 #ifdef WIN32
-	_strlwr(this->m_data);
+  _strlwr(this->m_data);
 #else
-	for (int i = 0; i < this->m_len; i++)
-		this->m_data[i] = (this->m_data[i] >= 'A' && this->m_data[i] <= 'Z') ? this->m_data[i] + 'a' - 'A' : this->m_data[i];
+  for (int i = 0; i < this->m_len; i++)
+    this->m_data[i] = (this->m_data[i] >= 'A' && this->m_data[i] <= 'Z') ?
+                          this->m_data[i] + 'a' - 'A' :
+                          this->m_data[i];
 #endif
-	return *this;
+  return *this;
 }
 
-
-
 //
 // Capitalize string, "heLLo" -> "Hello"
 //
-STR_String& STR_String::Capitalize()
+STR_String &STR_String::Capitalize()
 {
-	assertd(this->m_data != NULL);
+  assertd(this->m_data != NULL);
 #ifdef WIN32
-	if (this->m_len > 0) this->m_data[0] = toupper(this->m_data[0]);
-	if (this->m_len > 1) _strlwr(this->m_data + 1);
+  if (this->m_len > 0)
+    this->m_data[0] = toupper(this->m_data[0]);
+  if (this->m_len > 1)
+    _strlwr(this->m_data + 1);
 #else
-	if (this->m_len > 0)
-		this->m_data[0] = (this->m_data[0] >= 'a' && this->m_data[0] <= 'z') ? this->m_data[0] + 'A' - 'a' : this->m_data[0];
-	for (int i = 1; i < this->m_len; i++)
-		this->m_data[i] = (this->m_data[i] >= 'A' && this->m_data[i] <= 'Z') ? this->m_data[i] + 'a' - 'A' : this->m_data[i];
+  if (this->m_len > 0)
+    this->m_data[0] = (this->m_data[0] >= 'a' && this->m_data[0] <= 'z') ?
+                          this->m_data[0] + 'A' - 'a' :
+                          this->m_data[0];
+  for (int i = 1; i < this->m_len; i++)
+    this->m_data[i] = (this->m_data[i] >= 'A' && this->m_data[i] <= 'Z') ?
+                          this->m_data[i] + 'a' - 'A' :
+                          this->m_data[i];
 #endif
-	return *this;
+  return *this;
 }
 
-
-
 //
 // Trim whitespace from the left side of the string
 //
-STR_String& STR_String::TrimLeft()
+STR_String &STR_String::TrimLeft()
 {
-	int skip;
-	assertd(this->m_data != NULL);
-	for (skip = 0; isSpace(this->m_data[skip]); skip++, this->m_len--) {
-		/* pass */
-	}
-	memmove(this->m_data, this->m_data + skip, this->m_len + 1);
-	return *this;
+  int skip;
+  assertd(this->m_data != NULL);
+  for (skip = 0; isSpace(this->m_data[skip]); skip++, this->m_len--) {
+    /* pass */
+  }
+  memmove(this->m_data, this->m_data + skip, this->m_len + 1);
+  return *this;
 }
 
-
-
 //
 // Trim whitespaces from the right side of the string
 //
-STR_String& STR_String::TrimRight()
+STR_String &STR_String::TrimRight()
 {
-	assertd(this->m_data != NULL);
-	while (this->m_len && isSpace(this->m_data[this->m_len - 1])) this->m_len--;
-	this->m_data[this->m_len] = 0;
-	return *this;
+  assertd(this->m_data != NULL);
+  while (this->m_len && isSpace(this->m_data[this->m_len - 1]))
+    this->m_len--;
+  this->m_data[this->m_len] = 0;
+  return *this;
 }
 
-
-
 //
 // Trim spaces from both sides of the character set
 //
-STR_String& STR_String::Trim()
+STR_String &STR_String::Trim()
 {
-	TrimRight();
-	TrimLeft();
-	return *this;
+  TrimRight();
+  TrimLeft();
+  return *this;
 }
 
-
-
 //
 // Trim characters from the character set <set> from the left side of the string
 //
-STR_String& STR_String::TrimLeft(char *set)
+STR_String &STR_String::TrimLeft(char *set)
 {
-	int skip;
-	assertd(this->m_data != NULL);
-	for (skip = 0; this->m_len && strchr(set, this->m_data[skip]); skip++, this->m_len--) {
-		/* pass */
-	}
-	memmove(this->m_data, this->m_data + skip, this->m_len + 1);
-	return *this;
+  int skip;
+  assertd(this->m_data != NULL);
+  for (skip = 0; this->m_len && strchr(set, this->m_data[skip]); skip++, this->m_len--) {
+    /* pass */
+  }
+  memmove(this->m_data, this->m_data + skip, this->m_len + 1);
+  return *this;
 }
 
-
-
 //
 // Trim characters from the character set <set> from the right side of the string
 //
-STR_String& STR_String::TrimRight(char *set)
+STR_String &STR_String::TrimRight(char *set)
 {
-	assertd(this->m_data != NULL);
-	while (this->m_len && strchr(set, this->m_data[this->m_len - 1])) this->m_len--;
-	this->m_data[this->m_len] = 0;
-	return *this;
+  assertd(this->m_data != NULL);
+  while (this->m_len && strchr(set, this->m_data[this->m_len - 1]))
+    this->m_len--;
+  this->m_data[this->m_len] = 0;
+  return *this;
 }
 
-
-
 //
 // Trim characters from the character set <set> from both sides of the character set
 //
-STR_String& STR_String::Trim(char *set)
+STR_String &STR_String::Trim(char *set)
 {
-	TrimRight(set);
-	TrimLeft(set);
-	return *this;
+  TrimRight(set);
+  TrimLeft(set);
+  return *this;
 }
 
-
-
 //
 // Trim quotes from both sides of the string
 //
-STR_String& STR_String::TrimQuotes()
+STR_String &STR_String::TrimQuotes()
 {
-	// Trim quotes if they are on both sides of the string
-	assertd(this->m_data != NULL);
-	if ((this->m_len >= 2) && (this->m_data[0] == '\"') && (this->m_data[this->m_len - 1] == '\"'))
-	{
-		memmove(this->m_data, this->m_data + 1, this->m_len - 2 + 1);
-		this->m_len -= 2;
-	}
-	return *this;
+  // Trim quotes if they are on both sides of the string
+  assertd(this->m_data != NULL);
+  if ((this->m_len >= 2) && (this->m_data[0] == '\"') && (this->m_data[this->m_len - 1] == '\"')) {
+    memmove(this->m_data, this->m_data + 1, this->m_len - 2 + 1);
+    this->m_len -= 2;
+  }
+  return *this;
 }
 
-
-
 /*-------------------------------------------------------------------------------------------------
-	Assignment/Concatenation
+  Assignment/Concatenation
 -------------------------------------------------------------------------------------------------*/
 
-
-
 //
 // Set the string's conents to a copy of <src> with length <len>
 //
 rcSTR_String STR_String::Copy(const char *src, int len)
 {
-	assertd(len >= 0);
-	assertd(src);
-	assertd(this->m_data != NULL);
+  assertd(len >= 0);
+  assertd(src);
+  assertd(this->m_data != NULL);
 
-	AllocBuffer(len, false);
-	this->m_len = len;
-	memcpy(this->m_data, src, len);
-	this->m_data[this->m_len] = 0;
+  AllocBuffer(len, false);
+  this->m_len = len;
+  memcpy(this->m_data, src, len);
+  this->m_data[this->m_len] = 0;
 
-	return *this;
+  return *this;
 }
 
-
-
 //
 // Concate a number of bytes to the current string
 //
 rcSTR_String STR_String::Concat(const char *data, int len)
 {
-	assertd(this->m_len >= 0);
-	assertd(len >= 0);
-	assertd(data);
-	assertd(this->m_data != NULL);
+  assertd(this->m_len >= 0);
+  assertd(len >= 0);
+  assertd(data);
+  assertd(this->m_data != NULL);
 
-	AllocBuffer(this->m_len + len, true);
-	memcpy(this->m_data + this->m_len, data, len);
-	this->m_len += len;
-	this->m_data[this->m_len] = 0;
+  AllocBuffer(this->m_len + len, true);
+  memcpy(this->m_data + this->m_len, data, len);
+  this->m_len += len;
+  this->m_data[this->m_len] = 0;
 
-	return *this;
+  return *this;
 }
 
-
 std::vector<STR_String> STR_String::Explode(char c) const
 {
-	STR_String lcv = *this;
-	std::vector<STR_String> uc;
+  STR_String lcv = *this;
+  std::vector<STR_String> uc;
 
-	while (lcv.Length()) {
-		int pos = lcv.Find(c);
-		if (pos < 0) {
-			uc.push_back(lcv);
-			lcv.Clear();
-		}
-		else {
-			uc.push_back(lcv.Left(pos));
-			lcv = lcv.Mid(pos + 1);
-		}
-	}
+  while (lcv.Length()) {
+    int pos = lcv.Find(c);
+    if (pos < 0) {
+      uc.push_back(lcv);
+      lcv.Clear();
+    }
+    else {
+      uc.push_back(lcv.Left(pos));
+      lcv = lcv.Mid(pos + 1);
+    }
+  }
 
-	//uc. -= STR_String("");
+  //uc. -= STR_String("");
 
-	return uc;
+  return uc;
 }
 
-
 #if 0
 
-int		STR_String::Serialize(pCStream stream)
-{
-	if (stream->GetAccess() == CStream::Access_Read) {
-		int ln;
-		stream->Read(&ln, sizeof(ln));
-		AllocBuffer(ln, false);
-		stream->Read(this->m_data, ln);
-		this->m_data[ln]	= '\0';
-		this->m_len			= ln;
-	}
-	else {
-		stream->Write(&this->m_len, sizeof(this->m_len));
-		stream->Write(this->m_data, this->m_len);
-	}
-
-	return this->m_len + sizeof(this->m_len);
+int     STR_String::Serialize(pCStream stream)
+{
+  if (stream->GetAccess() == CStream::Access_Read) {
+    int ln;
+    stream->Read(&ln, sizeof(ln));
+    AllocBuffer(ln, false);
+    stream->Read(this->m_data, ln);
+    this->m_data[ln]    = '\0';
+    this->m_len         = ln;
+  }
+  else {
+    stream->Write(&this->m_len, sizeof(this->m_len));
+    stream->Write(this->m_data, this->m_len);
+  }
+
+  return this->m_len + sizeof(this->m_len);
 }
 #endif