BuildTreeDBCache.hpp

Go to the documentation of this file.

#ifndef BuildTreeDBCache_HPP
#define BuildTreeDBCache_HPP

#include <vector>
#include <set>
#include <map>
//#include <fstream>

#include "fpgrowth/buildfptree.hpp"

namespace bracz
{
  template <class T_R, class BIS, class BuildTree, bool ENDONLY=true, bool SORT_NEEDED=false>
  class BuildTreeDBCache : public T_R, public BuildTree
  {
  public:
    typedef typename T_R::params_t params_t;
    typedef typename BuildTree::nodeiter_t nodeiter_t;
    typedef typename BuildTree::nodeptr_t nodeptr_t;

    BuildTreeDBCache( const params_t* par ) : T_R(par), BuildTree(){
      nullTreeAnn treeann;
      T_R::rewind();
      BuildTree::initBuildTree(tree,this->getLargestItem()+1,treeann);
      BIS trans;
      while (counter_t count=T_R::nextTransactionBIS(trans)) {
        BuildTree::addTransToTree(trans,trans.size(),tree,count,treeann);
      }
      if(SORT_NEEDED)
         sortEdgeList(tree.getRoot());
    }
      
        void insert( const BIS& transaction, 
                     const counter_t multiplicity )
        {
           nullTreeAnn treeann;
           BuildTree::addTransToTree( 
              transaction, transaction.size(), 
              tree, multiplicity, treeann);
        }
        void clear()
        {}
      
    counter_t nextTransactionBIS(BIS& transaction ) {
      while ((!curriters.empty()) && (curriters.top()==enditers.top())) {
        curriters.pop();
        enditers.pop();
        currtrans.pop_back();
        if (!curriters.empty()) {
          ++(curriters.top());
        }
      }
      if (curriters.empty()) {
        return 0;
      }
      while (true) {
        std::pair<item_t,nodeptr_t> p=*(curriters.top());
        currtrans.push_back(p.first);
        curriters.push((*p.second).childrenBegin());
        enditers.push((*p.second).childrenEnd());
        counter_t r=(*p.second).getCounter();
        if(!ENDONLY)
        {
           for( nodeiter_t child_iter = (*p.second).childrenBegin(); 
                child_iter != (*p.second).childrenEnd(); ++child_iter )
              r -= (*child_iter).second->getCounter();
        }
        if (r) {
          transaction=currtrans;
          return r;
        }
      }
    }
        nodeptr_t getRoot()
        {
           return tree.getRoot();
        }

    template <class UAC> counter_t nextTransactionUAC(UAC& transaction ) { exit(1);}

    void rewind()
    {
      currtrans.clear();
      while (!curriters.empty())
        curriters.pop();
      while (!enditers.empty())
        enditers.pop(); 
      nodeptr_t r=tree.getRoot();
      curriters.push((*r).childrenBegin());
      enditers.push((*r).childrenEnd());
   }
  protected:
    typename BuildTree::buildtree_t tree;
    std::stack<nodeiter_t> curriters,enditers;
    BIS currtrans;

        void sortEdgeList(nodeptr_t subtrie)
        {
           typename BuildTree::childmap_t* children = subtrie->getChildren();
           if(children)
           {
               children->sort< std::less<typename BuildTree::childmap_t::value_type> >();
               for(  nodeiter_t patr_iter = subtrie->childrenBegin(); 
                     patr_iter !=  subtrie->childrenEnd(); ++patr_iter)
                  sortEdgeList((*patr_iter).second);
           }
        }
  };

}
#endif

---