rewrote the proxy class to use the sibling function and a custom iterator

Author: mpetri

include/sdsl/suffix_tree_helper.hpp

@@ -10,28 +10,55 @@ namespace sdsl
 {
 
 
+template <class t_cst>
+class cst_node_child_proxy_iterator
+{
+    public:
+        using node_type = typename t_cst::node_type;
+        using const_reference = const node_type;
+        using iterator_type =  cst_node_child_proxy_iterator<t_cst>;
+    private:
+        const t_cst& m_cst;
+        node_type current_node;
+    public:
+        cst_node_child_proxy_iterator() = delete;
+        cst_node_child_proxy_iterator(const t_cst& cst,const node_type& v) : m_cst(cst) , current_node(v) {}
+    public:
+        const_reference operator*() const {
+            return current_node;
+        }
+        iterator_type& operator++() {
+            current_node = m_cst.sibling(current_node);
+            return *this;
+        }
+        bool operator==(const iterator_type& it)const {
+            return it.current_node == current_node;
+        }
+        bool operator!=(const iterator_type& it)const {
+            return !(*this==it);
+        }
+};
+
 template <class t_cst>
 class cst_node_child_proxy
 {
     public: // types
-        using iterator_type = random_access_const_iterator<cst_node_child_proxy>;
+        using iterator_type = cst_node_child_proxy_iterator<t_cst>;
         using node_type = typename t_cst::node_type;
         using size_type = typename t_cst::size_type;
-        using difference_type = size_type;
-        using value_type = node_type;
     private: // data
         const node_type& m_parent;
         const t_cst& m_cst;
     public: // constructors
         cst_node_child_proxy() = delete;
         explicit cst_node_child_proxy(const t_cst& cst,const node_type& v) : m_parent(v) , m_cst(cst) {};
     public: // methods
-        value_type operator[](size_type i) const { return m_cst.select_child(m_parent,i+1); } // enumeration starts with 1 not 0
-        iterator_type begin() const { return iterator_type(this); }
-        iterator_type end() const { return iterator_type(this,m_cst.degree(m_parent)); }
+        node_type operator[](size_type i) const { return m_cst.select_child(m_parent,i+1); } // enumeration starts with 1 not 0
+        size_type size() { return m_cst.degree(m_parent); }
+        iterator_type begin() const { return iterator_type(m_cst,m_cst.select_child(m_parent,1)); }
+        iterator_type end() const { return iterator_type(m_cst,m_cst.root()); }
 };
 
-
 }
 
 #endif