Generic dirctrl corrections

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

diff --git a/include/wx/string.h b/include/wx/string.h
index cf7a45ac25ca6f976b7f4f9f5e6599d93ad08040..fe9787845f32bf2ccc0b246c6a081cb8a9477ce4 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -38,7 +38,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __WXMAC__
+#if defined(__WXMAC__) || defined(__VISAGECPP__)

     #include <ctype.h>
 #endif
 
     #include <ctype.h>
 #endif
 


@@ -46,18 +46,26 @@
     #include <std.h>
 #endif
 
     #include <std.h>
 #endif
 

-#include <string.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <limits.h>
-#include <stdlib.h>
+#if defined(__VISAGECPP__) && __IBMCPP__ >= 400
+   // problem in VACPP V4 with including stdlib.h multiple times
+   // strconv includes it anyway
+#  include <stdio.h>
+#  include <string.h>
+#  include <stdarg.h>
+#  include <limits.h>
+#else
+#  include <string.h>
+#  include <stdio.h>
+#  include <stdarg.h>
+#  include <limits.h>
+#  include <stdlib.h>
+#endif

 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 #endif // AIX
 
 #include "wx/defs.h"        // everybody should include this
 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 #endif // AIX
 
 #include "wx/defs.h"        // everybody should include this

-#include "wx/debug.h"       // for wxASSERT()

 #include "wx/wxchar.h"      // for wxChar
 #include "wx/buffer.h"      // for wxCharBuffer
 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes
 #include "wx/wxchar.h"      // for wxChar
 #include "wx/buffer.h"      // for wxCharBuffer
 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes


@@ -85,10 +93,17 @@
 // constants
 // ----------------------------------------------------------------------------
 
 // constants
 // ----------------------------------------------------------------------------
 

+#if defined(__VISAGECPP__) && __IBMCPP__ >= 400
+// must define this static for VA or else you get multiply defined symbols everywhere
+extern const unsigned int wxSTRING_MAXLEN;
+
+#else

 // maximum possible length for a string means "take all string" everywhere
 //  (as sizeof(StringData) is unknown here, we substract 100)
 const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
 
 // maximum possible length for a string means "take all string" everywhere
 //  (as sizeof(StringData) is unknown here, we substract 100)
 const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
 

+#endif
+

 // ----------------------------------------------------------------------------
 // global data
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // global data
 // ----------------------------------------------------------------------------


@@ -189,6 +204,12 @@ 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
+#if defined(__VISUALC__) && (__VISUALC__ >= 1200)
+  __forceinline
+#endif

   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this);  }
 
   // if we had taken control over string memory (GetWriteBuf), it's
   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this);  }
 
   // if we had taken control over string memory (GetWriteBuf), it's


@@ -271,7 +292,9 @@ private:
   //
   // try `s << i' or `s.Printf("%d", i)' instead
   wxString(int);
   //
   // try `s << i' or `s.Printf("%d", i)' instead
   wxString(int);

+  wxString(unsigned int);

   wxString(long);
   wxString(long);

+  wxString(unsigned long);

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


@@ -297,6 +320,8 @@ public:
     // (default value of wxSTRING_MAXLEN means take all the string)
   wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
     { InitWith(psz, 0, nLength); }
     // (default value of wxSTRING_MAXLEN means take all the string)
   wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
     { InitWith(psz, 0, nLength); }

+  wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = wxSTRING_MAXLEN)
+    { InitWith(psz, 0, nLength); }

 
 #if wxUSE_UNICODE
     // from multibyte string
 
 #if wxUSE_UNICODE
     // from multibyte string


@@ -310,13 +335,10 @@ public:
     // from C string (for compilers using unsigned char)
   wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
     { InitWith((const char*)psz, 0, nLength); }
     // from C string (for compilers using unsigned char)
   wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
     { InitWith((const char*)psz, 0, nLength); }

-    // from multibyte string
-  wxString(const char *psz, wxMBConv& WXUNUSED(conv) , size_t nLength = wxSTRING_MAXLEN)
-    { InitWith(psz, 0, nLength); }

 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string

-  wxString(const wchar_t *pwz);
+  wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc);

 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer
 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer


@@ -391,7 +413,7 @@ public:
     wxChar  operator[](unsigned int n) const
       { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
 #endif
     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]; }


@@ -405,18 +427,30 @@ public:
     operator const wxChar*() const { return m_pchData; }
     // explicit conversion to C string (use this with printf()!)
     const wxChar* c_str()   const { return m_pchData; }
     operator const wxChar*() const { return m_pchData; }
     // explicit conversion to C string (use this with printf()!)
     const wxChar* c_str()   const { return m_pchData; }

-    // (and this with [wx]Printf()!)
+    // identical to c_str()

     const wxChar* wx_str()  const { return m_pchData; }
     // identical to c_str()
     const wxChar* GetData() const { return m_pchData; }
 
     // conversions with (possible) format convertions: have to return a
     // buffer with temporary data
     const wxChar* wx_str()  const { return m_pchData; }
     // identical to c_str()
     const wxChar* GetData() const { return m_pchData; }
 
     // conversions with (possible) format convertions: have to return a
     // buffer with temporary data

+    //
+    // the functions defined (in either Unicode or ANSI) mode are mb_str() to
+    // return an ANSI (multibyte) string, wc_str() to return a wide string and
+    // fn_str() to return a string which should be used with the OS APIs
+    // accepting the file names. The return value is always the same, but the
+    // type differs because a function may either return pointer to the buffer
+    // directly or have to use intermediate buffer for translation.

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-    const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const { return conv.cWC2MB(m_pchData); }
+    const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const
+        { return conv.cWC2MB(m_pchData); }
+

     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 

-    const wxChar* wc_str(wxMBConv& WXUNUSED(conv) = wxConvLibc) const { return m_pchData; }
+    const wxChar* wc_str() const { return m_pchData; }
+
+    // for compatibility with !wxUSE_UNICODE version
+    const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }

 
 #if wxMBFILES
     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
 
 #if wxMBFILES
     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }


@@ -424,17 +458,18 @@ public:
     const wxChar* fn_str() const { return m_pchData; }
 #endif // wxMBFILES/!wxMBFILES
 #else // ANSI
     const wxChar* fn_str() const { return m_pchData; }
 #endif // wxMBFILES/!wxMBFILES
 #else // ANSI

-#if wxUSE_MULTIBYTE
-    const wxChar* mb_str(wxMBConv& WXUNUSED(conv) = wxConvLibc) const
-        { return m_pchData; }
-    const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
-#else // !mmultibyte

     const wxChar* mb_str() const { return m_pchData; }
     const wxChar* mb_str() const { return m_pchData; }

+
+    // for compatibility with wxUSE_UNICODE version
+    const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
+

     const wxWX2MBbuf mbc_str() const { return mb_str(); }
     const wxWX2MBbuf mbc_str() const { return mb_str(); }

-#endif // multibyte/!multibyte
+

 #if wxUSE_WCHAR_T
 #if wxUSE_WCHAR_T

-    const wxWCharBuffer wc_str(wxMBConv& conv) const { return conv.cMB2WC(m_pchData); }
+    const wxWCharBuffer wc_str(wxMBConv& conv) const
+        { return conv.cMB2WC(m_pchData); }

 #endif // wxUSE_WCHAR_T
 #endif // wxUSE_WCHAR_T

+

     const wxChar* fn_str() const { return m_pchData; }
 #endif // Unicode/ANSI
 
     const wxChar* fn_str() const { return m_pchData; }
 #endif // Unicode/ANSI
 


@@ -502,6 +537,8 @@ public:
     // append count copies of given character
   wxString& Append(wxChar ch, size_t count = 1u)
     { wxString str(ch, count); return *this << str; }
     // append count copies of given character
   wxString& Append(wxChar ch, size_t count = 1u)
     { wxString str(ch, count); return *this << str; }

+  wxString& Append(const wxChar* psz, size_t nLen)
+    { ConcatSelf(nLen, psz); return *this; }

 
     // prepend a string, return the string itself
   wxString& Prepend(const wxString& str)
 
     // prepend a string, return the string itself
   wxString& Prepend(const wxString& str)


@@ -521,11 +558,23 @@ public:
 
   // stream-like functions
       // insert an int into string
 
   // stream-like functions
       // insert an int into string

-  wxString& operator<<(int i);
+  wxString& operator<<(int i)
+    { return (*this) << Format(_T("%d"), i); }
+      // insert an unsigned int into string
+  wxString& operator<<(unsigned int ui)
+    { return (*this) << Format(_T("%u"), ui); }
+      // insert a long into string
+  wxString& operator<<(long l)
+    { return (*this) << Format(_T("%ld"), l); }
+      // insert an unsigned long into string
+  wxString& operator<<(unsigned long ul)
+    { return (*this) << Format(_T("%lu"), ul); }

       // insert a float into string
       // insert a float into string

-  wxString& operator<<(float f);
+  wxString& operator<<(float f)
+    { return (*this) << Format(_T("%f"), f); }

       // insert a double into string
       // insert a double into string

