SupportCounterLookupEdgeCommute.hpp

Go to the documentation of this file.

#ifndef SupportCounterLookupEdgeCommute_HPP
#define SupportCounterLookupEdgeCommute_HPP

#include "common.hpp"
#include <vector>
#include "apriori/bodon/Leaf.hpp"
//#include <cstdio>
//#include <iterator>   //for test




namespace Bodon
{
namespace sequence
{
   template <class TRIE>
   class SupportCounterLookupEdgeCommute
   {
      public:
         SupportCounterLookupEdgeCommute( ){}

         void findCandidates( TRIE* subtrie,
            std::vector<item_t>::const_iterator it_transaction_upper_bound,
            std::vector<item_t>::const_iterator it_transaction, 
            item_t step_to_candidate,
            const counter_t counter_incr );
   };

   template <class TRIE> void 
   SupportCounterLookupEdgeCommute<TRIE>::findCandidates( 
      TRIE* subtrie, std::vector<item_t>::const_iterator 
      it_transaction_upper_bound,
      std::vector<item_t>::const_iterator it_transaction, 
      item_t step_to_candidate, const counter_t counter_incr )
   {
      --step_to_candidate;
      std::vector<bool>::size_type largestEdgelabel_p1 = 
         subtrie->edgelist.largestEdgelabel()+1;
      std::vector<bool>::size_type smallestEdgelabel = 
         subtrie->edgelist.smallestEdgelabel();
      std::vector<bool> pattern(largestEdgelabel_p1 - smallestEdgelabel, true);
      typename TRIE::iterator it_edge(subtrie->edgelist.begin());
      for(; it_transaction != it_transaction_upper_bound; ++it_transaction)
         if(*it_transaction < largestEdgelabel_p1 && 
            *it_transaction >= smallestEdgelabel &&
            pattern[*it_transaction - smallestEdgelabel])
         {
            if((*it_edge).first < *it_transaction)
               subtrie->edgelist.findForwardNoBoundaryCheck(*it_transaction, it_edge);
            else
               subtrie->edgelist.findBackwardNoBoundaryCheck(*it_transaction, it_edge);
            
            if((*it_edge).first == *it_transaction)
               if( step_to_candidate ) 
                  findCandidates( static_cast<TRIE*>((*it_edge).second),
                                  it_transaction_upper_bound + 1, it_transaction+1, 
                                  step_to_candidate, counter_incr);       
               else
                  static_cast<Leaf*>((*it_edge).second)->increaseCounter( counter_incr);
            pattern[*it_transaction - smallestEdgelabel] = false;
         }
   }
}
}
#endif

---