OrderedVectorDBCache.hpp

Go to the documentation of this file.

#ifndef OrderedVectorDBCache_HPP
#define OrderedVectorDBCache_HPP

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


template <class BIS>
bool less_itemset(std::pair<BIS, counter_t> x, BIS y) 
{ 
   return x.first < y; 
}


template <class T_R, class BIS>
class OrderedVectorDBCache : public T_R
{
   public:
      typedef typename T_R::params_t params_t;

      OrderedVectorDBCache( const params_t* par );

      counter_t nextTransactionBIS( 
         BIS& transaction );

      template <class UAC> counter_t nextTransactionUAC( 
         UAC& transaction );

      void rewind()
      {
         it = ordered_vector.begin();
      }
   protected:
      std::vector< std::pair<BIS, counter_t> > ordered_vector;
      typename std::vector<std::pair<BIS, counter_t> >::iterator it;
};

template <class T_R, class BIS> inline OrderedVectorDBCache<T_R, BIS>::
OrderedVectorDBCache(const params_t* par) : T_R(par)
{
   BIS transaction;
   register counter_t multiplicity;
   T_R::rewind();
   while( (multiplicity = T_R::nextTransactionBIS(
              transaction)) != 0 )
      if(transaction.size() > 1) 
      {
         it = std::lower_bound( ordered_vector.begin(), ordered_vector.end(), 
                                transaction, less_itemset<BIS> );
         if(it != ordered_vector.end() && (*it).first == transaction)
            (*it).second += multiplicity;
         else
            ordered_vector.insert( 
               it, std::pair<BIS, counter_t>(transaction, multiplicity) );
      }
   it = ordered_vector.begin();
}

template <class T_R, class BIS> inline counter_t 
OrderedVectorDBCache<T_R, BIS>::nextTransactionBIS( BIS& transaction )
{
   if( it == ordered_vector.end() )
      return 0;
   else
   {
      transaction = (*it).first;
      return (*(it++)).second;
   }
}

template <class T_R, class BIS> template <class UAC> inline counter_t 
OrderedVectorDBCache<T_R, BIS>::nextTransactionUAC( UAC& transaction )
{
   if( it == ordered_vector.end() )
      return 0;
   else
   {
      transaction.clear();
      transaction.insert((*it).first.begin(), (*it).first.end());
      return (*(it++)).second;
   }
}

#endif

---