-  wxString& operator<<(double d);
+  wxString& operator<<(double d)
+    { return (*this) << Format(_T("%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)


@@ -548,10 +597,15 @@ public:
       // if nCount = default value)
   wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const;
 
       // if nCount = default value)
   wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const;
 

-    // operator version of Mid()
+      // operator version of Mid()

   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
+      // string in the provided pointer if it is not NULL, otherwise return
+      // FALSE
+  bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
+

       // get first nCount characters
   wxString Left(size_t nCount) const;
       // get last nCount characters
       // get first nCount characters
   wxString Left(size_t nCount) const;
       // get last nCount characters


@@ -606,12 +660,26 @@ public:
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxChar *szMask) const;
 
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxChar *szMask) const;
 

+    // 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;
+        // convert to an unsigned integer
+    bool ToULong(unsigned long *val) const;
+        // convert to a double
+    bool ToDouble(double *val) const;
+

   // formated input/output
     // as sprintf(), returns the number of characters written or < 0 on error
   int Printf(const wxChar *pszFormat, ...);
     // as vprintf(), returns the number of characters written or < 0 on error
   int PrintfV(const wxChar* pszFormat, va_list argptr);
 
   // formated input/output
     // as sprintf(), returns the number of characters written or < 0 on error
   int Printf(const wxChar *pszFormat, ...);
     // as vprintf(), returns the number of characters written or < 0 on error
   int PrintfV(const wxChar* pszFormat, va_list argptr);
 

+    // returns the string containing the result of Printf() to it
+  static wxString Format(const wxChar *pszFormat, ...);
+    // the same as above, but takes a va_list
+  static wxString FormatV(const wxChar *pszFormat, va_list argptr);
+

   // 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
   // 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


@@ -624,6 +692,7 @@ public:
   wxChar *GetWriteBuf(size_t nLen);
     // call this immediately after GetWriteBuf() has been used
   void UngetWriteBuf();
   wxChar *GetWriteBuf(size_t nLen);
     // call this immediately after GetWriteBuf() has been used
   void UngetWriteBuf();

+  void UngetWriteBuf(size_t nLen);

 
   // wxWindows version 1 compatibility functions
 
 
   // wxWindows version 1 compatibility functions
 


@@ -705,6 +774,8 @@ public:
   void clear() { Empty(); }
     // returns true if the string is empty
   bool empty() const { return IsEmpty(); }
   void clear() { Empty(); }
     // returns true if the string is empty
   bool empty() const { return IsEmpty(); }

+    // inform string about planned change in size
+  void reserve(size_t size) { Alloc(size); }

 
   // lib.string.access
     // return the character at position n
 
   // lib.string.access
     // return the character at position n


@@ -857,7 +928,8 @@ public:
               const wxChar* sz, size_t nCount = npos) const;
 
   // substring extraction
               const wxChar* sz, size_t nCount = npos) const;
 
   // substring extraction

-  wxString substr(size_t nStart = 0, size_t nLen = npos) const;
+  wxString substr(size_t nStart = 0, size_t nLen = npos) const
+    { return Mid(nStart, nLen); }

 #endif // wxSTD_STRING_COMPATIBILITY
 };
 
 #endif // wxSTD_STRING_COMPATIBILITY
 };
 


@@ -944,6 +1016,12 @@ public:
     // sort array elements using specified comparaison function
   void Sort(CompareFunction compareFunction);
 
     // 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 Copy(const wxArrayString& src);  // copies the contents of another array
 
 protected:
   void Copy(const wxArrayString& src);  // copies the contents of another array
 


@@ -1022,11 +1100,19 @@ inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
     { return (s1.Cmp((const wchar_t *)s2) == 0); }
 inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const wchar_t *)s1) == 0); }
     { return (s1.Cmp((const wchar_t *)s2) == 0); }
 inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const wchar_t *)s1) == 0); }

+inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
+    { return (s1.Cmp((const wchar_t *)s2) != 0); }
+inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
+    { return (s2.Cmp((const wchar_t *)s1) != 0); }

 #else
 inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
     { return (s1.Cmp((const char *)s2) == 0); }
 inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const char *)s1) == 0); }
 #else
 inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
     { return (s1.Cmp((const char *)s2) == 0); }
 inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const char *)s1) == 0); }

+inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
+    { return (s1.Cmp((const char *)s2) != 0); }
+inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
+    { return (s2.Cmp((const char *)s1) != 0); }

 #endif
 
 wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
 #endif
 
 wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);