compilation fix for recent commit

[wxWidgets.git] / include / wx / string.h

diff --git a/include/wx/string.h b/include/wx/string.h
index 26ac2326f8eb009e4f64ec1a5724109b96ad22bf..ee258c42b97c22285c8a2cad9764dfee8e85d7b7 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -63,7 +63,7 @@
 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()

-#endif // AIX
+#endif // HAVE_STRINGS_H

 
 #include "wx/defs.h"        // everybody should include this
 #include "wx/wxchar.h"      // for wxChar
 
 #include "wx/defs.h"        // everybody should include this
 #include "wx/wxchar.h"      // for wxChar


@@ -139,6 +139,8 @@ inline int Stricmp(const char *psz1, const char *psz2)
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);

+#elif defined(__DJGPP__)
+  return stricmp(psz1, psz2);

 #elif defined(__EMX__)
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)
 #elif defined(__EMX__)
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)


@@ -287,14 +289,20 @@ private:
   void CopyBeforeWrite();
   void AllocBeforeWrite(size_t);
 
   void CopyBeforeWrite();
   void AllocBeforeWrite(size_t);
 

-  // this method is not implemented - there is _no_ conversion from int to
+  // 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
+  // converted to char in C and we do have operator=(char)
+  //
+  // NB: we don't need other versions (short/long and unsigned) as attempt
+  //     to assign another numeric type to wxString will now result in
+  //     ambiguity between operator=(char) and operator=(int)
+  wxString& operator=(int);
+
+  // these methods are not implemented - there is _no_ conversion from int to

   // string, you're doing something wrong if the compiler wants to call it!
   //
   // try `s << i' or `s.Printf("%d", i)' instead
   wxString(int);
   // string, you're doing something wrong if the compiler wants to call it!
   //
   // try `s << i' or `s.Printf("%d", i)' instead
   wxString(int);

-  wxString(unsigned int);
-  wxString(long);
-  wxString(unsigned long);

 
 public:
   // constructors and destructor
 
 public:
   // constructors and destructor


@@ -356,14 +364,14 @@ public:
   bool IsEmpty() const { return Len() == 0; }
     // empty string is "FALSE", so !str will return TRUE
   bool operator!() const { return IsEmpty(); }
   bool IsEmpty() const { return Len() == 0; }
     // empty string is "FALSE", so !str will return TRUE
   bool operator!() const { return IsEmpty(); }

+    // truncate the string to given length
+  wxString& Truncate(size_t uiLen);

     // empty string contents
   void Empty()
   {
     // empty string contents
   void Empty()
   {

-    if ( !IsEmpty() )
-      Reinit();
+    Truncate(0);

 
 

-    // should be empty
-    wxASSERT( GetStringData()->nDataLength == 0 );
+    wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") );

   }
     // empty the string and free memory
   void Clear()
   }
     // empty the string and free memory
   void Clear()


@@ -401,6 +409,28 @@ public:
     wxChar& Last()
       { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; }
 
     wxChar& Last()
       { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; }
 

