Cleanup: remove unused string module

This is legacy code that can simply be replaced by std::string.

4 files changed, 0 insertions, 1042 deletions

diff --git a/intern/CMakeLists.txt b/intern/CMakeLists.txt
index 4e780dc9f0f..fa18f4d793a 100644
--- a/intern/CMakeLists.txt
+++ b/intern/CMakeLists.txt
@@ -20,7 +20,6 @@
 
 # add_subdirectory(atomic)  # header only
 add_subdirectory(clog)
-add_subdirectory(string)
 add_subdirectory(ghost)
 add_subdirectory(guardedalloc)
 add_subdirectory(libmv)
diff --git a/intern/string/CMakeLists.txt b/intern/string/CMakeLists.txt
deleted file mode 100644
index 8c400f320ae..00000000000
--- a/intern/string/CMakeLists.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software Foundation,
-# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# The Original Code is Copyright (C) 2006, Blender Foundation
-# All rights reserved.
-# ***** END GPL LICENSE BLOCK *****
-
-set(INC
-  .
-)
-
-set(INC_SYS
-
-)
-
-set(SRC
-  intern/STR_String.cpp
-
-  STR_String.h
-)
-
-set(LIB
-)
-
-blender_add_lib(bf_intern_string "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
diff --git a/intern/string/STR_String.h b/intern/string/STR_String.h
deleted file mode 100644
index 97b23345f91..00000000000
--- a/intern/string/STR_String.h
+++ /dev/null
@@ -1,366 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- */
-
-/** \file
- * \ingroup string
- */
-
-#ifndef __STR_STRING_H__
-#define __STR_STRING_H__
-
-#ifndef STR_NO_ASSERTD
-#  undef assertd
-#  define assertd(exp) ((void)NULL)
-#endif
-
-#include <limits.h>
-#include <vector>
-
-#include <cstdlib>
-#include <cstring>
-
-#ifdef WITH_CXX_GUARDEDALLOC
-#  include "MEM_guardedalloc.h"
-#endif
-
-#ifdef _WIN32
-#  define stricmp _stricmp
-#endif
-
-class STR_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
-#ifdef __GNUC__
-      __attribute__((format(printf, 2, 3)))
-#endif
-      ;
-  STR_String &FormatAdd(const char *fmt, ...)  // Add formatted text to string
-#ifdef __GNUC__
-      __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
-
-#ifdef WITH_CXX_GUARDEDALLOC
-  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());
-}
-
-#endif  //__STR_STRING_H__
diff --git a/intern/string/intern/STR_String.cpp b/intern/string/intern/STR_String.cpp
deleted file mode 100644
index 306e786969b..00000000000
--- a/intern/string/intern/STR_String.cpp
+++ /dev/null
@@ -1,637 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- */
-
-/** \file
- * \ingroup string
- *
- * Copyright (C) 2001 NaN Technologies B.V.
- * This file was formerly known as: GEN_StdString.cpp.
- */
-
-#include "STR_String.h"
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/*-------------------------------------------------------------------------------------------------
-  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 */
-
-//
-// 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)
-{
-  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)
-{
-  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)
-{
-  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;
-  }
-}
-
-//
-// 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)
-{
-  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)
-{
-  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)
-{
-  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)
-{
-  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)
-{
-  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)
-{
-  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)
-{
-  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)
-{
-  assertd(this->m_data != NULL);
-  this->m_len = sprintf(this->m_data, "%g", val);
-}
-
-/*-------------------------------------------------------------------------------------------------
-  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;
-
-  // 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);
-}
-
-/*-------------------------------------------------------------------------------------------------
-  Basic string operations
--------------------------------------------------------------------------------------------------*/
-
-//
-// Format string (as does sprintf)
-//
-STR_String &STR_String::Format(const char *fmt, ...)
-{
-  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);
-
-  return *this;
-}
-
-//
-// Format string (as does sprintf)
-//
-STR_String &STR_String::FormatAdd(const char *fmt, ...)
-{
-  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);
-
-  return *this;
-}
-
-/*-------------------------------------------------------------------------------------------------
-  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;
-
-  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;
-
-  return true;
-}
-
-/*-------------------------------------------------------------------------------------------------
-  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;
-}
-
-//
-// 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;
-}
-
-//
-// 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;
-}
-
-//
-// 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;
-}
-
-//
-// 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;
-}
-
-//
-// Replace a character in this string with another string
-//
-void STR_String::Replace(int pos, rcSTR_String str)
-{
-  // 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());
-  }
-
-  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);
-
-  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;
-}
-
-/*-------------------------------------------------------------------------------------------------
-  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());
-}
-
-//
-// 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());
-#else
-  return strcasecmp(this->ReadPtr(), rhs.ReadPtr());
-#endif
-}
-
-/*-------------------------------------------------------------------------------------------------
-  Formatting
--------------------------------------------------------------------------------------------------*/
-
-//
-// Capitalize string, "heLLo" -> "HELLO"
-//
-STR_String &STR_String::Upper()
-{
-  assertd(this->m_data != NULL);
-#ifdef WIN32
-  _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];
-#endif
-  return *this;
-}
-
-//
-// Lower string, "heLLo" -> "hello"
-//
-STR_String &STR_String::Lower()
-{
-  assertd(this->m_data != NULL);
-#ifdef WIN32
-  _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];
-#endif
-  return *this;
-}
-
-//
-// Capitalize string, "heLLo" -> "Hello"
-//
-STR_String &STR_String::Capitalize()
-{
-  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);
-#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];
-#endif
-  return *this;
-}
-
-//
-// Trim whitespace from the left side of the string
-//
-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;
-}
-
-//
-// Trim whitespaces from the right side of the string
-//
-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;
-}
-
-//
-// Trim spaces from both sides of the character set
-//
-STR_String &STR_String::Trim()
-{
-  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)
-{
-  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)
-{
-  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)
-{
-  TrimRight(set);
-  TrimLeft(set);
-  return *this;
-}
-
-//
-// Trim quotes from both sides of the string
-//
-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;
-}
-
-/*-------------------------------------------------------------------------------------------------
-  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);
-
-  AllocBuffer(len, false);
-  this->m_len = len;
-  memcpy(this->m_data, src, len);
-  this->m_data[this->m_len] = 0;
-
-  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);
-
-  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;
-}
-
-std::vector<STR_String> STR_String::Explode(char c) const
-{
-  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);
-    }
-  }
-
-  // uc. -= STR_String("");
-
-  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);
-}
-#endif