added StringTokenizer::find()

Foundation/include/Poco/StringTokenizer.h

@@ -61,7 +61,8 @@ public:
                 TOK_TRIM         = 2  /// remove leading and trailing whitespace from tokens
         };
         
-	typedef std::vector<std::string>::const_iterator Iterator;
+        typedef std::vector<std::string> TokenVec;
+        typedef TokenVec::const_iterator Iterator;
         
         StringTokenizer(const std::string& str, const std::string& separators, int options = 0);
                 /// Splits the given string into tokens. The tokens are expected to be
@@ -81,17 +82,37 @@ public:
         Iterator end() const;
         
         const std::string& operator [] (std::size_t index) const;
-		/// Returns the index'th token.
+                /// Returns const reference the index'th token.
                 /// Throws a RangeException if the index is out of range.
 
+        std::string& operator [] (std::size_t index);
+                /// Returns reference to the index'th token.
+                /// Throws a RangeException if the index is out of range.
+
+        bool has(const std::string& token) const;
+                /// Returns true if token exists, false otherwise.
+
+        std::size_t find(const std::string& token, std::size_t pos = 0) const;
+                /// Returns the index of the first occurence of the token
+                /// starting at position pos.
+                /// Throws a NotFoundException if the token is not found.
+
+        std::size_t replace(const std::string& oldToken, const std::string& newToken, std::size_t pos = 0);
+                /// Starting at position pos, replaces all subsequent tokens having value 
+                /// equal to oldToken with newToken.
+                /// Returns the number of modified tokens.
+                
         std::size_t count() const;
-		/// Returns the number of tokens.
+                /// Returns the total number of tokens.
+
+        std::size_t count(const std::string& token) const;
+                /// Returns the number of tokens equal to the specified token.
 
 private:
         StringTokenizer(const StringTokenizer&);
         StringTokenizer& operator = (const StringTokenizer&);
         
-	std::vector<std::string> _tokens;
+        TokenVec _tokens;
 };
 
 
@@ -112,6 +133,13 @@ inline StringTokenizer::Iterator StringTokenizer::end() const
 }
 
 
+inline std::string& StringTokenizer::operator [] (std::size_t index)
+{
+        if (index >= _tokens.size()) throw RangeException();
+        return _tokens[index];
+}
+
+
 inline const std::string& StringTokenizer::operator [] (std::size_t index) const
 {
         if (index >= _tokens.size()) throw RangeException();

Foundation/testsuite/src/StringTokenizerTest.cpp

@@ -1,7 +1,7 @@
 //
 // StringTokenizerTest.cpp
 //
-// $Id: //poco/1.4/Foundation/testsuite/src/StringTokenizerTest.cpp#1 $
+// $Id: //poco/svn/Foundation/testsuite/src/StringTokenizerTest.cpp#2 $
 //
 // Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
 // and Contributors.
@@ -34,9 +34,12 @@
 #include "CppUnit/TestCaller.h"
 #include "CppUnit/TestSuite.h"
 #include "Poco/StringTokenizer.h"
+#include "Poco/Exception.h"
 
 
 using Poco::StringTokenizer;
+using Poco::RangeException;
+using Poco::NotFoundException;
 
 
 StringTokenizerTest::StringTokenizerTest(const std::string& name): CppUnit::TestCase(name)
@@ -70,6 +73,7 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc", "");
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("abc") == 0);
                 assert (it != st.end());
                 assert (*it++ == "abc");
                 assert (it == st.end());
@@ -77,6 +81,7 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc ", "", StringTokenizer::TOK_TRIM);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("abc") == 0);
                 assert (it != st.end());
                 assert (*it++ == "abc");
                 assert (it == st.end());
@@ -84,6 +89,7 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("  abc  ", "", StringTokenizer::TOK_TRIM);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("abc") == 0);
                 assert (it != st.end());
                 assert (*it++ == "abc");
                 assert (it == st.end());