+    /*
+        So why do we have all these overloaded operator[]s? A bit of history:
+        initially there was only one of them, taking size_t. Then people
+        started complaining because they wanted to use ints as indices (I
+        wonder why) and compilers were giving warnings about it, so we had to
+        add the operator[](int). Then it became apparent that you couldn't
+        write str[0] any longer because there was ambiguity between two
+        overloads and so you now had to write str[0u] (or, of course, use the
+        explicit casts to either int or size_t but nobody did this).
+
+        Finally, someone decided to compile wxWin on an Alpha machine and got
+        a surprize: str[0u] didn't compile there because it is of type
+        unsigned int and size_t is unsigned _long_ on Alpha and so there was
+        ambiguity between converting uint to int or ulong. To fix this one we
+        now add operator[](uint) for the machines where size_t is not already
+        the same as unsigned int - hopefully this fixes the problem (for some
+        time)
+
+        The only real fix is, of course, to remove all versions but the one
+        taking size_t...
+     */
+

     // operator version of GetChar
     wxChar  operator[](size_t n) const
       { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
     // operator version of GetChar
     wxChar  operator[](size_t n) const
       { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }


@@ -408,20 +438,20 @@ public:
     // operator version of GetChar
     wxChar  operator[](int n) const
       { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
     // operator version of GetChar
     wxChar  operator[](int n) const
       { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }

-#ifdef __alpha__
-    // operator version of GetChar
-    wxChar  operator[](unsigned int n) const
-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
-#endif

 
     // operator version of GetWriteableChar
     wxChar& operator[](size_t n)
       { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
 
     // operator version of GetWriteableChar
     wxChar& operator[](size_t n)
       { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }

-#ifdef __alpha__
+
+#ifndef wxSIZE_T_IS_UINT
+    // operator version of GetChar
+    wxChar operator[](unsigned int n) const
+      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
+

     // operator version of GetWriteableChar
     // operator version of GetWriteableChar

-    wxChar&  operator[](unsigned int n)
+    wxChar& operator[](unsigned int n)

       { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
       { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }

-#endif
+#endif // size_t != unsigned int

 
     // implicit conversion to C string
     operator const wxChar*() const { return m_pchData; }
 
     // implicit conversion to C string
     operator const wxChar*() const { return m_pchData; }


@@ -601,7 +631,7 @@ public:
   wxString  operator()(size_t start, size_t len) const
     { return Mid(start, len); }
 
   wxString  operator()(size_t start, size_t len) const
     { return Mid(start, len); }
 

-      // check that the tring starts with prefix and return the rest of the
+      // check that the string starts with prefix and return the rest of the

       // string in the provided pointer if it is not NULL, otherwise return
       // FALSE
   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
       // string in the provided pointer if it is not NULL, otherwise return
       // FALSE
   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;


@@ -610,7 +640,7 @@ public:
   wxString Left(size_t nCount) const;
       // get last nCount characters
   wxString Right(size_t nCount) const;
   wxString Left(size_t nCount) const;
       // get last nCount characters
   wxString Right(size_t nCount) const;

-      // get all characters before the first occurence of ch
+      // get all characters before the first occurance of ch

       // (returns the whole string if ch not found)
   wxString BeforeFirst(wxChar ch) const;
       // get all characters before the last occurence of ch
       // (returns the whole string if ch not found)
   wxString BeforeFirst(wxChar ch) const;
       // get all characters before the last occurence of ch


@@ -643,8 +673,6 @@ public:
   wxString& Trim(bool bFromRight = TRUE);
       // add nCount copies chPad in the beginning or at the end (default)
   wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
   wxString& Trim(bool bFromRight = TRUE);
       // add nCount copies chPad in the beginning or at the end (default)
   wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);

-      // truncate string to given length
-  wxString& Truncate(size_t uiLen);

 
   // searching and replacing
       // searching (return starting index, or -1 if not found)
 
   // searching and replacing
       // searching (return starting index, or -1 if not found)


@@ -663,9 +691,9 @@ public:
     // conversion to numbers: all functions return TRUE only if the whole string
     // is a number and put the value of this number into the pointer provided
         // convert to a signed integer
     // conversion to numbers: all functions return TRUE only if the whole string
     // is a number and put the value of this number into the pointer provided
         // convert to a signed integer

-    bool ToLong(long *val) const;
+    bool ToLong(long *val, int base = 0) const;

         // convert to an unsigned integer
         // convert to an unsigned integer

-    bool ToULong(unsigned long *val) const;
+    bool ToULong(unsigned long *val, int base = 0) const;

         // convert to a double
     bool ToDouble(double *val) const;
 
         // convert to a double
     bool ToDouble(double *val) const;
 


@@ -803,16 +831,17 @@ public:
   wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
 
     // same as `this_string = str'
   wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
 
     // same as `this_string = str'

-  wxString& assign(const wxString& str) { return (*this) = str; }
+  wxString& assign(const wxString& str)
+    { return *this = str; }

     // same as ` = str[pos..pos + n]
   wxString& assign(const wxString& str, size_t pos, size_t n)
     // same as ` = str[pos..pos + n]
   wxString& assign(const wxString& str, size_t pos, size_t n)

-    { return *this = wxString((const wxChar *)str + pos, n); }
+    { Empty(); return Append(str.c_str() + pos, n); }

     // same as `= first n (or all if n == npos) characters of sz'
   wxString& assign(const wxChar *sz, size_t n = npos)
     // same as `= first n (or all if n == npos) characters of sz'
   wxString& assign(const wxChar *sz, size_t n = npos)

-    { return *this = wxString(sz, n); }
+    { Empty(); return Append(sz, n == npos ? wxStrlen(sz) : n); }

     // same as `= n copies of ch'
   wxString& assign(size_t n, wxChar ch)
     // same as `= n copies of ch'
   wxString& assign(size_t n, wxChar ch)

-    { return *this = wxString(ch, n); }
+    { Empty(); return Append(ch, n); }

 
     // insert another string
   wxString& insert(size_t nPos, const wxString& str);
 
     // insert another string
   wxString& insert(size_t nPos, const wxString& str);


@@ -997,6 +1026,12 @@ public:
     // get last item
   wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); }
 
     // get last item
   wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); }
 

+    // return a wxString[], useful for the controls which
+    // take one in their ctor.  You must delete[] it yourself
+    // once you are done with it.  Will return NULL if the
+    // ArrayString was empty.
+  wxString* GetStringArray() const;
+

   // item management
     // Search the element in the array, starting from the beginning if
     // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case
   // item management
     // Search the element in the array, starting from the beginning if
     // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case


@@ -1008,6 +1043,8 @@ public:
   size_t Add(const wxString& str);
     // add new element at given position
   void Insert(const wxString& str, size_t uiIndex);
   size_t Add(const wxString& str);
     // add new element at given position
   void Insert(const wxString& str, size_t uiIndex);

+    // 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
     // remove first item matching this value
   void Remove(const wxChar *sz);
     // remove item by index


@@ -1053,6 +1090,25 @@ public:
     { Copy(array); }
 };
 
     { Copy(array); }
 };
 

+// ----------------------------------------------------------------------------
+// wxStringBuffer: a tiny class allowing to get a writable pointer into string
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStringBuffer
+{
+public:
+    wxStringBuffer(wxString& str, size_t lenWanted = 1024)
+        : m_str(str) { m_buf = m_str.GetWriteBuf(lenWanted); }
+
+    ~wxStringBuffer() { m_str.UngetWriteBuf(); }
+
+    operator wxChar*() const { return m_buf; }
+
+private:
+    wxString& m_str;
+    wxChar   *m_buf;
+};
+

 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------