Trie.hpp

Go to the documentation of this file.

#ifndef Trie_HPP
#define Trie_HPP

enum MatchFind
{
   MERGE,
   LOOKUP,
   HYBRID
};


#include "common.hpp"
#include "common/Edge.hpp"
#include "apriori/bodon/InnerNodeSpecific.hpp"
#include <vector>
//#include <iterator>   //for test


namespace Bodon
{
   template <class LEAF, class EDGELIST>
   class Trie : public LEAF, public InnerNodeSpecific<EDGELIST>
   {
      public:
         static std::vector<item_t> neelist;
         Trie(){}
         Trie(const counter_t counter) : LEAF(counter), 
                                         InnerNodeSpecific<EDGELIST>() {}


         bool neeFind(item_t item) const{return true;} //this should never be called

         void neePushBackSorted(const std::vector<item_t>& new_neelist){} //this should never be called
         void neeAddSorted(const std::vector<item_t>& new_neelist){} //this should never be called
         void neeInsertItem(const item_t new_item){} //this should never be called
         template <class CONTAINER> const Trie* isIncluded( 
            const CONTAINER& an_itemset, typename CONTAINER::const_iterator item_it ) const;
   };
   template <class LEAF, class EDGELIST> std::vector<item_t> Trie<LEAF, EDGELIST>::neelist;
   
   template <class LEAF, class EDGELIST> template <class CONTAINER> const 
   Trie<LEAF, EDGELIST>* Trie<LEAF, EDGELIST>::
   isIncluded( const CONTAINER& an_itemset, 
      typename CONTAINER::const_iterator item_it ) const
   {
      if( item_it == an_itemset.end() ) 
         return this;
      else
      {
         Trie<LEAF, EDGELIST>* subtrie = static_cast<Trie<LEAF, EDGELIST>*>(
            InnerNodeSpecific<EDGELIST>::edgelist.find(*item_it));
         if(subtrie)
            return subtrie->isIncluded( an_itemset, ++item_it );
         else 
            return NULL;
      }
   }
}

#endif

---