i18n files are installed as part of wxBase (and should be ideally part of separate...

[wxWidgets.git] / src / common / tokenzr.cpp

diff --git a/src/common/tokenzr.cpp b/src/common/tokenzr.cpp
index 0601d5d0e5f762c9d84624ab38d2713923f1a0d3..5bdae9d7fbc5f34286608c4179b565b73428a1db 100644 (file)
--- a/src/common/tokenzr.cpp
+++ b/src/common/tokenzr.cpp
@@ -1,8 +1,8 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        tokenzr.cpp
+// Name:        src/common/tokenzr.cpp

 // Purpose:     String tokenizer
 // Author:      Guilhem Lavaux
 // Purpose:     String tokenizer
 // Author:      Guilhem Lavaux

-// Modified by: Vadim Zeitlin
+// Modified by: Vadim Zeitlin (almost full rewrite)

 // Created:     04/22/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Guilhem Lavaux
 // Created:     04/22/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Guilhem Lavaux


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "tokenzr.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -30,6 +26,13 @@
 
 #include "wx/tokenzr.h"
 
 
 #include "wx/tokenzr.h"
 

+#ifndef WX_PRECOMP
+    #include "wx/arrstr.h"
+#endif
+
+// Required for wxIs... functions
+#include <ctype.h>
+

 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================


@@ -38,55 +41,119 @@
 // wxStringTokenizer construction
 // ----------------------------------------------------------------------------
 
 // wxStringTokenizer construction
 // ----------------------------------------------------------------------------
 

-wxStringTokenizer::wxStringTokenizer(const wxString& to_tokenize,
+wxStringTokenizer::wxStringTokenizer(const wxString& str,

                                      const wxString& delims,
                                      const wxString& delims,

-                                     bool ret_delims)
+                                     wxStringTokenizerMode mode)

 {
 {

-    SetString(to_tokenize, delims, ret_delims);
+    SetString(str, delims, mode);

 }
 
 }
 

-void wxStringTokenizer::SetString(const wxString& to_tokenize,
+void wxStringTokenizer::SetString(const wxString& str,

                                   const wxString& delims,
                                   const wxString& delims,

-                                  bool ret_delim)
+                                  wxStringTokenizerMode mode)

 {
 {

-    m_string = to_tokenize;
+    if ( mode == wxTOKEN_DEFAULT )
+    {
+        // by default, we behave like strtok() if the delimiters are only
+        // whitespace characters and as wxTOKEN_RET_EMPTY otherwise (for
+        // whitespace delimiters, strtok() behaviour is better because we want
+        // to count consecutive spaces as one delimiter)
+        const wxChar *p;
+        for ( p = delims.c_str(); *p; p++ )
+        {
+            if ( !wxIsspace(*p) )
+                break;
+        }
+
+        if ( *p )
+        {
+            // not whitespace char in delims
+            mode = wxTOKEN_RET_EMPTY;
+        }
+        else
+        {
+            // only whitespaces
+            mode = wxTOKEN_STRTOK;
+        }
+    }
+

     m_delims = delims;
     m_delims = delims;

-    m_retdelims = ret_delim;
-    m_pos = 0;
+    m_mode = mode;

 
 

-    // empty string doesn't have any tokens
-    m_hasMore = !m_string.empty();
+    Reinit(str);

 }
 
 }
 

-wxStringTokenizer::~wxStringTokenizer()
+void wxStringTokenizer::Reinit(const wxString& str)

 {
 {

+    wxASSERT_MSG( IsOk(), _T("you should call SetString() first") );
+
+    m_string = str;
+    m_pos = 0;
+    m_lastDelim = _T('\0');

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// count the number of tokens in the string
+// access to the tokens

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

-size_t wxStringTokenizer::CountTokens() const
+// do we have more of them?
+bool wxStringTokenizer::HasMoreTokens() const

 {
 {

-    size_t pos = 0;
-    size_t count = 0;
-    for ( ;; )
+    wxCHECK_MSG( IsOk(), false, _T("you should call SetString() first") );
+
+    if ( m_string.find_first_not_of(m_delims, m_pos) != wxString::npos )

     {
     {

-        pos = m_string.find_first_of(m_delims, pos);
-        if ( pos == wxString::npos )
+        // there are non delimiter characters left, so we do have more tokens
+        return true;
+    }
+
+    switch ( m_mode )
+    {
+        case wxTOKEN_RET_EMPTY:
+        case wxTOKEN_RET_DELIMS:
+            // special hack for wxTOKEN_RET_EMPTY: we should return the initial
+            // empty token even if there are only delimiters after it
+            return m_pos == 0 && !m_string.empty();
+
+        case wxTOKEN_RET_EMPTY_ALL:
+            // special hack for wxTOKEN_RET_EMPTY_ALL: we can know if we had
+            // already returned the trailing empty token after the last
+            // delimiter by examining m_lastDelim: it is set to NUL if we run
+            // up to the end of the string in GetNextToken(), but if it is not
+            // NUL yet we still have this last token to return even if m_pos is
+            // already at m_string.length()
+            return m_pos < m_string.length() || m_lastDelim != _T('\0');
+
+        case wxTOKEN_INVALID:
+        case wxTOKEN_DEFAULT:
+            wxFAIL_MSG( _T("unexpected tokenizer mode") );
+            // fall through
+
+        case wxTOKEN_STRTOK:
+            // never return empty delimiters

             break;
             break;

+    }

 
 

-        count++;    // one more token found
+    return false;
+}

 
 

-        pos++;      // skip delimiter
-    }
+// count the number of (remaining) tokens in the string
+size_t wxStringTokenizer::CountTokens() const
+{
+    wxCHECK_MSG( IsOk(), 0, _T("you should call SetString() first") );
+
+    // VZ: this function is IMHO not very useful, so it's probably not very
+    //     important if its implementation here is not as efficient as it
+    //     could be -- but OTOH like this we're sure to get the correct answer
+    //     in all modes
+    wxStringTokenizer tkz(m_string.c_str() + m_pos, m_delims, m_mode);

 
 

-    // normally, we didn't count the last token in the loop above - so add it
-    // unless the string was empty from the very beginning, in which case it
-    // still has 0 (and not 1) tokens
-    if ( !m_string.empty() )
+    size_t count = 0;
+    while ( tkz.HasMoreTokens() )

     {
         count++;
     {
         count++;

+
+        (void)tkz.GetNextToken();

     }
 
     return count;
     }
 
     return count;


@@ -99,32 +166,64 @@ size_t wxStringTokenizer::CountTokens() const
 wxString wxStringTokenizer::GetNextToken()
 {
     wxString token;
 wxString wxStringTokenizer::GetNextToken()
 {
     wxString token;

-    if ( HasMoreTokens() )
+    do

     {
     {

-        size_t pos = m_string.find_first_of(m_delims); // end of token
-        size_t pos2;                                   // start of the next one
-        if ( pos != wxString::npos )
+        if ( !HasMoreTokens() )

         {
         {

-            // return the delimiter too
-            pos2 = pos + 1;
+            break;

         }
         }

-        else
+
+        // find the end of this token
+        size_t pos = m_string.find_first_of(m_delims, m_pos);
+
+        // and the start of the next one
+        if ( pos == wxString::npos )

         {
         {

-            pos2 = m_string.length();
+            // no more delimiters, the token is everything till the end of
+            // string
+            token.assign(m_string, m_pos, wxString::npos);

 
 

-            // no more tokens in this string
-            m_hasMore = FALSE;
+            // skip the token
+            m_pos = m_string.length();
+
+            // it wasn't terminated
+            m_lastDelim = _T('\0');

         }
         }

+        else // we found a delimiter at pos
+        {
+            // in wxTOKEN_RET_DELIMS mode we return the delimiter character
+            // with token, otherwise leave it out
+            size_t len = pos - m_pos;
+            if ( m_mode == wxTOKEN_RET_DELIMS )
+                len++;

 
 

-        token = wxString(m_string, m_retdelims ? pos2 : pos);
+            token.assign(m_string, m_pos, len);

 
 

-        // remove token with the following it delimiter from string
-        m_string.erase(0, pos2);
+            // skip the token and the trailing delimiter
+            m_pos = pos + 1;

 
 

-        // keep track of the position in the original string too
-        m_pos += pos2;
+            m_lastDelim = m_string[pos];
+        }

     }
     }

-    //else: no more tokens, return empty token
+    while ( !AllowEmpty() && token.empty() );

 
     return token;
 }
 
     return token;
 }

+
+// ----------------------------------------------------------------------------
+// public functions
+// ----------------------------------------------------------------------------
+
+wxArrayString wxStringTokenize(const wxString& str,
+                               const wxString& delims,
+                               wxStringTokenizerMode mode)
+{
+    wxArrayString tokens;
+    wxStringTokenizer tk(str, delims, mode);
+    while ( tk.HasMoreTokens() )
+    {
+        tokens.Add(tk.GetNextToken());
+    }
+
+    return tokens;
+}