Index: trunk/include/VBox/com/string.h
===================================================================
--- trunk/include/VBox/com/string.h	(revision 36526)
+++ trunk/include/VBox/com/string.h	(revision 36527)
@@ -72,5 +72,5 @@
  *
  * The Bstr class hides all this handling behind a std::string-like interface
- * and also provides automatic conversions to MiniString and Utf8Str instances.
+ * and also provides automatic conversions to RTCString and Utf8Str instances.
  *
  * The one advantage of using the SysString* routines is that this makes it
@@ -117,5 +117,5 @@
 #endif
 
-    Bstr(const iprt::MiniString &that)
+    Bstr(const RTCString &that)
     {
         copyFrom(that.c_str());
@@ -426,11 +426,11 @@
  * String class used universally in Main for UTF-8 strings.
  *
- * This is based on iprt::MiniString, to which some functionality has been
+ * This is based on RTCString, to which some functionality has been
  * moved.  Here we keep things that are specific to Main, such as conversions
  * with UTF-16 strings (Bstr).
  *
- * Like iprt::MiniString, Utf8Str does not differentiate between NULL strings
+ * Like RTCString, Utf8Str does not differentiate between NULL strings
  * and empty strings.  In other words, Utf8Str("") and Utf8Str(NULL) behave the
- * same.  In both cases, MiniString allocates no memory, reports
+ * same.  In both cases, RTCString allocates no memory, reports
  * a zero length and zero allocated bytes for both, and returns an empty
  * C string from c_str().
@@ -440,5 +440,5 @@
  *          from external sources before passing them to Utf8Str or Bstr.
  */
-class Utf8Str : public iprt::MiniString
+class Utf8Str : public RTCString
 {
 public:
@@ -446,10 +446,10 @@
     Utf8Str() {}
 
-    Utf8Str(const MiniString &that)
-        : MiniString(that)
+    Utf8Str(const RTCString &that)
+        : RTCString(that)
     {}
 
     Utf8Str(const char *that)
-        : MiniString(that)
+        : RTCString(that)
     {}
 
@@ -472,14 +472,14 @@
      * @param   a_va            Argument vector containing the arguments
      *                          specified by the format string.
-     * @sa      iprt::MiniString::printfV
+     * @sa      RTCString::printfV
      */
     Utf8Str(const char *a_pszFormat, va_list a_va)
-        : MiniString(a_pszFormat, a_va)
-    {
-    }
-
-    Utf8Str& operator=(const MiniString &that)
-    {
-        MiniString::operator=(that);
+        : RTCString(a_pszFormat, a_va)
+    {
+    }
+
+    Utf8Str& operator=(const RTCString &that)
+    {
+        RTCString::operator=(that);
         return *this;
     }
@@ -487,5 +487,5 @@
     Utf8Str& operator=(const char *that)
     {
-        MiniString::operator=(that);
+        RTCString::operator=(that);
         return *this;
     }
@@ -572,5 +572,5 @@
 
 /**
- * Class with iprt::MiniString::printf as constructor for your convenience.
+ * Class with RTCString::printf as constructor for your convenience.
  *
  * Constructing a Utf8Str string object from a format string and a variable
Index: trunk/include/iprt/cpp/exception.h
===================================================================
--- trunk/include/iprt/cpp/exception.h	(revision 36526)
+++ trunk/include/iprt/cpp/exception.h	(revision 36527)
@@ -49,5 +49,5 @@
     }
 
-    RTCError(const iprt::MiniString &a_rstrMessage)
+    RTCError(const RTCString &a_rstrMessage)
         : m_strMsg(a_rstrMessage)
     {
@@ -87,5 +87,5 @@
 
     /** The exception message. */
-    iprt::MiniString m_strMsg;
+    RTCString m_strMsg;
 };
 
Index: trunk/include/iprt/cpp/list.h
===================================================================
--- trunk/include/iprt/cpp/list.h	(revision 36526)
+++ trunk/include/iprt/cpp/list.h	(revision 36527)
@@ -54,6 +54,6 @@
  * preallocated. To minimize the memory overhead, native types (that is
  * everything smaller then the size of void*) are directly saved in the array.
- * If bigger types are used (e.g. iprt::MiniString) the internal array is an
- * array of pointers to the objects.
+ * If bigger types are used (e.g. RTCString) the internal array is an array of
+ * pointers to the objects.
  *
  * The size of the internal array will usually not shrink, but grow
Index: trunk/include/iprt/cpp/ministring.h
===================================================================
--- trunk/include/iprt/cpp/ministring.h	(revision 36526)
+++ trunk/include/iprt/cpp/ministring.h	(revision 36527)
@@ -1,4 +1,4 @@
 /** @file
- * IPRT - Mini C++ string class.
+ * IPRT - C++ string class.
  */
 
@@ -24,6 +24,6 @@
  */
 
-#ifndef ___VBox_ministring_h
-#define ___VBox_ministring_h
+#ifndef ___iprt_cpp_ministring_h
+#define ___iprt_cpp_ministring_h
 
 #include <iprt/mem.h>
@@ -34,6 +34,4 @@
 #include <new>
 
-namespace iprt
-{
 
 /** @defgroup grp_rt_cpp_string     C++ String support
@@ -42,29 +40,29 @@
  */
 
-/** @brief  Mini C++ string class.
- *
- * "MiniString" is a small C++ string class that does not depend on anything
- * else except IPRT memory management functions.  Semantics are like in
- * std::string, except it can do a lot less.
- *
- * Note that MiniString does not differentiate between NULL strings and
- * empty strings. In other words, MiniString("") and MiniString(NULL)
- * behave the same. In both cases, MiniString allocates no memory, reports
+/** @brief  C++ string class.
+ *
+ * This is a C++ string class that does not depend on anything else except IPRT
+ * memory management functions.  Semantics are like in std::string, except it
+ * can do a lot less.
+ *
+ * Note that RTCString does not differentiate between NULL strings
+ * and empty strings.  In other words, RTCString("") and RTCString(NULL)
+ * behave the same.  In both cases, RTCString allocates no memory, reports
  * a zero length and zero allocated bytes for both, and returns an empty
  * C string from c_str().
  *
- * @note    MiniString ASSUMES that all strings it deals with are valid UTF-8.
+ * @note    RTCString ASSUMES that all strings it deals with are valid UTF-8.
  *          The caller is responsible for not breaking this assumption.
  */
 #ifdef VBOX
  /** @remarks Much of the code in here used to be in com::Utf8Str so that
-  *          com::Utf8Str can now derive from MiniString and only contain code
+  *          com::Utf8Str can now derive from RTCString and only contain code
   *          that is COM-specific, such as com::Bstr conversions.  Compared to
-  *          the old Utf8Str though, MiniString always knows the length of its
+  *          the old Utf8Str though, RTCString always knows the length of its
   *          member string and the size of the buffer so it can use memcpy()
   *          instead of strdup().
   */
 #endif
-class RT_DECL_CLASS MiniString
+class RT_DECL_CLASS RTCString
 {
 public:
@@ -72,5 +70,5 @@
      * Creates an empty string that has no memory allocated.
      */
-    MiniString()
+    RTCString()
         : m_psz(NULL),
           m_cch(0),
@@ -80,5 +78,5 @@
 
     /**
-     * Creates a copy of another MiniString.
+     * Creates a copy of another RTCString.
      *
      * This allocates s.length() + 1 bytes for the new instance, unless s is empty.
@@ -88,5 +86,5 @@
      * @throws  std::bad_alloc
      */
-    MiniString(const MiniString &a_rSrc)
+    RTCString(const RTCString &a_rSrc)
     {
         copyFromN(a_rSrc.m_psz, a_rSrc.m_cch);
@@ -102,5 +100,5 @@
      * @throws  std::bad_alloc
      */
-    MiniString(const char *pcsz)
+    RTCString(const char *pcsz)
     {
         copyFromN(pcsz, pcsz ? strlen(pcsz) : 0);
@@ -108,5 +106,5 @@
 
     /**
-     * Create a partial copy of another MiniString.
+     * Create a partial copy of another RTCString.
      *
      * @param   a_rSrc          The source string.
@@ -115,5 +113,5 @@
      *                          to copy from the source string.
      */
-    MiniString(const MiniString &a_rSrc, size_t a_offSrc, size_t a_cchSrc = npos)
+    RTCString(const RTCString &a_rSrc, size_t a_offSrc, size_t a_cchSrc = npos)
     {
         if (a_offSrc < a_rSrc.m_cch)
@@ -136,5 +134,5 @@
      *                          that for the va_list constructor.
      */
-    MiniString(const char *a_pszSrc, size_t a_cchSrc)
+    RTCString(const char *a_pszSrc, size_t a_cchSrc)
     {
         size_t cchMax = a_pszSrc ? RTStrNLen(a_pszSrc, a_cchSrc) : 0;
@@ -149,5 +147,5 @@
      * @param   a_ch            The character to fill the string with.
      */
-    MiniString(size_t a_cTimes, char a_ch)
+    RTCString(size_t a_cTimes, char a_ch)
         : m_psz(NULL),
           m_cch(0),
@@ -174,5 +172,5 @@
      * @remarks Not part of std::string.
      */
-    MiniString(const char *a_pszFormat, va_list a_va)
+    RTCString(const char *a_pszFormat, va_list a_va)
         : m_psz(NULL),
           m_cch(0),
@@ -185,5 +183,5 @@
      * Destructor.
      */
-    virtual ~MiniString()
+    virtual ~RTCString()
     {
         cleanup();
@@ -280,5 +278,5 @@
      * @returns Reference to the object.
      */
-    MiniString &operator=(const char *pcsz)
+    RTCString &operator=(const char *pcsz)
     {
         if (m_psz != pcsz)
@@ -300,5 +298,5 @@
      * @returns Reference to the object.
      */
-    MiniString &operator=(const MiniString &s)
+    RTCString &operator=(const RTCString &s)
     {
         if (this != &s)
@@ -322,5 +320,5 @@
      * @returns Reference to the object.
      */
-    MiniString &printf(const char *pszFormat, ...);
+    RTCString &printf(const char *pszFormat, ...);
 
     /**
@@ -336,5 +334,5 @@
      * @returns Reference to the object.
      */
-    MiniString &printfV(const char *pszFormat, va_list va);
+    RTCString &printfV(const char *pszFormat, va_list va);
 
     /**
@@ -347,5 +345,5 @@
      * @returns Reference to the object.
      */
-    MiniString &append(const MiniString &that);
+    RTCString &append(const RTCString &that);
 
     /**
@@ -358,5 +356,5 @@
      * @returns Reference to the object.
      */
-    MiniString &append(const char *pszThat);
+    RTCString &append(const char *pszThat);
 
     /**
@@ -369,5 +367,5 @@
      * @returns Reference to the object.
      */
-    MiniString &append(char ch);
+    RTCString &append(char ch);
 
     /**
@@ -380,8 +378,8 @@
      * @returns Reference to the object.
      */
-    MiniString &appendCodePoint(RTUNICP uc);
-
-    /**
-     * Shortcut to append(), MiniString variant.
+    RTCString &appendCodePoint(RTUNICP uc);
+
+    /**
+     * Shortcut to append(), RTCString variant.
      *
      * @param that              The string to append.
@@ -389,5 +387,5 @@
      * @returns Reference to the object.
      */
-    MiniString &operator+=(const MiniString &that)
+    RTCString &operator+=(const RTCString &that)
     {
         return append(that);
@@ -401,5 +399,5 @@
      * @returns                 Reference to the object.
      */
-    MiniString &operator+=(const char *pszThat)
+    RTCString &operator+=(const char *pszThat)
     {
         return append(pszThat);
@@ -413,5 +411,5 @@
      * @returns                 Reference to the object.
      */
-    MiniString &operator+=(char c)
+    RTCString &operator+=(char c)
     {
         return append(c);
@@ -423,5 +421,5 @@
      * @returns Reference to the object.
      */
-    MiniString &toUpper()
+    RTCString &toUpper()
     {
         if (length())
@@ -442,5 +440,5 @@
      * @returns Reference to the object.
      */
-    MiniString &toLower()
+    RTCString &toLower()
     {
         if (length())
@@ -494,5 +492,5 @@
      *         capacity() to find out how large that buffer is.
      *      -# After any operation that modifies the length of the string,
-     *         you _must_ call MiniString::jolt(), or subsequent copy operations
+     *         you _must_ call RTCString::jolt(), or subsequent copy operations
      *         may go nowhere.  Better not use mutableRaw() at all.
      */
@@ -582,5 +580,5 @@
 
     /**
-     * Compares the member string to another MiniString.
+     * Compares the member string to another RTCString.
      *
      * @param   pcszThat    The string to compare with.
@@ -589,5 +587,5 @@
      *          if larger.
      */
-    int compare(const MiniString &that, CaseSensitivity cs = CaseSensitive) const
+    int compare(const RTCString &that, CaseSensitivity cs = CaseSensitive) const
     {
         if (cs == CaseSensitive)
@@ -602,5 +600,5 @@
      * @param   that    The string to compare with.
      */
-    bool equals(const MiniString &that) const
+    bool equals(const RTCString &that) const
     {
         return that.length() == length()
@@ -629,5 +627,5 @@
      * @param   that    The string to compare with.
      */
-    bool equalsIgnoreCase(const MiniString &that) const
+    bool equalsIgnoreCase(const RTCString &that) const
     {
         /* Unfolded upper and lower case characters may require different
@@ -653,8 +651,8 @@
     /** @name Comparison operators.
      * @{  */
-    bool operator==(const MiniString &that) const { return equals(that); }
-    bool operator!=(const MiniString &that) const { return !equals(that); }
-    bool operator<( const MiniString &that) const { return compare(that) < 0; }
-    bool operator>( const MiniString &that) const { return compare(that) > 0; }
+    bool operator==(const RTCString &that) const { return equals(that); }
+    bool operator!=(const RTCString &that) const { return !equals(that); }
+    bool operator<( const RTCString &that) const { return compare(that) < 0; }
+    bool operator>( const RTCString &that) const { return compare(that) > 0; }
 
     bool operator==(const char *pszThat) const    { return equals(pszThat); }
@@ -709,7 +707,7 @@
      *                          n bytes have been copied.
      */
-    iprt::MiniString substr(size_t pos = 0, size_t n = npos) const
-    {
-        return MiniString(*this, pos, n);
+    RTCString substr(size_t pos = 0, size_t n = npos) const
+    {
+        return RTCString(*this, pos, n);
     }
 
@@ -725,5 +723,5 @@
      *                          been copied.
      */
-    iprt::MiniString substrCP(size_t pos = 0, size_t n = npos) const;
+    RTCString substrCP(size_t pos = 0, size_t n = npos) const;
 
     /**
@@ -734,5 +732,5 @@
      * @returns true if match, false if mismatch.
      */
-    bool endsWith(const iprt::MiniString &that, CaseSensitivity cs = CaseSensitive) const;
+    bool endsWith(const RTCString &that, CaseSensitivity cs = CaseSensitive) const;
 
     /**
@@ -742,5 +740,5 @@
      * @returns true if match, false if mismatch.
      */
-    bool startsWith(const iprt::MiniString &that, CaseSensitivity cs = CaseSensitive) const;
+    bool startsWith(const RTCString &that, CaseSensitivity cs = CaseSensitive) const;
 
     /**
@@ -751,5 +749,5 @@
      * @returns true if match, false if mismatch.
      */
-    bool contains(const iprt::MiniString &that, CaseSensitivity cs = CaseSensitive) const;
+    bool contains(const RTCString &that, CaseSensitivity cs = CaseSensitive) const;
 
     /**
@@ -827,6 +825,6 @@
      * @returns separated strings as string list.
      */
-    iprt::list<iprt::MiniString, iprt::MiniString *> split(const iprt::MiniString &a_rstrSep,
-                                                           SplitMode a_enmMode = RemoveEmptyParts);
+    iprt::list<RTCString, RTCString *> split(const RTCString &a_rstrSep,
+                                             SplitMode a_enmMode = RemoveEmptyParts);
 
     /**
@@ -837,6 +835,6 @@
      * @returns joined string.
      */
-    static iprt::MiniString join(const iprt::list<iprt::MiniString, iprt::MiniString *> &a_rList,
-                                 const iprt::MiniString &a_rstrSep = "");
+    static RTCString join(const iprt::list<RTCString, RTCString *> &a_rList,
+                          const RTCString &a_rstrSep = "");
 
 protected:
@@ -917,5 +915,4 @@
 /** @} */
 
-} /* namespace iprt */
 
 /** @addtogroup grp_rt_cpp_string
@@ -930,7 +927,7 @@
  * @returns the concatenate string.
  *
- * @relates iprt::MiniString
+ * @relates RTCString
  */
-RTDECL(const iprt::MiniString) operator+(const iprt::MiniString &a_rstr1, const iprt::MiniString &a_rstr2);
+RTDECL(const RTCString) operator+(const RTCString &a_rstr1, const RTCString &a_rstr2);
 
 /**
@@ -941,7 +938,7 @@
  * @returns the concatenate string.
  *
- * @relates iprt::MiniString
+ * @relates RTCString
  */
-RTDECL(const iprt::MiniString) operator+(const iprt::MiniString &a_rstr1, const char *a_psz2);
+RTDECL(const RTCString) operator+(const RTCString &a_rstr1, const char *a_psz2);
 
 /**
@@ -952,7 +949,7 @@
  * @returns the concatenate string.
  *
- * @relates iprt::MiniString
+ * @relates RTCString
  */
-RTDECL(const iprt::MiniString) operator+(const char *a_psz1, const iprt::MiniString &a_rstr2);
+RTDECL(const RTCString) operator+(const char *a_psz1, const RTCString &a_rstr2);
 
 /** @} */
Index: trunk/include/iprt/cpp/xml.h
===================================================================
--- trunk/include/iprt/cpp/xml.h	(revision 36526)
+++ trunk/include/iprt/cpp/xml.h	(revision 36527)
@@ -465,6 +465,6 @@
     const AttributeNode* findAttribute(const char *pcszMatch) const;
     bool getAttributeValue(const char *pcszMatch, const char *&ppcsz) const;
-    bool getAttributeValue(const char *pcszMatch, iprt::MiniString &str) const;
-    bool getAttributeValuePath(const char *pcszMatch, iprt::MiniString &str) const;
+    bool getAttributeValue(const char *pcszMatch, RTCString &str) const;
+    bool getAttributeValuePath(const char *pcszMatch, RTCString &str) const;
     bool getAttributeValue(const char *pcszMatch, int32_t &i) const;
     bool getAttributeValue(const char *pcszMatch, uint32_t &i) const;
@@ -476,5 +476,5 @@
 
     ContentNode* addContent(const char *pcszContent);
-    ContentNode* addContent(const iprt::MiniString &strContent)
+    ContentNode* addContent(const RTCString &strContent)
     {
         return addContent(strContent.c_str());
@@ -482,9 +482,9 @@
 
     AttributeNode* setAttribute(const char *pcszName, const char *pcszValue);
-    AttributeNode* setAttribute(const char *pcszName, const iprt::MiniString &strValue)
+    AttributeNode* setAttribute(const char *pcszName, const RTCString &strValue)
     {
         return setAttribute(pcszName, strValue.c_str());
     }
-    AttributeNode* setAttributePath(const char *pcszName, const iprt::MiniString &strValue);
+    AttributeNode* setAttributePath(const char *pcszName, const RTCString &strValue);
     AttributeNode* setAttribute(const char *pcszName, int32_t i);
     AttributeNode* setAttribute(const char *pcszName, uint32_t i);
@@ -550,5 +550,5 @@
     AttributeNode(const AttributeNode &x);      // no copying
 
-    iprt::MiniString    m_strKey;
+    RTCString    m_strKey;
 
     friend class Node;
@@ -651,5 +651,5 @@
     ~XmlMemParser();
 
-    void read(const void* pvBuf, size_t cbSize, const iprt::MiniString &strFilename, Document &doc);
+    void read(const void* pvBuf, size_t cbSize, const RTCString &strFilename, Document &doc);
 };
 
@@ -665,5 +665,5 @@
     ~XmlFileParser();
 
-    void read(const iprt::MiniString &strFilename, Document &doc);
+    void read(const RTCString &strFilename, Document &doc);
 
 private:
