* Renamed fstream.h in wfstream.h

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

diff --git a/include/wx/string.h b/include/wx/string.h
index e07f95d74d69bb5c7a02564cadf2b54afbf7be79..1db45300c411696570a98fc3a3b1ab58c8f82747 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -9,8 +9,8 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 

-#ifndef __WXSTRINGH__
-#define __WXSTRINGH__
+#ifndef _WX_WXSTRINGH__
+#define _WX_WXSTRINGH__

 
 #ifdef __GNUG__
 #pragma interface "string.h"
 
 #ifdef __GNUG__
 #pragma interface "string.h"


@@ -112,10 +112,10 @@ inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
 // ----------------------------------------------------------------------------
 
 // global pointer to empty string
 // ----------------------------------------------------------------------------
 
 // global pointer to empty string

-extern const char *g_szNul;
+WXDLLEXPORT_DATA(extern const char*) g_szNul;

 
 // return an empty wxString
 
 // return an empty wxString

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

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


@@ -125,7 +125,7 @@ inline const wxString& wxGetEmptyString() { return *(wxString *)&g_szNul; }
 struct WXDLLEXPORT wxStringData
 {
   int     nRefs;        // reference count
 struct WXDLLEXPORT wxStringData
 {
   int     nRefs;        // reference count

-  uint    nDataLength,  // actual string length
+  size_t  nDataLength,  // actual string length

           nAllocLength; // allocated memory size
 
   // mimics declaration 'char data[nAllocLength]'
           nAllocLength; // allocated memory size
 
   // mimics declaration 'char data[nAllocLength]'


@@ -182,10 +182,10 @@ struct WXDLLEXPORT wxStringData
   {
 #endif  //WXSTRING_IS_WXOBJECT
 
   {
 #endif  //WXSTRING_IS_WXOBJECT
 

-friend class wxArrayString;
+friend class WXDLLEXPORT wxArrayString;

 
 

-  // NB: this data must be here (before all other functions) to be sure that all
-  // inline functions are really inlined by all compilers
+  // NB: special care was taken in arrangin the member functions in such order
+  //     that all inline functions can be effectively inlined

 private:
   // points to data preceded by wxStringData structure with ref count info
   char *m_pchData;
 private:
   // points to data preceded by wxStringData structure with ref count info
   char *m_pchData;


@@ -193,35 +193,74 @@ private:
   // accessor to string data
   wxStringData* GetStringData() const { return (wxStringData*)m_pchData - 1; }
 
   // accessor to string data
   wxStringData* GetStringData() const { return (wxStringData*)m_pchData - 1; }
 

+  // string (re)initialization functions
+    // initializes the string to the empty value (must be called only from
+    // ctors, use Reinit() otherwise)
+  void Init() { m_pchData = (char *)g_szNul; }
+    // initializaes the string with (a part of) C-string
+  void InitWith(const char *psz, size_t nPos = 0, size_t nLen = STRING_MAXLEN);
+    // as Init, but also frees old data
+  void Reinit() { GetStringData()->Unlock(); Init(); }
+
+  // memory allocation
+    // allocates memory for string of lenght nLen
+  void AllocBuffer(size_t nLen);
+    // copies data to another string
+  void AllocCopy(wxString&, int, int) const;
+    // effectively copies data to string
+  void AssignCopy(size_t, const char *);
+
+  // append a (sub)string
+  void ConcatSelf(int nLen, const char *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);
+

 public:
   /** @name constructors & dtor */
   //@{
     /// ctor for an empty string
 public:
   /** @name constructors & dtor */
   //@{
     /// ctor for an empty string

-  wxString();
+  wxString() { Init(); }

     /// copy ctor
     /// copy ctor

-  wxString(const wxString& stringSrc);
+  wxString(const wxString& stringSrc)
+  {
+    wxASSERT( stringSrc.GetStringData()->IsValid() );
+
+    if ( stringSrc.IsEmpty() ) {
+      // nothing to do for an empty string
+      Init();
+    }
+    else {
+      m_pchData = stringSrc.m_pchData;            // share same data
+      GetStringData()->Lock();                    // => one more copy
+    }
+  }

     /// string containing nRepeat copies of ch
   wxString(char ch, size_t nRepeat = 1);
     /// ctor takes first nLength characters from C string
     /// string containing nRepeat copies of ch
   wxString(char ch, size_t nRepeat = 1);
     /// ctor takes first nLength characters from C string

-  wxString(const char *psz, size_t nLength = STRING_MAXLEN);
+    // (default value of STRING_MAXLEN means take all the string)
+  wxString(const char *psz, size_t nLength = STRING_MAXLEN)
+    { InitWith(psz, 0, nLength); }

     /// from C string (for compilers using unsigned char)
   wxString(const unsigned char* psz, size_t nLength = STRING_MAXLEN);
     /// from wide (UNICODE) string
   wxString(const wchar_t *pwz);
     /// dtor is not virtual, this class must not be inherited from!
     /// from C string (for compilers using unsigned char)
   wxString(const unsigned char* psz, size_t nLength = STRING_MAXLEN);
     /// from wide (UNICODE) string
   wxString(const wchar_t *pwz);
     /// dtor is not virtual, this class must not be inherited from!

- ~wxString();
+ ~wxString() { GetStringData()->Unlock(); }

   //@}
 
   /** @name generic attributes & operations */
   //@{
     /// as standard strlen()
   //@}
 
   /** @name generic attributes & operations */
   //@{
     /// as standard strlen()

-  uint Len() const { return GetStringData()->nDataLength; }
+  size_t Len() const { return GetStringData()->nDataLength; }

     /// string contains any characters?
   bool IsEmpty() const { return Len() == 0; }
     /// string contains any characters?
   bool IsEmpty() const { return Len() == 0; }

-    /// reinitialize string (and free data!)
+    /// reinitialize string (and free memory)

   void Empty()
   {
   void Empty()
   {

-    if ( GetStringData()->nDataLength != 0 )
+    if ( !IsEmpty() )

       Reinit();
 
     wxASSERT( GetStringData()->nDataLength == 0 );
       Reinit();
 
     wxASSERT( GetStringData()->nDataLength == 0 );


@@ -290,14 +329,6 @@ public:
   /** @name string concatenation */
   //@{
     /** @name in place concatenation */
   /** @name string concatenation */
   //@{
     /** @name in place concatenation */

-    //@{
-      /// string += string
-  void operator+=(const wxString& s) { (void)operator<<(s); }
-      /// string += C string
-  void operator+=(const char *psz) { (void)operator<<(psz); }
-      /// string += char
-  void operator+=(char ch) { (void)operator<<(ch); }
-    //@}

     /** @name concatenate and return the result
         left to right associativity of << allows to write
         things like "str << str1 << str2 << ..."          */
     /** @name concatenate and return the result
         left to right associativity of << allows to write
         things like "str << str1 << str2 << ..."          */


@@ -317,31 +348,40 @@ public:
   wxString& operator<<(char ch) { ConcatSelf(1, &ch); return *this; }
     //@}
 
   wxString& operator<<(char ch) { ConcatSelf(1, &ch); return *this; }
     //@}
 

+    //@{
+      /// string += string
+  void operator+=(const wxString& s) { (void)operator<<(s); }
+      /// string += C string
+  void operator+=(const char *psz) { (void)operator<<(psz); }
+      /// string += char
+  void operator+=(char ch) { (void)operator<<(ch); }
+    //@}
+

     /** @name return resulting string */
     //@{
       ///
     /** @name return resulting string */
     //@{
       ///

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

       ///
       ///

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

       ///
       ///

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

       ///
       ///

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

       ///
       ///

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

     //@}
   //@}
 
   /** @name string comparison */
   //@{
     /**
     //@}
   //@}
 
   /** @name string comparison */
   //@{
     /**

-    case-sensitive comparaison
+    case-sensitive comparison

     @return 0 if equal, +1 if greater or -1 if less
     @see CmpNoCase, IsSameAs
     */
   int  Cmp(const char *psz) const { return strcmp(c_str(), psz); }
     /**
     @return 0 if equal, +1 if greater or -1 if less
     @see CmpNoCase, IsSameAs
     */
   int  Cmp(const char *psz) const { return strcmp(c_str(), psz); }
     /**

-    case-insensitive comparaison, return code as for wxString::Cmp()
+    case-insensitive comparison, return code as for wxString::Cmp()

     @see: Cmp, IsSameAs
     */
   int  CmpNoCase(const char *psz) const { return Stricmp(c_str(), psz); }
     @see: Cmp, IsSameAs
     */
   int  CmpNoCase(const char *psz) const { return Stricmp(c_str(), psz); }


@@ -412,7 +452,7 @@ public:
       @param  bReplaceAll: global replace (default) or only the first occurence
       @return the number of replacements made
       */
       @param  bReplaceAll: global replace (default) or only the first occurence
       @return the number of replacements made
       */

-  uint Replace(const char *szOld, const char *szNew, bool bReplaceAll = TRUE);
+  size_t Replace(const char *szOld, const char *szNew, bool bReplaceAll = TRUE);

     //@}
 
     /// check if the string contents matches a mask containing '*' and '?'
     //@}
 
     /// check if the string contents matches a mask containing '*' and '?'


@@ -431,7 +471,7 @@ public:
   //@{
     /// ensure that string has space for at least nLen characters
     // only works if the data of this string is not shared
   //@{
     /// ensure that string has space for at least nLen characters
     // only works if the data of this string is not shared

-  void Alloc(uint nLen);
+  void Alloc(size_t nLen);

     /// minimize the string's memory
     // only works if the data of this string is not shared
   void Shrink();
     /// minimize the string's memory
     // only works if the data of this string is not shared
   void Shrink();


@@ -440,7 +480,7 @@ public:
         Unget() *must* be called a.s.a.p. to put string back in a reasonable
         state!
      */
         Unget() *must* be called a.s.a.p. to put string back in a reasonable
         state!
      */

-  char *GetWriteBuf(uint nLen);
+  char *GetWriteBuf(size_t nLen);

     /// call this immediately after GetWriteBuf() has been used
   void UngetWriteBuf();
   //@}
     /// call this immediately after GetWriteBuf() has been used
   void UngetWriteBuf();
   //@}


@@ -463,17 +503,20 @@ public:
 
     /// same as Cmp
   inline int CompareTo(const char* psz, caseCompare cmp = exact) const
 
     /// same as Cmp
   inline int CompareTo(const char* psz, caseCompare cmp = exact) const

-  { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
+    { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }

 
     /// same as Mid (substring extraction)
 
     /// same as Mid (substring extraction)

-  inline wxString  operator()(size_t start, size_t len) const { return Mid(start, len); }
+  inline wxString  operator()(size_t start, size_t len) const
+    { return Mid(start, len); }

 
     /// same as += or <<
   inline wxString& Append(const char* psz) { return *this << psz; }
 
     /// same as += or <<
   inline wxString& Append(const char* psz) { return *this << psz; }

-  inline wxString& Append(char ch, int count = 1) { wxString str(ch, count); (*this) += str; return *this; }
+  inline wxString& Append(char ch, int count = 1)
+    { wxString str(ch, count); (*this) += str; return *this; }

 
     ///
 
     ///

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

     /// same as Len
   size_t Length() const { return Len(); }
     /// same as MakeLower
     /// same as Len
   size_t Length() const { return Len(); }
     /// same as MakeLower


@@ -490,17 +533,13 @@ public:
   wxString& Remove(size_t pos) { return Truncate(pos); }
   wxString& RemoveLast() { return Truncate(Len() - 1); }
 
   wxString& Remove(size_t pos) { return Truncate(pos); }
   wxString& RemoveLast() { return Truncate(Len() - 1); }
 

-  // Robert Roebling
-

   wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
 
   wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
 

-  size_t First( const char ch ) const { return find(ch); }
-  size_t First( const char* psz ) const { return find(psz); }
-  size_t First( const wxString &str ) const { return find(str); }
+  int First( const char ch ) const { return Find(ch); }
+  int First( const char* psz ) const { return Find(psz); }
+  int First( const wxString &str ) const { return Find(str); }

 
 

-  size_t Last( const char ch ) const { return rfind(ch,0); }
-  size_t Last( const char* psz ) const { return rfind(psz,0); }
-  size_t Last( const wxString &str ) const { return rfind(str,0); }
+  int Last( const char ch ) const { return Find(ch, TRUE); }

 
     /// same as IsEmpty
   bool IsNull() const { return IsEmpty(); }
 
     /// same as IsEmpty
   bool IsNull() const { return IsEmpty(); }


@@ -516,7 +555,11 @@ public:
     /** @name constructors */
     //@{
       /// take nLen chars starting at nPos
     /** @name constructors */
     //@{
       /// take nLen chars starting at nPos

-      wxString(const wxString& s, size_t nPos, size_t nLen = npos);
+      wxString(const wxString& str, size_t nPos, size_t nLen = npos)
+      {
+        wxASSERT( str.GetStringData()->IsValid() );
+        InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen);
+      }

       /// take all characters from pStart to pEnd
       wxString(const void *pStart, const void *pEnd);
     //@}
       /// take all characters from pStart to pEnd
       wxString(const void *pStart, const void *pEnd);
     //@}


@@ -643,7 +686,7 @@ public:
           size_t find(char ch, size_t nStart = 0) const;
 
           // wxWin compatibility
           size_t find(char ch, size_t nStart = 0) const;
 
           // wxWin compatibility

-          inline bool Contains(const wxString& str) { return Find(str) != -1; }
+          inline bool Contains(const wxString& str) const { return Find(str) != -1; }

 
         //@}
 
 
         //@}
 


@@ -711,49 +754,20 @@ public:
       //@{
         /// just like strcmp()
         int compare(const wxString& str) const { return Cmp(str); }
       //@{
         /// just like strcmp()
         int compare(const wxString& str) const { return Cmp(str); }

-        /// comparaison with a substring
+        /// comparison with a substring

         int compare(size_t nStart, size_t nLen, const wxString& str) const;
         int compare(size_t nStart, size_t nLen, const wxString& str) const;

-        /// comparaison of 2 substrings
+        /// comparison of 2 substrings

         int compare(size_t nStart, size_t nLen,
                     const wxString& str, size_t nStart2, size_t nLen2) const;
         /// just like strcmp()
         int compare(const char* sz) const { return Cmp(sz); }
         int compare(size_t nStart, size_t nLen,
                     const wxString& str, size_t nStart2, size_t nLen2) const;
         /// just like strcmp()
         int compare(const char* sz) const { return Cmp(sz); }

-        /// substring comparaison with first nCount characters of sz
+        /// substring comparison with first nCount characters of sz

         int compare(size_t nStart, size_t nLen,
                     const char* sz, size_t nCount = npos) const;
       //@}
     wxString substr(size_t nStart = 0, size_t nLen = npos) const;
   //@}
 #endif
         int compare(size_t nStart, size_t nLen,
                     const char* sz, size_t nCount = npos) const;
       //@}
     wxString substr(size_t nStart = 0, size_t nLen = npos) const;
   //@}
 #endif

-
-private:
-
-
-  // string (re)initialization functions
-    // initializes the string to the empty value (must be called only from
-    // ctors, use Reinit() otherwise)
-  void Init() { m_pchData = (char *)g_szNul; }
-    // initializaes the string with (a part of) C-string
-  void InitWith(const char *psz, size_t nPos = 0, size_t nLen = STRING_MAXLEN);
-    // as Init, but also frees old data
-  void Reinit() { GetStringData()->Unlock(); Init(); }
-
-  // memory allocation
-    // allocates memory for string of lenght nLen
-  void AllocBuffer(size_t nLen);
-    // copies data to another string
-  void AllocCopy(wxString&, int, int) const;
-    // effectively copies data to string
-  void AssignCopy(size_t, const char *);
-
-  // append a (sub)string
-  void ConcatCopy(int nLen1, const char *src1, int nLen2, const char *src2);
-  void ConcatSelf(int nLen, const char *src);
-
-  // functions called before writing to the string: they copy it if there
-  // other references (should be the only owner when writing)
-  void CopyBeforeWrite();
-  void AllocBeforeWrite(size_t);

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -774,7 +788,7 @@ private:
     @memo probably the most commonly used array type - array of strings
  */
 // ----------------------------------------------------------------------------
     @memo probably the most commonly used array type - array of strings
  */
 // ----------------------------------------------------------------------------

-class wxArrayString
+class WXDLLEXPORT wxArrayString

 {
 public:
   /** @name ctors and dtor */
 {
 public:
   /** @name ctors and dtor */


@@ -804,7 +818,7 @@ public:
   /** @name simple accessors */
   //@{
     /// number of elements in the array
   /** @name simple accessors */
   //@{
     /// number of elements in the array

-  uint  Count() const   { return m_nCount;      }
+  size_t  Count() const   { return m_nCount;      }

     /// is it empty?
   bool  IsEmpty() const { return m_nCount == 0; }
   //@}
     /// is it empty?
   bool  IsEmpty() const { return m_nCount == 0; }
   //@}


@@ -825,7 +839,7 @@ public:
     /**
       Search the element in the array, starting from the either side
       @param if bFromEnd reverse search direction
     /**
       Search the element in the array, starting from the either side
       @param if bFromEnd reverse search direction

-      @param if bCase, comparaison is case sensitive (default)
+      @param if bCase, comparison is case sensitive (default)

       @return index of the first item matched or NOT_FOUND
       @see NOT_FOUND
      */
       @return index of the first item matched or NOT_FOUND
       @see NOT_FOUND
      */


@@ -833,7 +847,7 @@ public:
     /// add new element at the end
   void Add   (const wxString& str);
     /// add new element at given position
     /// add new element at the end
   void Add   (const wxString& str);
     /// add new element at given position

-  void Insert(const wxString& str, uint uiIndex);
+  void Insert(const wxString& str, size_t uiIndex);

     /// remove first item matching this value
   void Remove(const char *sz);
     /// remove item by index
     /// remove first item matching this value
   void Remove(const char *sz);
     /// remove item by index


@@ -847,21 +861,15 @@ private:
   void    Grow();     // makes array bigger if needed
   void    Free();     // free the string stored
 
   void    Grow();     // makes array bigger if needed
   void    Free();     // free the string stored
 

-  size_t  m_nSize,    // current size of the array
+  size_t    m_nSize,    // current size of the array

           m_nCount;   // current number of elements
 
   char  **m_pItems;   // pointer to data
 };
 
 // ---------------------------------------------------------------------------
           m_nCount;   // current number of elements
 
   char  **m_pItems;   // pointer to data
 };
 
 // ---------------------------------------------------------------------------

-// implementation of inline functions
-// ---------------------------------------------------------------------------
-
-// Put back into class, since BC++ can't create precompiled header otherwise
-
-// ---------------------------------------------------------------------------
-/** @name wxString comparaison functions
-    @memo Comparaisons are case sensitive
+/** @name wxString comparison functions
+    @memo Comparisons are case sensitive

  */
 // ---------------------------------------------------------------------------
 //@{
  */
 // ---------------------------------------------------------------------------
 //@{


@@ -901,6 +909,11 @@ inline bool operator>=(const wxString& s1, const char  * s2) { return s1.Cmp(s2)
 ///
 inline bool operator>=(const char  * s1, const wxString& s2) { return s2.Cmp(s1) <= 0; }
 //@}
 ///
 inline bool operator>=(const char  * s1, const wxString& s2) { return s2.Cmp(s1) <= 0; }
 //@}

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

 
 // ---------------------------------------------------------------------------
 /** @name Global functions complementing standard C string library
 
 // ---------------------------------------------------------------------------
 /** @name Global functions complementing standard C string library


@@ -911,12 +924,23 @@ inline bool operator>=(const char  * s1, const wxString& s2) { return s2.Cmp(s1)
 #ifdef  STD_STRING_COMPATIBILITY
 
 // fwd decl
 #ifdef  STD_STRING_COMPATIBILITY
 
 // fwd decl

-class WXDLLEXPORT istream;
+// Known not to work with wxUSE_IOSTREAMH set to 0, so
+// replacing with includes (on advice of ungod@pasdex.com.au)
+// class WXDLLEXPORT istream;
+#if wxUSE_IOSTREAMH
+// N.B. BC++ doesn't have istream.h, ostream.h
+#include <iostream.h>
+#else
+#include <istream>
+#  ifdef _MSC_VER
+      using namespace std;
+#  endif
+#endif

 
 istream& WXDLLEXPORT operator>>(istream& is, wxString& str);
 
 #endif  //std::string compatibility
 
 
 istream& WXDLLEXPORT operator>>(istream& is, wxString& str);
 
 #endif  //std::string compatibility
 

-#endif  // __WXSTRINGH__
+#endif  // _WX_WXSTRINGH__

 
 //@}
 
 //@}