OrderedArrayDBCache.hpp

Go to the documentation of this file.

#ifndef OrderedArrayDBCache_HPP
#define OrderedArrayDBCache_HPP

#include <vector>
#include <set>
#include <map>
#include <functional>
#include "io/db_cache/OrderedVectorDBCache.hpp" // to avoid retyping "less_itemset" predicate
//#include <fstream>


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

      OrderedArrayDBCache( const params_t* par );

      counter_t nextTransactionBIS( 
         BIS& transaction );

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

      void rewind()
      {
         it_v = ordered_array.begin();
         while(it_v != ordered_array.end() && (*it_v).empty() )
            ++it_v;
         it = (*it_v).begin();
      }
   protected:
      std::vector<std::vector< std::pair<BIS, counter_t> > > ordered_array;
      typename std::vector<std::pair<BIS, counter_t> >::iterator it;
      typename std::vector<std::vector< std::pair<BIS, counter_t> > >
         ::iterator it_v;


};

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

template <class T_R, class BIS> inline counter_t OrderedArrayDBCache<T_R, BIS>::
nextTransactionBIS( BIS& transaction )
{
   if( it == (*it_v).end() )
   {
      do
      {
         ++it_v;
         if(it_v == ordered_array.end())
            return 0;       
      }
      while( (*it_v).empty() );
      it = (*it_v).begin();
   }
   transaction = (*it).first;
   return (*(it++)).second;

}

template <class T_R, class BIS> template <class UAC> inline counter_t 
OrderedArrayDBCache<T_R, BIS>::nextTransactionUAC( UAC& transaction )
{
   if( it == (*it_v).end() )
   {
      do
      {
         ++it_v;
         if(it_v == ordered_array.end())
            return 0;       
      }
      while( (*it_v).empty() );
      it = (*it_v).begin();
   }
   transaction.clear();
   transaction.insert((*it).first.begin(), (*it).first.end());
   return (*(it++)).second;
}

#endif

---