made wx[Array]TreeItemId[s] more backwards compatible

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

diff --git a/include/wx/string.h b/include/wx/string.h
index 521b7ca966fe5d7fbd0b42cae2a716479cae622f..a1840aa728c305f705b34945158103ba8b9a81fb 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -101,7 +101,7 @@ const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
 // ----------------------------------------------------------------------------
 
 // global pointer to empty string
 // ----------------------------------------------------------------------------
 
 // global pointer to empty string

-WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
+extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxEmptyString;

 
 // ---------------------------------------------------------------------------
 // global functions complementing standard C string library replacements for
 
 // ---------------------------------------------------------------------------
 // global functions complementing standard C string library replacements for


@@ -121,7 +121,15 @@ inline size_t Strlen(const char *psz)
 // portable strcasecmp/_stricmp
 inline int Stricmp(const char *psz1, const char *psz2)
 {
 // portable strcasecmp/_stricmp
 inline int Stricmp(const char *psz1, const char *psz2)
 {

-#if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
+#if defined(__VISUALC__) && defined(__WXWINCE__)
+  register char c1, c2;
+  do {
+    c1 = tolower(*psz1++);
+    c2 = tolower(*psz2++);
+  } while ( c1 && (c1 == c2) );
+
+  return c1 - c2;
+#elif defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )

   return _stricmp(psz1, psz2);
 #elif defined(__SC__)
   return _stricmp(psz1, psz2);
   return _stricmp(psz1, psz2);
 #elif defined(__SC__)
   return _stricmp(psz1, psz2);


@@ -166,7 +174,7 @@ inline int Stricmp(const char *psz1, const char *psz2)
 }
 
 // return an empty wxString
 }
 
 // return an empty wxString

-class WXDLLEXPORT wxString; // not yet defined
+class WXDLLIMPEXP_BASE wxString; // not yet defined

 inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
 
 // ---------------------------------------------------------------------------
 inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
 
 // ---------------------------------------------------------------------------


@@ -174,7 +182,7 @@ inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString;
 // is never used directly (but had to be put here to allow inlining)
 // ---------------------------------------------------------------------------
 
 // is never used directly (but had to be put here to allow inlining)
 // ---------------------------------------------------------------------------
 

-struct WXDLLEXPORT wxStringData
+struct WXDLLIMPEXP_BASE wxStringData

 {
   int     nRefs;        // reference count
   size_t  nDataLength,  // actual string length
 {
   int     nRefs;        // reference count
   size_t  nDataLength,  // actual string length


@@ -190,12 +198,19 @@ struct WXDLLEXPORT wxStringData
   // lock/unlock
   void  Lock()   { if ( !IsEmpty() ) nRefs++;                    }
 
   // lock/unlock
   void  Lock()   { if ( !IsEmpty() ) nRefs++;                    }
 

-  // VC++ will refuse to inline this function but profiling shows that it
-  // is wrong
+  // VC++ will refuse to inline Unlock but profiling shows that it is wrong

 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
   __forceinline
 #endif
 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
   __forceinline
 #endif

+  // VC++ free must take place in same DLL as allocation when using non dll
+  // run-time library (e.g. Multithreaded instead of Multithreaded DLL)
+#if defined(__VISUALC__) && defined(_MT) && !defined(_DLL)
+  void  Unlock() { if ( !IsEmpty() && --nRefs == 0) Free();  }
+  // we must not inline deallocation since allocation is not inlined
+  void  Free();
+#else

   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this);  }
   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this);  }

+#endif

 
   // if we had taken control over string memory (GetWriteBuf), it's
   // intentionally put in invalid state
 
   // if we had taken control over string memory (GetWriteBuf), it's
   // intentionally put in invalid state


@@ -226,9 +241,11 @@ struct WXDLLEXPORT wxStringData
 //  - regular expressions support
 // ---------------------------------------------------------------------------
 
 //  - regular expressions support
 // ---------------------------------------------------------------------------
 

