RBTreeDBCacheSimultaneous.hpp

Go to the documentation of this file.

#ifndef RBTreeDBCacheSimultaneous_HPP
#define RBTreeDBCacheSimultaneous_HPP

#include <vector>
#include <map>
#include "io/db_cache/RBTreeDBCache.hpp"
//#include <fstream>

namespace Bodon
{
   template< class T_R, class BIS = std::vector<item_t> >
   class RBTreeDBCacheSimultaneous : public RBTreeDBCache<T_R, BIS>
   {
      public:
         typedef typename RBTreeDBCache<T_R, BIS>::params_t params_t;

         RBTreeDBCacheSimultaneous( const params_t* par )
            : RBTreeDBCache<T_R, BIS>(par){}

         counter_t nextTransactionBIS_modifyPrevious( 
            BIS& transaction, std::vector<unsigned int>& filter);

         void rewind()
         {
            typename std::map<BIS, counter_t>::iterator it_temp = temp_rb_tree.begin();
            while(it_temp != temp_rb_tree.end())
            {
               RBTreeDBCache<T_R, BIS>::rb_tree[it_temp->first] += it_temp->second;
               temp_rb_tree.erase(it_temp++);
            }
            RBTreeDBCache<T_R, BIS>::rewind();
         }
         void setCandidateSize(const size_t candidate_size)
         {
            this->candidate_size = candidate_size;
         }
      protected:
         std::map<BIS, counter_t> temp_rb_tree;
         item_t candidate_size;
   };

   template <class T_R, class BIS> inline counter_t 
   RBTreeDBCacheSimultaneous<T_R, BIS>::
   nextTransactionBIS_modifyPrevious( BIS& transaction, 
                                      std::vector<unsigned int>& filter)
   {
      typename BIS::iterator it_tr = transaction.begin();
      while( it_tr != transaction.end())
      {
         if(filter[*it_tr] < candidate_size)
         {
            filter[*it_tr] = 0;
            it_tr = transaction.erase(it_tr);
            while(it_tr != transaction.end())
            {
               if(filter[*it_tr] < candidate_size)
               {
                  filter[*it_tr] = 0;
                  it_tr = transaction.erase(it_tr);
               }
               else
               {
                  filter[*it_tr++] = 0;
               }
            }
            --RBTreeDBCache<T_R, BIS>::it;
            if(transaction.size() > candidate_size)
               temp_rb_tree[transaction] += RBTreeDBCache<T_R, BIS>::it->second;
            RBTreeDBCache<T_R, BIS>::rb_tree.erase(RBTreeDBCache<T_R, BIS>::it++);
            return RBTreeDBCache<T_R, BIS>::nextTransactionBIS(transaction);
         }
         filter[*it_tr++] = 0;
      }
      if(transaction.size() <= candidate_size)
      {
         --RBTreeDBCache<T_R, BIS>::it;
         RBTreeDBCache<T_R, BIS>::rb_tree.erase(RBTreeDBCache<T_R, BIS>::it++);
      }
      return RBTreeDBCache<T_R, BIS>::nextTransactionBIS(transaction);
   }
}
#endif

---