Coder.hpp

Go to the documentation of this file.

#ifndef Coder_HPP
#define Coder_HPP

#include "common.hpp"
#include <vector>
#include <set>
#include "io/input/transaction_reader/brBufferedTransactionReader.hpp"
#include "io/codec/decoder/df/CacheDFDecoder.hpp"

enum CodeMode
{
   ASC,
   DESC,
   NOCARE
};

template <class T_R, class D>
class Coder : public T_R
{
   public:
      class params_t : public T_R::params_t
      {
         public:
            D* decoder;
            std::vector< std::pair<counter_t, item_t> >* 
            freq_items_with_counters;
            std::vector<counter_t>* freq_counters;
            CodeMode codemode;
            params_t()
            {
               decoder = NULL;
               freq_items_with_counters = NULL;
               freq_counters = new std::vector<counter_t>();
               codemode = NOCARE;
            }
            ~params_t()
            {
               delete freq_counters;
            }
      };

      Coder(const params_t* par);
      template <class BIS> counter_t nextTransactionBIS( BIS& transaction );
      template <class UAC> counter_t nextTransactionUAC( UAC& transaction );

   protected:
      std::vector<item_t> code;
};

template <class T_R, class D> Coder<T_R, D>::
Coder(const params_t* par) : T_R(par)
{
   code.reserve( T_R::getLargestItem() + 1 );
   code.resize( T_R::getLargestItem() + 1, 0 );
   if( par->codemode != NOCARE )
   {
      sort( par->freq_items_with_counters->begin(),
            par->freq_items_with_counters->end() );
      if( par->codemode == DESC)
         reverse( par->freq_items_with_counters->begin(),
                  par->freq_items_with_counters->end() );
   }
   par->freq_counters->reserve( par->freq_items_with_counters->size() );
   std::vector<item_t> code_inverse;
   code_inverse.reserve(par->freq_items_with_counters->size());
   std::vector< std::pair<counter_t, item_t> >::size_type index;
   for( index = 0; index < par->freq_items_with_counters->size(); ++index )
   {
      code_inverse.push_back( (*par->freq_items_with_counters)
                              [index].second );
      par->freq_counters->push_back( 
         (*par->freq_items_with_counters)[index].first );
      code[(*par->freq_items_with_counters)[index].second] = index+1;
   }
   par->decoder->setCodeInverse(code_inverse);
   T_R::largest_item = par->freq_items_with_counters->size() - 1;
}

template <class T_R, class D> template <class BIS> inline counter_t 
Coder<T_R, D>::nextTransactionBIS( BIS& transaction )
{
   counter_t return_value = T_R::nextTransactionBIS(transaction);
   TYPENAME BIS::iterator it1,it2;
   it1 = it2 = transaction.begin();
   while( it1 != transaction.end() )
   {
      register item_t new_code = code[*it1];
      if(new_code) 
      {
         *it2 = new_code - 1;
         ++it2;
      }
      ++it1;
   }
   transaction.erase(it2, transaction.end());
   return return_value;
}

template <class T_R, class D> template <class UAC> inline counter_t 
Coder<T_R, D>::nextTransactionUAC( UAC& transaction )
{
   std::set<item_t> raw_transaction;
   counter_t return_value = T_R::nextTransactionUAC(raw_transaction);
   if(return_value)
   {
      
      transaction.clear();
      for( std::set<item_t>::iterator it = raw_transaction.begin(); 
           it != raw_transaction.end(); ++it )
         if( code[*it] ) transaction.insert( code[*it]-1 );
   }
   return return_value;
}

#endif

---