]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/string.h
fixedb ug with normalization of UNC paths (patch 558701)
[wxWidgets.git] / include / wx / string.h
index 51583c89a355333cd55a87df7654b7e1b8cf11b8..af6c1ab17f76a2f55751fb60cdd3d5f63c5e86ed 100644 (file)
@@ -79,7 +79,7 @@
 
 // implementation only
 #define   wxASSERT_VALID_INDEX(i) \
-    wxASSERT_MSG( (size_t)(i) <= Len(), _T("invaid index in wxString") )
+    wxASSERT_MSG( (size_t)(i) <= Len(), _T("invalid index in wxString") )
 
 // ----------------------------------------------------------------------------
 // constants
@@ -259,20 +259,20 @@ private:
   void Reinit() { GetStringData()->Unlock(); Init(); }
 
   // memory allocation
-    // allocates memory for string of lenght nLen
-  void AllocBuffer(size_t nLen);
+    // allocates memory for string of length nLen
+  bool AllocBuffer(size_t nLen);
     // copies data to another string
-  void AllocCopy(wxString&, int, int) const;
+  bool AllocCopy(wxString&, int, int) const;
     // effectively copies data to string
-  void AssignCopy(size_t, const wxChar *);
+  bool AssignCopy(size_t, const wxChar *);
 
   // append a (sub)string
-  void ConcatSelf(int nLen, const wxChar *src);
+  bool ConcatSelf(int nLen, const wxChar *src);
 
   // functions called before writing to the string: they copy it if there
   // are other references to our data (should be the only owner when writing)
-  void CopyBeforeWrite();
-  void AllocBeforeWrite(size_t);
+  bool CopyBeforeWrite();
+  bool AllocBeforeWrite(size_t);
 
   // if we hadn't made these operators private, it would be possible to
   // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
@@ -292,11 +292,12 @@ private:
 public:
   // constructors and destructor
     // ctor for an empty string
-  wxString() { Init(); }
+  wxString() : m_pchData(NULL) { Init(); }
     // copy ctor
-  wxString(const wxString& stringSrc)
+  wxString(const wxString& stringSrc) : m_pchData(NULL)
   {
-    wxASSERT( stringSrc.GetStringData()->IsValid() );
+    wxASSERT_MSG( stringSrc.GetStringData()->IsValid(),
+                  _T("did you forget to call UngetWriteBuf()?") );
 
     if ( stringSrc.IsEmpty() ) {
       // nothing to do for an empty string
@@ -312,9 +313,11 @@ public:
     // ctor takes first nLength characters from C string
     // (default value of wxSTRING_MAXLEN means take all the string)
   wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
-    { InitWith(psz, 0, nLength); }
+      : m_pchData(NULL)
+      { InitWith(psz, 0, nLength); }
   wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = wxSTRING_MAXLEN)
-    { InitWith(psz, 0, nLength); }
+      : m_pchData(NULL)
+      { InitWith(psz, 0, nLength); }
 
 #if wxUSE_UNICODE
     // from multibyte string
@@ -327,7 +330,8 @@ public:
 #else // ANSI
     // from C string (for compilers using unsigned char)
   wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
-    { InitWith((const char*)psz, 0, nLength); }
+      : m_pchData(NULL)
+      { InitWith((const char*)psz, 0, nLength); }
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string
@@ -336,7 +340,8 @@ public:
 
     // from wxCharBuffer
   wxString(const wxCharBuffer& psz)
-    { InitWith(psz, 0, wxSTRING_MAXLEN); }
+      : m_pchData(NULL)
+      { InitWith(psz, 0, wxSTRING_MAXLEN); }
 #endif // Unicode/ANSI
 
     // dtor is not virtual, this class must not be inherited from!
@@ -364,8 +369,9 @@ public:
     if ( !GetStringData()->IsEmpty() )
       Reinit();
 
-    wxASSERT( GetStringData()->nDataLength == 0 );  // should be empty
-    wxASSERT( GetStringData()->nAllocLength == 0 ); // and not own any memory
+    wxASSERT_MSG( !GetStringData()->nDataLength &&
+                  !GetStringData()->nAllocLength,
+                  _T("string should be empty after Clear()") );
   }
 
   // contents test
