Merge pull request #40 from mpetri/cst-node-child-proxy

added cst child iterator proxy class

Author: simongog

examples/cst_node_child_iterator.cpp

@@ -0,0 +1,33 @@
+#include <sdsl/suffix_trees.hpp>
+#include <iostream>
+#include <string>
+
+using namespace std;
+using namespace sdsl;
+
+typedef cst_sct3<> cst_t;
+typedef cst_sada<> csts_t;
+
+int main(int argc, char* argv[])
+{
+    if (argc < 2) {
+        cout << "usage: "<<argv[0]<< " file" << std::endl;
+        return 1;
+    }
+
+    cst_t cst;
+    construct(cst, argv[1], 1);
+
+    auto root = cst.root();
+
+    for (auto& child: cst.children(root)) {
+        std::cout << "sct3 id = " << cst.id(child) << std::endl;
+    }
+
+    csts_t csts;
+    construct(csts, argv[1], 1);
+    auto roots = csts.root();
+    for (auto child: csts.children(roots)) {
+        std::cout << "sada id = " << csts.id(child) << std::endl;
+    }
+}

include/sdsl/cst_sada.hpp

@@ -434,6 +434,17 @@ class cst_sada
             }
         }
 
+        //! Return a proxy object which allows iterating over the children of a node
+        /*! \param v A valid node of the suffix tree.
+         *  \return The proxy object of v containing all children
+         *  \par Time complexity
+         *     \f$ \Order{1}\f$
+         */
+        cst_node_child_proxy<cst_sada> children(const node_type& v) const {
+            return cst_node_child_proxy<cst_sada>(*this,v);
+        }
+
+
 //! Returns the next sibling of node v.
         /*!
          * \param v A valid node v of the suffix tree.

include/sdsl/cst_sct3.hpp

@@ -26,7 +26,7 @@
 #include "iterators.hpp"
 #include "lcp.hpp"
 #include "bp_support.hpp"
-#include "csa_wt.hpp" // for std initialization of cst_sct3 
+#include "csa_wt.hpp" // for std initialization of cst_sct3
 #include "cst_iterators.hpp"
 #include "rank_support.hpp"
 #include "select_support.hpp"
@@ -556,6 +556,16 @@ class cst_sct3
             }
         }
 
+        //! Return a proxy object which allows iterating over the children of a node
+        /*! \param v A valid node of the suffix tree.
+         *  \return The proxy object of v containing all children
+         *  \par Time complexity
+         *     \f$ \Order{1}\f$
+         */
+        cst_node_child_proxy<cst_sct3> children(const node_type& v) const {
+            return cst_node_child_proxy<cst_sct3>(*this,v);
+        }
+
         //! Returns the next sibling of node v.
         /*!
          * \param v A valid node v of the suffix tree.

include/sdsl/suffix_tree_helper.hpp

@@ -0,0 +1,64 @@
+#ifndef INCLUDED_SDSL_SUFFIX_TREE_HELPER
+#define INCLUDED_SDSL_SUFFIX_TREE_HELPER
+
+#include <stdint.h>
+#include <cstdlib>
+#include <cassert>
+#include "iterators.hpp"
+
+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 = cst_node_child_proxy_iterator<t_cst>;
+        using node_type = typename t_cst::node_type;
+        using size_type = typename t_cst::size_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
+        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

include/sdsl/suffix_trees.hpp

@@ -149,6 +149,7 @@ void cst_info(const Cst& cst)
  *    - ..
  */
 
+#include "suffix_tree_helper.hpp"
 #include "cst_sct3.hpp"
 #include "cst_sada.hpp"