-class WXDLLEXPORT wxString
+class WXDLLIMPEXP_BASE wxString

 {
 {

-friend class WXDLLEXPORT wxArrayString;
+#if !wxUSE_STL
+friend class WXDLLIMPEXP_BASE wxArrayString;
+#endif

 
   // NB: special care was taken in arranging the member functions in such order
   //     that all inline functions can be effectively inlined, verify that all
 
   // NB: special care was taken in arranging the member functions in such order
   //     that all inline functions can be effectively inlined, verify that all


@@ -258,7 +275,7 @@ private:
   bool AssignCopy(size_t, const wxChar *);
 
   // append a (sub)string
   bool AssignCopy(size_t, const wxChar *);
 
   // append a (sub)string

-  bool ConcatSelf(int nLen, const wxChar *src);
+  bool ConcatSelf(size_t 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)
 
   // 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)


@@ -600,15 +617,15 @@ public:
 
     // non-destructive concatenation
       //
 
     // non-destructive concatenation
       //

-  friend wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);

       //
       //

-  friend wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);

       //
       //

-  friend wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
+  friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);

       //
       //

-  friend wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);

       //
       //

-  friend wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);

 
   // stream-like functions
       // insert an int into string
 
   // stream-like functions
       // insert an int into string


@@ -1005,159 +1022,72 @@ public:
 #endif // wxSTD_STRING_COMPATIBILITY
 };
 
 #endif // wxSTD_STRING_COMPATIBILITY
 };
 

+// define wxArrayString, for compatibility
+#if WXWIN_COMPATIBILITY_2_4 && !wxUSE_STL
+    #include "wx/arrstr.h"
+#endif
+

 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------

-// The string array uses it's knowledge of internal structure of the wxString
-// class to optimize string storage. Normally, we would store pointers to
-// string, but as wxString is, in fact, itself a pointer (sizeof(wxString) is
-// sizeof(char *)) we store these pointers instead. The cast to "wxString *" is
-// really all we need to turn such pointer into a string!
-//
-// Of course, it can be called a dirty hack, but we use twice less memory and
-// this approach is also more speed efficient, so it's probably worth it.
-//
-// Usage notes: when a string is added/inserted, a new copy of it is created,
-// so the original string may be safely deleted. When a string is retrieved
-// from the array (operator[] or Item() method), a reference is returned.
+// wxStringBuffer: a tiny class allowing to get a writable pointer into string

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxArrayString
+#if wxUSE_STL
+
+class WXDLLIMPEXP_BASE wxStringBuffer

 {
 public:
 {
 public:

-  // type of function used by wxArrayString::Sort()
-  typedef int (*CompareFunction)(const wxString& first,
-                                 const wxString& second);
-
-  // constructors and destructor
-    // default ctor
-  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
-    //     using this ctor for implicit conversions from "const char *" (which
-    //     we'd like to be implicitly converted to wxString instead!)
-    //
-    //     of course, using explicit would be even better - if all compilers
-    //     supported it...
-  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
-  wxArrayString& operator=(const wxArrayString& src);
-    // not virtual, this class should not be derived from
- ~wxArrayString();
-
-  // memory management
-    // empties the list, but doesn't release memory
-  void Empty();
-    // empties the list and releases memory
-  void Clear();
-    // preallocates memory for given number of items
-  void Alloc(size_t nCount);
-    // minimzes the memory usage (by freeing all extra memory)
-  void Shrink();
-
-  // simple accessors
-    // number of elements in the array
-  size_t GetCount() const { return m_nCount; }
-    // is it empty?
-  bool IsEmpty() const { return m_nCount == 0; }
-    // number of elements in the array (GetCount is preferred API)
-  size_t Count() const { return m_nCount; }
-
-  // items access (range checking is done in debug version)
-    // get item at position uiIndex
-  wxString& Item(size_t nIndex) const
-    {
-        wxASSERT_MSG( nIndex < m_nCount,
-                      _T("wxArrayString: index out of bounds") );
-
-        return *(wxString *)&(m_pItems[nIndex]);
-    }
+    wxStringBuffer(wxString& str, size_t lenWanted = 1024)
+        : m_str(str), m_buf(lenWanted), m_len(lenWanted)
+        { }

 
 

-    // same as Item()
-  wxString& operator[](size_t nIndex) const { return Item(nIndex); }
-    // get last item
-  wxString& Last() const
-  {
-      wxASSERT_MSG( !IsEmpty(),
-                    _T("wxArrayString: index out of bounds") );
-      return Item(Count() - 1);
-  }
+    ~wxStringBuffer() { m_str.assign(m_buf.data(), wxStrlen(m_buf.data())); }

 
 

-    // 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
-    // sensitive (default). Returns index of the first item matched or
-    // wxNOT_FOUND
-  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 nInsert = 1);
-    // add new element at given position
-  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, 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
-    // order if reverseOrder parameter is TRUE)
-  void Sort(bool reverseOrder = FALSE);
-    // sort array elements using specified comparaison function
-  void Sort(CompareFunction compareFunction);
-
-  // comparison
-    // compare two arrays case sensitively
-  bool operator==(const wxArrayString& a) const;
-    // compare two arrays case sensitively
-  bool operator!=(const wxArrayString& a) const { return !(*this == a); }
-
-protected:
-  void Init(bool autoSort);             // common part of all ctors
-  void Copy(const wxArrayString& src);  // copies the contents of another array
+    operator wxChar*() { return m_buf.data(); }

 
 private:
 
 private:

-  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
-
-  size_t  m_nSize,    // current size of the array
-          m_nCount;   // current number of elements
-
-  wxChar  **m_pItems; // pointer to data
+    wxString& m_str;
+#if wxUSE_UNICODE
+    wxWCharBuffer m_buf;
+#else
+    wxCharBuffer m_buf;
+#endif
+    size_t m_len;

 
 

-  bool    m_autoSort; // if TRUE, keep the array always sorted
+    DECLARE_NO_COPY_CLASS(wxStringBuffer)

 };
 
 };
 