@@ -91,6 +97,7 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("  abc", "", StringTokenizer::TOK_TRIM);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("abc") == 0);
                 assert (it != st.end());
                 assert (*it++ == "abc");
                 assert (it == st.end());
@@ -98,6 +105,8 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc", "b");
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a") == 0);
+                assert (st.find("c") == 1);
                 assert (it != st.end());
                 assert (*it++ == "a");
                 assert (it != st.end());
@@ -107,6 +116,8 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc", "b", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a") == 0);
+                assert (st.find("c") == 1);
                 assert (it != st.end());
                 assert (*it++ == "a");
                 assert (it != st.end());
@@ -116,6 +127,8 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc", "bc");
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a") == 0);
+                assert (st.find("") == 1);
                 assert (it != st.end());
                 assert (*it++ == "a");
                 assert (it != st.end());
@@ -125,6 +138,8 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc", "bc", StringTokenizer::TOK_TRIM);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a") == 0);
+                assert (st.find("") == 1);
                 assert (it != st.end());
                 assert (*it++ == "a");
                 assert (it != st.end());
@@ -134,6 +149,7 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc", "bc", StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a") == 0);
                 assert (it != st.end());
                 assert (*it++ == "a");
                 assert (it == st.end());
@@ -141,6 +157,7 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc", "bc", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a") == 0);
                 assert (it != st.end());
                 assert (*it++ == "a");
                 assert (it == st.end());
@@ -148,6 +165,7 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc", "bc", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a") == 0);
                 assert (it != st.end());
                 assert (*it++ == "a");
                 assert (it == st.end());
@@ -155,6 +173,8 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("a a,c c", ",");
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a a") == 0);
+                assert (st.find("c c") == 1);
                 assert (it != st.end());
                 assert (*it++ == "a a");
                 assert (it != st.end());
@@ -164,6 +184,8 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("a a,c c", ",", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a a") == 0);
+                assert (st.find("c c") == 1);
                 assert (it != st.end());
                 assert (*it++ == "a a");
                 assert (it != st.end());
@@ -173,6 +195,9 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st(" a a , , c c ", ",");
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find(" a a ") == 0);
+                assert (st.find(" ") == 1);
+                assert (st.find(" c c ") == 2);
                 assert (it != st.end());
                 assert (*it++ == " a a ");
                 assert (it != st.end());
@@ -184,6 +209,9 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st(" a a , , c c ", ",", StringTokenizer::TOK_TRIM);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a a") == 0);
+                assert (st.find("") == 1);
+                assert (st.find("c c") == 2);
                 assert (it != st.end());
                 assert (*it++ == "a a");
                 assert (it != st.end());
@@ -195,6 +223,8 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st(" a a , , c c ", ",", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a a") == 0);
+                assert (st.find("c c") == 1);
                 assert (it != st.end());
                 assert (*it++ == "a a");
                 assert (it != st.end());
@@ -204,6 +234,11 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc,def,,ghi , jk,  l ", ",", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("abc") == 0);
+                assert (st.find("def") == 1);
+                assert (st.find("ghi") == 2);
+                assert (st.find("jk") == 3);
+                assert (st.find("l") == 4);
                 assert (it != st.end());
                 assert (*it++ == "abc");
                 assert (it != st.end());
@@ -219,6 +254,11 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("abc,def,,ghi // jk,  l ", ",/", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("abc") == 0);
+                assert (st.find("def") == 1);
+                assert (st.find("ghi") == 2);
+                assert (st.find("jk") == 3);
+                assert (st.find("l") == 4);
                 assert (it != st.end());
                 assert (*it++ == "abc");
                 assert (it != st.end());
@@ -234,6 +274,12 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st("a/bc,def,,ghi // jk,  l ", ",/", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("a") == 0);
+                assert (st.find("bc") == 1);
+                assert (st.find("def") == 2);
+                assert (st.find("ghi") == 3);
+                assert (st.find("jk") == 4);
+                assert (st.find("l") == 5);
                 assert (it != st.end());
                 assert (*it++ == "a");
                 assert (it != st.end());
@@ -251,6 +297,9 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st(",ab,cd,", ",");
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("") == 0);
+                assert (st.find("ab") == 1);
+                assert (st.find("cd") == 2);
                 assert (it != st.end());
                 assert (*it++ == "");
                 assert (it != st.end());
