trie/trie_manipulators/sequence/FrequentPairInserterNoprune.hpp

Go to the documentation of this file.

#ifndef FrequentPairInserterNoprune_HPP
#define FrequentPairInserterNoprune_HPP

#include "common.hpp"
#include "common/Edge.hpp"
#include "apriori/bodon/inhomogeneous_trie/trie_manipulators/ManipulatorBase.hpp"
#include <vector>
//#include <cstdio>
//#include <iterator>   //for test

namespace Bodon
{
namespace sequence
{
template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
class FrequentPairInserterNoprune : public 
inhomogeneous_trie::ManipulatorBase<DF_D, TRIE, LEAF_ALLOCATOR>
{
   private:
      typedef inhomogeneous_trie::ManipulatorBase<DF_D, TRIE, LEAF_ALLOCATOR> PARENT;
   protected:
      std::vector<Edge> extenders;

   public:
      FrequentPairInserterNoprune( TRIE& trie, DF_D& df_decoder,
                                   LEAF_ALLOCATOR& s_alloc) : 
         inhomogeneous_trie::ManipulatorBase<DF_D, TRIE, LEAF_ALLOCATOR>(
            trie, df_decoder, s_alloc){}


      void insertFrequentPairs(
         const std::vector< std::pair< counter_t, 
         std::pair<item_t, item_t> > >& freq_pairs_with_counters );

};

   
template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR> void 
FrequentPairInserterNoprune<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>::insertFrequentPairs(
   const std::vector< std::pair< counter_t, std::pair<item_t, item_t> > >& 
   freq_pairs_with_counters )
{
   if( freq_pairs_with_counters.empty() )
      PARENT::main_trie.edgelist.clear();
   else
   {
      std::vector< std::pair< counter_t, std::pair<item_t, item_t> > >::
         const_iterator it = freq_pairs_with_counters.begin();
      typename TRIE::iterator mt_iter = PARENT::main_trie.edgelist.begin(); 
      while( mt_iter != PARENT::main_trie.edgelist.end())
      {
         while (it != freq_pairs_with_counters.end() && 
                (*it).second.first < (*mt_iter).first)
            ++it;
         extenders.clear();
         while( it != freq_pairs_with_counters.end() &&  
                (*it).second.first == (*mt_iter).first)
         {
            extenders.push_back(Edge((*it).second.second, PARENT::s_alloc.allocate()));
            static_cast<LEAF*>(extenders.back().second)->setCounter((*it).first);
            ++it;
         }
         if(extenders.size() > 0)
         {
            static_cast<TRIE*>((*mt_iter).second)->edgelist.insert(extenders);
            ++mt_iter;
         }
         else
         {
            delete static_cast<TRIE*>((*mt_iter).second);
            mt_iter = PARENT::main_trie.edgelist.erase(mt_iter);
         }
      }
      while( mt_iter != PARENT::main_trie.edgelist.end() )
      {
         delete static_cast<TRIE*>((*mt_iter).second);
         mt_iter = PARENT::main_trie.edgelist.erase(mt_iter);
      }
   }
}

}
}

#endif

---