Add RunScript and implement on all backends. Document and add a very simple unit...

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

diff --git a/include/wx/string.h b/include/wx/string.h
index 65e29e10ec36b561562ce74a2e96e1133cf05f48..e1cc80ae333a718a60a8b4fa55c0cfd99ee82344 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -225,19 +225,19 @@ public:
 
     inline ~wxCStrData();
 
 
     inline ~wxCStrData();
 

-    // methods defined inline below must be declared inline or mingw32 3.4.5
-    // warns about "<symbol> defined locally after being referenced with
-    // dllimport linkage"
-#if wxUSE_UNICODE_WCHAR
-    inline
-#endif
-    const wchar_t* AsWChar() const;
+    // AsWChar() and AsChar() can't be defined here as they use wxString and so
+    // must come after it and because of this won't be inlined when called from
+    // wxString methods (without a lot of work to extract these wxString methods
+    // from inside the class itself). But we still define them being inline
+    // below to let compiler inline them from elsewhere. And because of this we
+    // must declare them as inline here because otherwise some compilers give
+    // warnings about them, e.g. mingw32 3.4.5 warns about "<symbol> defined
+    // locally after being referenced with dllimport linkage" while IRIX
+    // mipsPro 7.4 warns about "function declared inline after being called".
+    inline const wchar_t* AsWChar() const;

     operator const wchar_t*() const { return AsWChar(); }
 
     operator const wchar_t*() const { return AsWChar(); }
 

-#if !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY
-    inline
-#endif
-    const char* AsChar() const;
+    inline const char* AsChar() const;

     const unsigned char* AsUnsignedChar() const
         { return (const unsigned char *) AsChar(); }
     operator const char*() const { return AsChar(); }
     const unsigned char* AsUnsignedChar() const
         { return (const unsigned char *) AsChar(); }
     operator const char*() const { return AsChar(); }


@@ -288,7 +288,7 @@ public:
     wxCStrData operator-(ptrdiff_t n) const
     {
         wxASSERT_MSG( n <= (ptrdiff_t)m_offset,
     wxCStrData operator-(ptrdiff_t n) const
     {
         wxASSERT_MSG( n <= (ptrdiff_t)m_offset,

-                      _T("attempt to construct address before the beginning of the string") );
+                      wxT("attempt to construct address before the beginning of the string") );

         return wxCStrData(m_str, m_offset - n, m_owned);
     }
 
         return wxCStrData(m_str, m_offset - n, m_owned);
     }
 


@@ -408,6 +408,7 @@ protected:
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
     // "non dll-interface class 'wxStringPrintfMixin' used as base interface
     // for dll-interface class 'wxString'" -- this is OK in our case
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
     // "non dll-interface class 'wxStringPrintfMixin' used as base interface
     // for dll-interface class 'wxString'" -- this is OK in our case

+    #pragma warning (push)

     #pragma warning (disable:4275)
 #endif
 
     #pragma warning (disable:4275)
 #endif
 