-class WXDLLEXPORT wxSortedArrayString : public wxArrayString
+class WXDLLIMPEXP_BASE wxStringBufferLength

 {
 public:
 {
 public:

-  wxSortedArrayString() : wxArrayString(TRUE)
-    { }
-  wxSortedArrayString(const wxArrayString& array) : wxArrayString(TRUE)
-    { Copy(array); }
+    wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
+        : m_str(str), m_buf(lenWanted), m_len(0), m_lenSet(false)
+        { }
+
+    ~wxStringBufferLength()
+    {
+        wxASSERT(m_lenSet);
+        m_str.assign(m_buf.data(), m_len);
+    }
+
+    operator wxChar*() { return m_buf.data(); }
+    void SetLength(size_t length) { m_len = length; m_lenSet = true; }
+
+private:
+    wxString& m_str;
+#if wxUSE_UNICODE
+    wxWCharBuffer m_buf;
+#else
+    wxCharBuffer  m_buf;
+#endif
+    size_t        m_len;
+    bool          m_lenSet;
+
+    DECLARE_NO_COPY_CLASS(wxStringBufferLength)

 };
 
 };
 

-// ----------------------------------------------------------------------------
-// wxStringBuffer: a tiny class allowing to get a writable pointer into string
-// ----------------------------------------------------------------------------
+#else // if !wxUSE_STL

 
 

-class WXDLLEXPORT wxStringBuffer
+class WXDLLIMPEXP_BASE wxStringBuffer

 {
 public:
     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
 {
 public:
     wxStringBuffer(wxString& str, size_t lenWanted = 1024)


@@ -1175,6 +1105,33 @@ private:
     DECLARE_NO_COPY_CLASS(wxStringBuffer)
 };
 
     DECLARE_NO_COPY_CLASS(wxStringBuffer)
 };
 

+class WXDLLIMPEXP_BASE wxStringBufferLength
+{
+public:
+    wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
+        : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)
+        { m_buf = m_str.GetWriteBuf(lenWanted); }
+
+    ~wxStringBufferLength()
+    {
+        wxASSERT(m_lenSet);
+        m_str.UngetWriteBuf(m_len);
+    }
+
+    operator wxChar*() const { return m_buf; }
+    void SetLength(size_t length) { m_len = length; m_lenSet = true; }
+
+private:
+    wxString& m_str;
+    wxChar   *m_buf;
+    size_t    m_len;
+    bool      m_lenSet;
+
+    DECLARE_NO_COPY_CLASS(wxStringBufferLength)
+};
+
+#endif // !wxUSE_STL
+

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


@@ -1242,11 +1199,11 @@ inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const char *)s1) != 0); }
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 
     { return (s2.Cmp((const char *)s1) != 0); }
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 

-wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
-wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
-wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
-wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
-wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
+wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
+wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);

 #if wxUSE_UNICODE
 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
     { return string + (const wchar_t *)buf; }
 #if wxUSE_UNICODE
 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
     { return string + (const wchar_t *)buf; }


@@ -1270,8 +1227,8 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
 
 #include "wx/iosfwrap.h"
 
 
 #include "wx/iosfwrap.h"
 

-WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&);
-WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
+WXDLLIMPEXP_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&);
+WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);

 
 #endif  // wxSTD_STRING_COMPATIBILITY
 
 
 #endif  // wxSTD_STRING_COMPATIBILITY