первый

lib/strutil.cpp

@@ -0,0 +1,191 @@
+////////////////////////////////////////////////////////////////////////////////
+// @(#) strutil.cpp
+// Utilities for std::string
+// defined in namespace strutil
+// by James Fancy
+////////////////////////////////////////////////////////////////////////////////
+
+#include "strutil.h"
+#include <algorithm>
+
+namespace strutil {
+
+    using namespace std;
+
+    string trimLeft(const string& str) {
+        string t = str;
+		string::iterator i;
+        for (i = t.begin(); i != t.end(); i++) {
+            if (!isspace(*i)) {
+                break;
+            }
+        }
+		if (i == t.end()) {
+			t.clear();
+		} else {
+			t.erase(t.begin(), i);
+		}
+        return t;
+    }
+
+    string trimRight(const string& str) {
+        if (str.begin() == str.end()) {
+            return str;
+        }
+
+        string t = str;
+		string::iterator i;
+        for (i = t.end() - 1; ;i--) {
+            if (!isspace(*i)) {
+                t.erase(i + 1, t.end());
+                break;
+            }
+			if (i == t.begin()) {
+				t.clear();
+				break;
+			}
+        }
+        return t;
+    }
+
+    string trim(const string& str) {
+        string t = str;
+
+        string::iterator i;
+        for (i = t.begin(); i != t.end(); i++) {
+            if (!isspace(*i)) {
+                break;
+            }
+        }
+		if (i == t.end()) {
+			t.clear();
+			return t;
+		} else {
+			t.erase(t.begin(), i);
+		}
+
+		for (i = t.end() - 1; ;i--) {
+			if (!isspace(*i)) {
+				t.erase(i + 1, t.end());
+				break;
+			}
+			if (i == t.begin()) {
+				t.clear();
+				break;
+			}
+		}
+
+        return t;
+    }
+
+    string toLower(const string& str) {
+        string t = str;
+        transform(t.begin(), t.end(), t.begin(), tolower);
+        return t;
+    }
+
+    string toUpper(const string& str) {
+        string t = str;
+        transform(t.begin(), t.end(), t.begin(), toupper);
+        return t;
+    }
+
+    string repeat(char c, int n) {
+        ostringstream s;
+        s << setw(n) << setfill(c) << "";
+        return s.str();
+    }
+
+    string repeat(const string& str, int n) {
+        string s;
+        for (int i = 0; i < n; i++) {
+            s += str;
+        }
+        return s;
+    }
+
+    bool startsWith(const string& str, const string& substr) {
+        return str.find(substr) == 0;
+    }
+
+    bool endsWith(const string& str, const string& substr) {
+        size_t i = str.rfind(substr);
+        return (i != string::npos) && (i == (str.length() - substr.length()));
+    }
+
+    bool equalsIgnoreCase(const string& str1, const string& str2) {
+        return toLower(str1) == toLower(str2);
+    }
+
+    template<bool>
+    bool parseString(const std::string& str) {
+        bool value;
+        std::istringstream iss(str);
+        iss >> boolalpha >> value;
+        return value;
+    }
+
+    string toString(const bool& value) {
+        ostringstream oss;
+        oss << boolalpha << value;
+        return oss.str();
+    }
+
+    vector<string> split(const string& str, const string& delimiters) {
+        vector<string> ss;
+
+        Tokenizer tokenizer(str, delimiters);
+        while (tokenizer.nextToken()) {
+            ss.push_back(tokenizer.getToken());
+        }
+
+        return ss;
+    }
+
+}
+
+namespace strutil {
+
+    const string Tokenizer::DEFAULT_DELIMITERS(" \t\n\r");
+
+    Tokenizer::Tokenizer(const std::string& str)
+        : m_String(str), m_Offset(0), m_Delimiters(DEFAULT_DELIMITERS) {}
+
+    Tokenizer::Tokenizer(const std::string& str, const std::string& delimiters)
+        : m_String(str), m_Offset(0), m_Delimiters(delimiters) {}
+
+    bool Tokenizer::nextToken() {
+        return nextToken(m_Delimiters);
+    }
+
+    bool Tokenizer::nextToken(const std::string& delimiters) {
+        // find the start charater of the next token.
+        size_t i = m_String.find_first_not_of(delimiters, m_Offset);
+        if (i == string::npos) {
+            m_Offset = m_String.length();
+            return false;
+        }
+
+        // find the end of the token.
+        size_t j = m_String.find_first_of(delimiters, i);
+        if (j == string::npos) {
+            m_Token = m_String.substr(i);
+            m_Offset = m_String.length();
+            return true;
+        }
+
+        // to intercept the token and save current position
+        m_Token = m_String.substr(i, j - i);
+        m_Offset = j;
+        return true;
+    }
+
+    const string Tokenizer::getToken() const {
+        return m_Token;
+    }
+
+    void Tokenizer::reset() {
+        m_Offset = 0;
+    }
+
+}