@@ -262,6 +311,8 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st(",ab,cd,", ",", StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("ab") == 0);
+                assert (st.find("cd") == 1);
                 assert (it != st.end());
                 assert (*it++ == "ab");
                 assert (it != st.end());
@@ -271,6 +322,8 @@ void StringTokenizerTest::testStringTokenizer()
         {
                 StringTokenizer st(" , ab , cd , ", ",", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
                 StringTokenizer::Iterator it = st.begin();
+                assert (st.find("ab") == 0);
+                assert (st.find("cd") == 1);
                 assert (it != st.end());
                 assert (*it++ == "ab");
                 assert (it != st.end());
@@ -283,10 +336,86 @@ void StringTokenizerTest::testStringTokenizer()
                 assert (st[0] == "1");
                 assert (st[1] == "2");
                 assert (st[2] == "3");
+                assert (st.find("1") == 0);
+                assert (st.find("2") == 1);
+                assert (st.find("3") == 2);
         }
 }
 
 
+void StringTokenizerTest::testFind()
+{
+        StringTokenizer st("0,1,2,3,3,2,1,0", ",", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
+        
+        assert (st.count() == 8);
+        assert (2 == st.count("0"));
+        assert (2 == st.count("1"));
+        assert (2 == st.count("2"));
+        assert (2 == st.count("3"));
+        assert (0 == st.count("4"));
+        assert (0 == st.count("5"));
+        assert (0 == st.count("6"));
+        assert (0 == st.count("7"));
+
+        assert (st[0] == "0");
+        assert (st[1] == "1");
+        assert (st[2] == "2");
+        assert (st[3] == "3");
+        assert (st[4] == "3");
+        assert (st[5] == "2");
+        assert (st[6] == "1");
+        assert (st[7] == "0");
+        
+        assert (st.has("0"));
+        assert (st.has("1"));
+        assert (st.has("2"));
+        assert (st.has("3"));
+        assert (!st.has("4"));
+        assert (!st.has("5"));
+        assert (!st.has("6"));
+        assert (!st.has("7"));
+
+        assert (st.find("0") == 0);
+        assert (st.find("1") == 1);
+        assert (st.find("2") == 2);
+        assert (st.find("3") == 3);
+
+        assert (st.find("0", 1) == 7);
+        assert (st.find("1", 2) == 6);
+        assert (st.find("2", 3) == 5);
+        assert (st.find("3", 4) == 4);
+
+        try
+        {
+                std::size_t p = st.find("4"); 
+                fail ("must fail");
+        }
+        catch (NotFoundException&) { }
+
+        try
+        {
+                std::string s = st[8]; 
+                fail ("must fail");
+        }
+        catch (RangeException&) { }
+
+        st[0] = "1";
+        st[7] = "1";
+        assert (st[0] == "1");
+        assert (st[7] == "1");
+        assert (0 == st.count("0"));
+        assert (4 == st.count("1"));
+
+        st.replace("2", "5");
+        assert (0 == st.count("2"));
+        assert (2 == st.count("5"));
+
+        st.replace("3", "6", 4);
+        assert (1 == st.count("3"));
+        assert (1 == st.count("6"));
+}
+
+
 void StringTokenizerTest::setUp()
 {
 }
@@ -302,6 +431,7 @@ CppUnit::Test* StringTokenizerTest::suite()
         CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("StringTokenizerTest");
 
         CppUnit_addTest(pSuite, StringTokenizerTest, testStringTokenizer);
+        CppUnit_addTest(pSuite, StringTokenizerTest, testFind);
 
         return pSuite;
 }