iterator pattern

Author: xiao cheng

IteratorPattern/CMakeLists.txt

@@ -8,6 +8,12 @@ add_executable(Iter_example1 example1.cpp)
 
 target_link_libraries(Iter_example1 PUBLIC gtest_main ${Boost_LIBRARIES})
 
-install(TARGETS Iter_example1 RUNTIME DESTINATION ../bin)
+add_executable(Iter_test iter_test.cpp)
+target_link_libraries(Iter_test PUBLIC gtest_main ${Boost_LIBRARIES})
 
+add_executable(Iter_example2 example2.cpp)
+target_link_libraries(Iter_example2 PUBLIC gtest_main ${Boost_LIBRARIES})
 
+install(TARGETS Iter_example1 RUNTIME DESTINATION ../bin)
+install(TARGETS Iter_test RUNTIME DESTINATION ../bin)
+install(TARGETS Iter_example2 RUNTIME DESTINATION ../bin)

IteratorPattern/example2.cpp

@@ -0,0 +1,128 @@
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <string>
+using namespace std;
+
+class Container
+{
+
+  public:
+    Container(istream &s) : m_stream(s), m_nIndex(0)
+    {
+        FillData();
+    }
+
+    class iterator
+    {
+        const Container &sln;
+        size_t m_Index;
+
+      public:
+        iterator(const Container &s) : sln(s), m_Index(0)
+        {
+        }
+        iterator(const Container &s, size_t nSize) : sln(s), m_Index(nSize)
+        {
+        }
+        iterator(const iterator &other) : sln(other.sln), m_Index(other.m_Index)
+        {
+        }
+        void operator++()
+        {
+            m_Index++;
+        }
+
+        void operator--()
+        {
+            m_Index++;
+        }
+
+        bool operator!=(const iterator &other)
+        {
+            return m_Index != other.m_Index;
+        }
+
+        int operator*()
+        {
+            return sln.m_Elements[m_Index];
+        }
+    };
+
+    iterator begin()
+    {
+        iterator it(*this);
+        return it;
+    }
+
+    iterator end()
+    {
+        iterator it(*this, m_Elements.size());
+        return it;
+    }
+
+  private:
+    void FillData()
+    {
+        std::ifstream &in_stream = dynamic_cast<ifstream &>(m_stream);
+        string line;
+        vector<string> list;
+        while (std::getline(in_stream, line))
+        {
+            //in_stream >> line;
+            list.push_back(line);
+            TrimLeadingSpace(line);
+            bool bValid = IsValidInteger(line);
+            if (bValid)
+                m_Elements.push_back(atoi(line.c_str()));
+        }
+        in_stream.close();
+    }
+
+    void TrimLeadingSpace(string &sNum)
+    {
+        const char *ws = " \t\n\r\f\v";
+        sNum.erase(0, sNum.find_first_not_of(ws));
+    }
+
+    bool IsValidInteger(const string &sNum)
+    {
+        const int MAX_LIMIT = 1000000000;
+        const int MIN_LIMIT = -1000000000;
+        bool bflag = false;
+        auto startIt = sNum.begin();
+        if (sNum[0] == '+' || (sNum[0] == '-'))
+            startIt = sNum.begin() + 1;
+
+        for (auto it = startIt; it != sNum.end(); ++it)
+        {
+            bflag = true;
+            char nChar = *it;
+            if (!isdigit(nChar))
+                return false;
+        }
+
+        int nNum = atoi(sNum.c_str());
+        bool bMaxCheck = nNum < MAX_LIMIT && nNum > MIN_LIMIT; //limit check
+
+        return (bMaxCheck && bflag);
+    }
+
+    istream &m_stream;
+    int m_nIndex;
+    vector<int> m_Elements;
+};
+
+int main()
+{
+    std::ifstream file("Test.txt");
+    Container sobj(file);
+
+    for (Container::iterator it = sobj.begin(); it != sobj.end(); ++it)
+    {
+        int x = *it;
+        cout << x << endl;
+    }
+
+    return 0;
+}

IteratorPattern/iter_test.cpp

@@ -0,0 +1,73 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+template <typename T>
+struct Node
+{
+    T value;
+    Node *left{nullptr}, *right{nullptr}, *parent{nullptr};
+
+    Node(T value) : value(value) {}
+
+    Node(T value, Node<T> *left, Node<T> *right) : value(value), left(left), right(right) {
+      left->parent = right->parent = this;
+    }
+
+    void preorder_traversal_impl(Node<T>* current, vector<Node<T>*>& result)
+    {
+      result.push_back(current);
+      if (current->left)
+      {
+        preorder_traversal_impl(current->left, result);
+      }
+      if (current->right)
+      {
+        preorder_traversal_impl(current->right, result);
+      }
+    }
+
+    // traverse the node and its children preorder
+    // and put all the results into `result`
+
+    // this interface does not expose it is a tree
+    void preorder_traversal(vector<Node<T>*>& result)
+    {
+      preorder_traversal_impl(this, result);
+    }
+};
+
+#include "gtest/gtest.h"
+
+//#include "helpers/iohelper.h"
+
+//#include "exercise.cpp"
+
+namespace {
+
+    class Evaluate : public ::testing::Test {};
+
+    TEST_F(Evaluate, ExampleTest) {
+      Node<char> c{'c'};
+      Node<char> d{'d'};
+      Node<char> e{'e'};
+      Node<char> b{'b', &c, &d};
+      Node<char> a{'a', &b, &e};
+
+      vector<Node<char>*> result;
+      a.preorder_traversal(result);
+
+      ostringstream oss;
+      for (auto n : result)
+        oss << n->value;
+      ASSERT_EQ("abcde", oss.str());
+    }
+
+}  // namespace
+
+int main(int ac, char* av[])
+{
+  //::testing::GTEST_FLAG(catch_exceptions) = false;
+  testing::InitGoogleTest(&ac, av);
+  return RUN_ALL_TESTS();
+}