@@ -1003,9 +1004,19 @@ public:
       iterator operator-(ptrdiff_t n) const
         { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
 
       iterator operator-(ptrdiff_t n) const
         { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
 

+      // Normal iterators need to be comparable with the const_iterators so
+      // declare the comparison operators and implement them below after the
+      // full const_iterator declaration.
+      bool operator==(const const_iterator& i) const;
+      bool operator!=(const const_iterator& i) const;
+      bool operator<(const const_iterator& i) const;
+      bool operator>(const const_iterator& i) const;
+      bool operator<=(const const_iterator& i) const;
+      bool operator>=(const const_iterator& i) const;
+

   private:
   private:

-      iterator(wxString *str, underlying_iterator ptr)
-          : m_cur(ptr), m_node(str, &m_cur) {}
+      iterator(wxString *wxstr, underlying_iterator ptr)
+          : m_cur(ptr), m_node(wxstr, &m_cur) {}

 
       wxString* str() const { return const_cast<wxString*>(m_node.m_str); }
 
 
       wxString* str() const { return const_cast<wxString*>(m_node.m_str); }
 


@@ -1047,10 +1058,15 @@ public:
       const_iterator operator-(ptrdiff_t n) const
         { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
 
       const_iterator operator-(ptrdiff_t n) const
         { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
 

+      // Notice that comparison operators taking non-const iterator are not
+      // needed here because of the implicit conversion from non-const iterator
+      // to const ones ensure that the versions for const_iterator declared
+      // inside WX_STR_ITERATOR_IMPL can be used.
+

   private:
       // for internal wxString use only:
   private:
       // for internal wxString use only:

-      const_iterator(const wxString *str, underlying_iterator ptr)
-          : m_cur(ptr), m_node(str, &m_cur) {}
+      const_iterator(const wxString *wxstr, underlying_iterator ptr)
+          : m_cur(ptr), m_node(wxstr, &m_cur) {}

 
       const wxString* str() const { return m_node.m_str; }
 
 
       const wxString* str() const { return m_node.m_str; }
 


@@ -1082,6 +1098,15 @@ public:
       iterator operator-(ptrdiff_t n) const
         { return iterator(wxStringOperations::AddToIter(m_cur, -n)); }
 
       iterator operator-(ptrdiff_t n) const
         { return iterator(wxStringOperations::AddToIter(m_cur, -n)); }
 

+      // As in UTF-8 case above, define comparison operators taking
+      // const_iterator too.
+      bool operator==(const const_iterator& i) const;
+      bool operator!=(const const_iterator& i) const;
+      bool operator<(const const_iterator& i) const;
+      bool operator>(const const_iterator& i) const;
+      bool operator<=(const const_iterator& i) const;
+      bool operator>=(const const_iterator& i) const;
+

   private:
       // for internal wxString use only:
       iterator(underlying_iterator ptr) : m_cur(ptr) {}
   private:
       // for internal wxString use only:
       iterator(underlying_iterator ptr) : m_cur(ptr) {}


@@ -1109,6 +1134,11 @@ public:
       const_iterator operator-(ptrdiff_t n) const
         { return const_iterator(wxStringOperations::AddToIter(m_cur, -n)); }
 
       const_iterator operator-(ptrdiff_t n) const
         { return const_iterator(wxStringOperations::AddToIter(m_cur, -n)); }
 

+      // As in UTF-8 case above, we don't need comparison operators taking
+      // iterator because we have an implicit conversion from iterator to
+      // const_iterator so the operators declared by WX_STR_ITERATOR_IMPL will
+      // be used.
+

   private:
       // for internal wxString use only:
       const_iterator(underlying_iterator ptr) : m_cur(ptr) {}
   private:
       // for internal wxString use only:
       const_iterator(underlying_iterator ptr) : m_cur(ptr) {}


@@ -1315,12 +1345,13 @@ public:
   }
 #endif // wxUSE_STRING_POS_CACHE
 
   }
 #endif // wxUSE_STRING_POS_CACHE
 

-  // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
-  // implicit conversions from std::string to wxString and vice verse as this
-  // allows to use the same strings in non-GUI and GUI code, however we don't
-  // want to unconditionally add this ctor as it would make wx lib dependent on
-  // libstdc++ on some Linux versions which is bad, so instead we ask the
-  // client code to define this wxUSE_STD_STRING symbol if they need it
+  // even if we're not built with wxUSE_STD_STRING_CONV_IN_WXSTRING == 1 it is
+  // very convenient to allow implicit conversions from std::string to wxString
+  // and vice verse as this allows to use the same strings in non-GUI and GUI
+  // code, however we don't want to unconditionally add this ctor as it would
+  // make wx lib dependent on libstdc++ on some Linux versions which is bad, so
+  // instead we ask the client code to define this wxUSE_STD_STRING symbol if
+  // they need it

 #if wxUSE_STD_STRING
   #if wxUSE_UNICODE_WCHAR
     wxString(const wxStdWideString& str) : m_impl(str) {}
 #if wxUSE_STD_STRING
   #if wxUSE_UNICODE_WCHAR
     wxString(const wxStdWideString& str) : m_impl(str) {}


@@ -1338,34 +1369,57 @@ public:
   #endif
 #endif // wxUSE_STD_STRING
 
   #endif
 #endif // wxUSE_STD_STRING
 

-  // Unlike ctor from std::string, we provide conversion to std::string only
-  // if wxUSE_STL and not merely wxUSE_STD_STRING (which is on by default),
-  // because it conflicts with operator const char/wchar_t*:
-#if wxUSE_STL
+  // Also always provide explicit conversions to std::[w]string in any case,
+  // see below for the implicit ones.
+#if wxUSE_STD_STRING
+  // We can avoid a copy if we already use this string type internally,
+  // otherwise we create a copy on the fly:

   #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING
   #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING

-    // wxStringImpl is std::string in the encoding we want
-    operator const wxStdWideString&() const { return m_impl; }
+    #define wxStringToStdWstringRetType const wxStdWideString&
+    const wxStdWideString& ToStdWstring() const { return m_impl; }

   #else
     // wxStringImpl is either not std::string or needs conversion
   #else
     // wxStringImpl is either not std::string or needs conversion

-    operator wxStdWideString() const
+    #define wxStringToStdWstringRetType wxStdWideString
+    wxStdWideString ToStdWstring() const

     {
     {

+#if wxUSE_UNICODE_WCHAR
+        wxScopedWCharBuffer buf =
+            wxScopedWCharBuffer::CreateNonOwned(m_impl.c_str(), m_impl.length());
+#else // !wxUSE_UNICODE_WCHAR

         wxScopedWCharBuffer buf(wc_str());
         wxScopedWCharBuffer buf(wc_str());

+#endif
+

         return wxStdWideString(buf.data(), buf.length());
     }
   #endif
 
   #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING
     // wxStringImpl is std::string in the encoding we want
         return wxStdWideString(buf.data(), buf.length());
     }
   #endif
 
   #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING
     // wxStringImpl is std::string in the encoding we want

-    operator const std::string&() const { return m_impl; }
+    #define wxStringToStdStringRetType const std::string&
+    const std::string& ToStdString() const { return m_impl; }

   #else
     // wxStringImpl is either not std::string or needs conversion
   #else
     // wxStringImpl is either not std::string or needs conversion

-    operator std::string() const
+    #define wxStringToStdStringRetType std::string
+    std::string ToStdString() const

     {
         wxScopedCharBuffer buf(mb_str());
         return std::string(buf.data(), buf.length());
     }
   #endif
     {
         wxScopedCharBuffer buf(mb_str());
         return std::string(buf.data(), buf.length());
     }
   #endif

-#endif // wxUSE_STL
+
+#if wxUSE_STD_STRING_CONV_IN_WXSTRING
+    // Implicit conversions to std::[w]string are not provided by default as
+    // they conflict with the implicit conversions to "const char/wchar_t *"
+    // which we use for backwards compatibility but do provide them if
+    // explicitly requested.
+  operator wxStringToStdStringRetType() const { return ToStdString(); }
+  operator wxStringToStdWstringRetType() const { return ToStdWstring(); }
+#endif // wxUSE_STD_STRING_CONV_IN_WXSTRING
+
+#undef wxStringToStdStringRetType
+#undef wxStringToStdWstringRetType
+
+#endif // wxUSE_STD_STRING

 
   wxString Clone() const
   {
 
   wxString Clone() const
   {


@@ -1512,14 +1566,14 @@ public:
     // get last character
     wxUniChar Last() const
     {
     // get last character
     wxUniChar Last() const
     {

-      wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
+      wxASSERT_MSG( !empty(), wxT("wxString: index out of bounds") );

       return *rbegin();
     }
 
     // get writable last character
     wxUniCharRef Last()
     {
       return *rbegin();
     }
 
     // get writable last character
     wxUniCharRef Last()
     {

-      wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
+      wxASSERT_MSG( !empty(), wxT("wxString: index out of bounds") );

       return *rbegin();
     }
 
       return *rbegin();
     }
 


@@ -1600,11 +1654,12 @@ public:
     operator wxCStrData() const { return c_str(); }
 
     // the first two operators conflict with operators for conversion to
     operator wxCStrData() const { return c_str(); }
 
     // the first two operators conflict with operators for conversion to

-    // std::string and they must be disabled in STL build; the next one only
-    // makes sense if conversions to char* are also defined and not defining it
-    // in STL build also helps us to get more clear error messages for the code
-    // which relies on implicit conversion to char* in STL build
-#if !wxUSE_STL
+    // std::string and they must be disabled if those conversions are enabled;
+    // the next one only makes sense if conversions to char* are also defined
+    // and not defining it in STL build also helps us to get more clear error
+    // messages for the code which relies on implicit conversion to char* in
+    // STL build
+#if !wxUSE_STD_STRING_CONV_IN_WXSTRING

     operator const char*() const { return c_str(); }
     operator const wchar_t*() const { return c_str(); }
 
     operator const char*() const { return c_str(); }
     operator const wchar_t*() const { return c_str(); }
 


@@ -1612,7 +1667,7 @@ public:
     // wxWidgets versions: this is the same as conversion to const char * so it
     // may fail!
     operator const void*() const { return c_str(); }
     // wxWidgets versions: this is the same as conversion to const char * so it
     // may fail!
     operator const void*() const { return c_str(); }

-#endif // wxUSE_STL
+#endif // !wxUSE_STD_STRING_CONV_IN_WXSTRING

 
     // identical to c_str(), for MFC compatibility
     const wxCStrData GetData() const { return c_str(); }
 
     // identical to c_str(), for MFC compatibility
     const wxCStrData GetData() const { return c_str(); }


@@ -1781,7 +1836,8 @@ public:
     // version for NUL-terminated data:
     static wxString From8BitData(const char *data)
       { return wxString(data); }
     // version for NUL-terminated data:
     static wxString From8BitData(const char *data)
       { return wxString(data); }

-    const char *To8BitData() const { return c_str(); }
+    const wxScopedCharBuffer To8BitData() const
+        { return wxScopedCharBuffer::CreateNonOwned(wx_str(), length()); }

 #endif // Unicode/ANSI
 
     // conversions with (possible) format conversions: have to return a
 #endif // Unicode/ANSI
 
     // conversions with (possible) format conversions: have to return a


@@ -1962,7 +2018,7 @@ public:
   {
 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
     wxASSERT_MSG( s.IsValid(),
   {
 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
     wxASSERT_MSG( s.IsValid(),

-                  _T("did you forget to call UngetWriteBuf()?") );
+                  wxT("did you forget to call UngetWriteBuf()?") );

 #endif
 
     append(s);
 #endif
 
     append(s);


@@ -2056,36 +2112,34 @@ public:
   // stream-like functions
       // insert an int into string
   wxString& operator<<(int i)
   // stream-like functions
       // insert an int into string
   wxString& operator<<(int i)

-    { return (*this) << Format(_T("%d"), i); }
+    { return (*this) << Format(wxT("%d"), i); }

       // insert an unsigned int into string
   wxString& operator<<(unsigned int ui)
       // insert an unsigned int into string
   wxString& operator<<(unsigned int ui)

-    { return (*this) << Format(_T("%u"), ui); }
+    { return (*this) << Format(wxT("%u"), ui); }

       // insert a long into string
   wxString& operator<<(long l)
       // insert a long into string
   wxString& operator<<(long l)

-    { return (*this) << Format(_T("%ld"), l); }
+    { return (*this) << Format(wxT("%ld"), l); }

       // insert an unsigned long into string
   wxString& operator<<(unsigned long ul)
       // insert an unsigned long into string
   wxString& operator<<(unsigned long ul)

-    { return (*this) << Format(_T("%lu"), ul); }
-#if defined wxLongLong_t && !defined wxLongLongIsLong
+    { return (*this) << Format(wxT("%lu"), ul); }
+#ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG

       // insert a long long if they exist and aren't longs
   wxString& operator<<(wxLongLong_t ll)
     {
       // insert a long long if they exist and aren't longs
   wxString& operator<<(wxLongLong_t ll)
     {

-      const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("d");
-      return (*this) << Format(fmt, ll);
+      return (*this) << Format("%" wxLongLongFmtSpec "d", ll);

     }
       // insert an unsigned long long
   wxString& operator<<(wxULongLong_t ull)
     {
     }
       // insert an unsigned long long
   wxString& operator<<(wxULongLong_t ull)
     {

-      const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u");
-      return (*this) << Format(fmt , ull);
+      return (*this) << Format("%" wxLongLongFmtSpec "u" , ull);

     }
     }

-#endif // wxLongLong_t && !wxLongLongIsLong
+#endif // wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG

       // insert a float into string
   wxString& operator<<(float f)
       // insert a float into string
   wxString& operator<<(float f)

-    { return (*this) << Format(_T("%f"), f); }
+    { return (*this) << Format(wxT("%f"), f); }

       // insert a double into string
   wxString& operator<<(double d)
       // insert a double into string
   wxString& operator<<(double d)

-    { return (*this) << Format(_T("%g"), d); }
+    { return (*this) << Format(wxT("%g"), d); }

 
   // string comparison
     // case-sensitive comparison (returns a value < 0, = 0 or > 0)
 
   // string comparison
     // case-sensitive comparison (returns a value < 0, = 0 or > 0)


@@ -2163,11 +2217,13 @@ public:
       // get last nCount characters
   wxString Right(size_t nCount) const;
       // get all characters before the first occurrence of ch
       // get last nCount characters
   wxString Right(size_t nCount) const;
       // get all characters before the first occurrence of ch

-      // (returns the whole string if ch not found)
-  wxString BeforeFirst(wxUniChar ch) const;
+      // (returns the whole string if ch not found) and also put everything
+      // following the first occurrence of ch into rest if it's non-NULL
+  wxString BeforeFirst(wxUniChar ch, wxString *rest = NULL) const;

       // get all characters before the last occurrence of ch
       // get all characters before the last occurrence of ch

-      // (returns empty string if ch not found)
-  wxString BeforeLast(wxUniChar ch) const;
+      // (returns empty string if ch not found) and also put everything
+      // following the last occurrence of ch into rest if it's non-NULL
+  wxString BeforeLast(wxUniChar ch, wxString *rest = NULL) const;

       // get all characters after the first occurrence of ch
       // (returns empty string if ch not found)
   wxString AfterFirst(wxUniChar ch) const;
       // get all characters after the first occurrence of ch
       // (returns empty string if ch not found)
   wxString AfterFirst(wxUniChar ch) const;


@@ -2263,7 +2319,6 @@ public:
       // convert to a double
   bool ToDouble(double *val) const;
 
       // convert to a double
   bool ToDouble(double *val) const;
 

-#if wxUSE_XLOCALE

   // conversions to numbers using C locale
       // convert to a signed integer
   bool ToCLong(long *val, int base = 10) const;
   // conversions to numbers using C locale
       // convert to a signed integer
   bool ToCLong(long *val, int base = 10) const;


@@ -2271,8 +2326,14 @@ public:
   bool ToCULong(unsigned long *val, int base = 10) const;
       // convert to a double
   bool ToCDouble(double *val) const;
   bool ToCULong(unsigned long *val, int base = 10) const;
       // convert to a double
   bool ToCDouble(double *val) const;

-#endif
-  
+
+  // create a string representing the given floating point number with the
+  // default (like %g) or fixed (if precision >=0) precision
+    // in the current locale
+  static wxString FromDouble(double val, int precision = -1);
+    // in C locale
+  static wxString FromCDouble(double val, int precision = -1);
+

 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
   // formatted input/output
     // as sprintf(), returns the number of characters written or < 0 on error
 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
   // formatted input/output
     // as sprintf(), returns the number of characters written or < 0 on error


@@ -2427,7 +2488,7 @@ public:
                CreateConstIterator(last).impl())
   {
       wxASSERT_MSG( first.m_str == last.m_str,
                CreateConstIterator(last).impl())
   {
       wxASSERT_MSG( first.m_str == last.m_str,

-                    _T("pointers must be into the same string") );
+                    wxT("pointers must be into the same string") );

   }
 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
 
   }
 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
 


@@ -3576,7 +3637,7 @@ private:
 };
 
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 };
 
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN

-    #pragma warning (default:4275)
+    #pragma warning (pop)

 #endif
 
 // string iterator operators that satisfy STL Random Access Iterator
 #endif
 
 // string iterator operators that satisfy STL Random Access Iterator


@@ -4023,6 +4084,21 @@ inline bool operator!=(const wxString& s, const wxUniCharRef& c) { return !s.IsS
 inline bool operator!=(const wxString& s, char c) { return !s.IsSameAs(c); }
 inline bool operator!=(const wxString& s, wchar_t c) { return !s.IsSameAs(c); }
 
 inline bool operator!=(const wxString& s, char c) { return !s.IsSameAs(c); }
 inline bool operator!=(const wxString& s, wchar_t c) { return !s.IsSameAs(c); }
 

+
+// wxString iterators comparisons
+inline bool wxString::iterator::operator==(const const_iterator& i) const
+    { return i == *this; }
+inline bool wxString::iterator::operator!=(const const_iterator& i) const
+    { return i != *this; }
+inline bool wxString::iterator::operator<(const const_iterator& i) const
+    { return i > *this; }
+inline bool wxString::iterator::operator>(const const_iterator& i) const
+    { return i < *this; }
+inline bool wxString::iterator::operator<=(const const_iterator& i) const
+    { return i >= *this; }
+inline bool wxString::iterator::operator>=(const const_iterator& i) const
+    { return i <= *this; }
+

 // comparison with C string in Unicode build
 #if wxUSE_UNICODE
 
 // comparison with C string in Unicode build
 #if wxUSE_UNICODE
 


@@ -4164,7 +4240,7 @@ inline const wxStringCharType *wxCStrData::AsInternal() const
 inline wxUniChar wxCStrData::operator*() const
 {
     if ( m_str->empty() )
 inline wxUniChar wxCStrData::operator*() const
 {
     if ( m_str->empty() )

-        return wxUniChar(_T('\0'));
+        return wxUniChar(wxT('\0'));

     else
         return (*m_str)[m_offset];
 }
     else
         return (*m_str)[m_offset];
 }