RBTreeDBCache.hpp

Go to the documentation of this file.

#ifndef RBTreeDBCache_HPP
#define RBTreeDBCache_HPP

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

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

         RBTreeDBCache( const params_t* par );

        void insert( const BIS& transaction, 
                     const counter_t multiplicity )
        {
           rb_tree[transaction] += multiplicity;
        }
         counter_t nextTransactionBIS( 
            BIS& transaction );

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

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

   template <class T_R, class BIS> inline RBTreeDBCache<T_R, BIS>::
   RBTreeDBCache(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) 
            rb_tree[transaction] += multiplicity;
      it = rb_tree.begin();
   }

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

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

---