@@ -389,10 +395,19 @@ public:
 
     // get last character
     wxChar  Last() const
-      { wxASSERT( !IsEmpty() ); return m_pchData[Len() - 1]; }
+      {
+          wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
+
+          return m_pchData[Len() - 1];
+      }
+
     // get writable last character
     wxChar& Last()
-      { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; }
+      {
+          wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
+          CopyBeforeWrite();
+          return m_pchData[Len()-1];
+      }
 
     /*
         So why do we have all these overloaded operator[]s? A bit of history:
@@ -497,7 +512,8 @@ public:
   wxString& operator=(const wxChar *psz);
 #if wxUSE_UNICODE
     // from wxWCharBuffer
-  wxString& operator=(const wxWCharBuffer& psz) { return operator=((const wchar_t *)psz); }
+  wxString& operator=(const wxWCharBuffer& psz)
+  { (void) operator=((const wchar_t *)psz); return *this; }
 #else // ANSI
     // from another kind of C string
   wxString& operator=(const unsigned char* psz);
@@ -506,7 +522,8 @@ public:
   wxString& operator=(const wchar_t *pwz);
 #endif
     // from wxCharBuffer
-  wxString& operator=(const wxCharBuffer& psz) { return operator=((const char *)psz); }
+  wxString& operator=(const wxCharBuffer& psz)
+  { (void) operator=((const char *)psz); return *this; }
 #endif // Unicode/ANSI
 
   // string concatenation
@@ -519,7 +536,8 @@ public:
       // string += string
   wxString& operator<<(const wxString& s)
   {
-    wxASSERT( s.GetStringData()->IsValid() );
+    wxASSERT_MSG( s.GetStringData()->IsValid(),
+                  _T("did you forget to call UngetWriteBuf()?") );
 
     ConcatSelf(s.Len(), s);
     return *this;
@@ -539,14 +557,27 @@ public:
 
       // string += buffer (i.e. from wxGetString)
 #if wxUSE_UNICODE
-  wxString& operator<<(const wxWCharBuffer& s) { (void)operator<<((const wchar_t *)s); return *this; }
-  void operator+=(const wxWCharBuffer& s) { (void)operator<<((const wchar_t *)s); }
-#else
-  wxString& operator<<(const wxCharBuffer& s) { (void)operator<<((const char *)s); return *this; }
-  void operator+=(const wxCharBuffer& s) { (void)operator<<((const char *)s); }
-#endif
+  wxString& operator<<(const wxWCharBuffer& s)
+    { (void)operator<<((const wchar_t *)s); return *this; }
+  void operator+=(const wxWCharBuffer& s)
+    { (void)operator<<((const wchar_t *)s); }
+#else // !wxUSE_UNICODE
+  wxString& operator<<(const wxCharBuffer& s)
+    { (void)operator<<((const char *)s); return *this; }
+  void operator+=(const wxCharBuffer& s)
+    { (void)operator<<((const char *)s); }
+#endif // wxUSE_UNICODE/!wxUSE_UNICODE
 
     // string += C string
+  wxString& Append(const wxString& s)
+    {
+        // test for IsEmpty() to share the string if possible
+        if ( IsEmpty() )
+            *this = s;
+        else
+            ConcatSelf(s.Length(), s.c_str());
+        return *this;
+    }
   wxString& Append(const wxChar* psz)
     { ConcatSelf(wxStrlen(psz), psz); return *this; }
     // append count copies of given character
@@ -699,10 +730,10 @@ public:
   // raw access to string memory
     // ensure that string has space for at least nLen characters
     // only works if the data of this string is not shared
-  void Alloc(size_t nLen);
+  bool Alloc(size_t nLen);
     // minimize the string's memory
     // only works if the data of this string is not shared
-  void Shrink();
+  bool Shrink();
     // get writable buffer of at least nLen bytes. Unget() *must* be called
     // a.s.a.p. to put string back in a reasonable state!
   wxChar *GetWriteBuf(size_t nLen);
@@ -770,8 +801,11 @@ public:
   // constructors
     // take nLen chars starting at nPos
   wxString(const wxString& str, size_t nPos, size_t nLen)
+      : m_pchData(NULL)
   {
-    wxASSERT( str.GetStringData()->IsValid() );
+    wxASSERT_MSG( str.GetStringData()->IsValid(),
+                  _T("did you forget to call UngetWriteBuf()?") );
+
     InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen);
   }
     // take all characters from pStart to pEnd
@@ -978,7 +1012,9 @@ public:
 
   // constructors and destructor
     // default ctor
-  wxArrayString() { Init(FALSE); }
+  wxArrayString()
+      : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
+      { Init(FALSE); }
     // if autoSort is TRUE, the array is always sorted (in alphabetical order)
     //
     // NB: the reason for using int and not bool is that like this we can avoid
@@ -987,7 +1023,9 @@ public:
     //
     //     of course, using explicit would be even better - if all compilers
     //     supported it...
-  wxArrayString(int autoSort) { Init(autoSort != 0); }
+  wxArrayString(int autoSort)
+      : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
+      { Init(autoSort != 0); }
     // copy ctor
   wxArrayString(const wxArrayString& array);
     // assignment operator
@@ -1016,11 +1054,22 @@ public:
   // items access (range checking is done in debug version)
     // get item at position uiIndex
   wxString& Item(size_t nIndex) const
-    { wxASSERT( nIndex < m_nCount ); return *(wxString *)&(m_pItems[nIndex]); }
+    {
+        wxASSERT_MSG( nIndex < m_nCount,
+                      _T("wxArrayString: index out of bounds") );
+
+        return *(wxString *)&(m_pItems[nIndex]);
+    }
+
     // same as Item()
   wxString& operator[](size_t nIndex) const { return Item(nIndex); }
     // get last item
-  wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); }
+  wxString& Last() const
+  {
+      wxASSERT_MSG( !IsEmpty(),
+                    _T("wxArrayString: index out of bounds") );
+      return Item(Count() - 1);
+  }
 
     // return a wxString[], useful for the controls which
     // take one in their ctor.  You must delete[] it yourself
@@ -1036,16 +1085,16 @@ public:
   int  Index (const wxChar *sz, bool bCase = TRUE, bool bFromEnd = FALSE) const;
     // add new element at the end (if the array is not sorted), return its
     // index
-  size_t Add(const wxString& str);
+  size_t Add(const wxString& str, size_t nInsert = 1);
     // add new element at given position
-  void Insert(const wxString& str, size_t uiIndex);
+  void Insert(const wxString& str, size_t uiIndex, size_t nInsert = 1);
     // expand the array to have count elements
   void SetCount(size_t count);
     // remove first item matching this value
   void Remove(const wxChar *sz);
     // remove item by index
-  void Remove(size_t nIndex);
-  void RemoveAt(size_t nIndex) { Remove(nIndex); }
+  void Remove(size_t nIndex, size_t nRemove = 1);
+  void RemoveAt(size_t nIndex, size_t nRemove = 1) { Remove(nIndex, nRemove); }
 
   // sorting
     // sort array elements in alphabetical order (or reversed alphabetical
@@ -1065,7 +1114,7 @@ protected:
   void Copy(const wxArrayString& src);  // copies the contents of another array
 
 private:
-  void Grow();                          // makes array bigger if needed
+  void Grow(size_t nIncrement = 0);     // makes array bigger if needed
   void Free();                          // free all the strings stored
 
   void DoSort();                        // common part of all Sort() variants
@@ -1093,14 +1142,17 @@ public:
 
 class WXDLLEXPORT wxStringBuffer
 {
+    DECLARE_NO_COPY_CLASS(wxStringBuffer)
+    
 public:
     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
-        : m_str(str) { m_buf = m_str.GetWriteBuf(lenWanted); }
-
+        : m_str(str), m_buf(NULL)
+        { m_buf = m_str.GetWriteBuf(lenWanted); }
+    
     ~wxStringBuffer() { m_str.UngetWriteBuf(); }
-
+    
     operator wxChar*() const { return m_buf; }
-
+    
 private:
     wxString& m_str;
     wxChar   *m_buf;