DFDecoderWithEEManagement.hpp

Go to the documentation of this file.

#ifndef DFDecoderWithEEManagement_HPP
#define DFDecoderWithEEManagement_HPP

#include "CacheDFDecoder.hpp"

#include "common/debug.hpp"
#include <vector>
#include <iostream>
#include <iterator>
#include "io/output/OutputBase.hpp"

template <class DF = CacheDFDecoder< > >
class DFDecoderWithEEManagement : public DF
{
public:
  
      typedef typename DF::params_t params_t;
  
  DFDecoderWithEEManagement(const params_t* par) :
    DF(par)
  {
    ee_buffer_segment_length.push_back(0);
  }

      size_t nrOfEEItems() const
      {
         return ee_buffer.size();
      }
      bool EEListEmpty() const
      {
         return ee_buffer.empty();
      }
  void pushItem(item_t item)
  {
#if DEBUG_LEVEL >= LEVEL_DBG
  std::cout << "pushItem " << item << std::endl; 
#endif
    DF::pushItem(item);
    ee_buffer_segment_length.push_back(0);
  }

  void popItem()
  {
#if DEBUG_LEVEL >= LEVEL_DBG
    //assert(ee_buffer_segment_length.size()>0);
    std::cout << "popItem " << ee_buffer_segment_length.size() << " and ";
#endif
    // popEquisupportItems(ee_buffer_segment_length.back());
    popEquisupportItems(ee_buffer_segment_length.back());
    DF::popItem();
    ee_buffer_segment_length.pop_back();
  }

  void pushEquisupportItem(item_t item);

  void pushEquisupportItemSet(const std::vector<item_t>& itemset);


  void write(counter_t support) {
    // as is -- w./o. any ee-extension (= empty ee set):
    DF::write(support);
    write1();
  }


  void pushItemWithPrevSupport(item_t item) {
    // as is -- w./o. any ee-extension (= empty ee set):
    DF::pushItemWithPrevSupport(item);
    ee_buffer_segment_length.push_back(0);
    write1();
  }

  void pushItemWithWrite(item_t item, counter_t support)
  {   
    pushItem(item);
    write(support);
  }

  class EquisupportItemOutputIterator {
  public:
    EquisupportItemOutputIterator(DFDecoderWithEEManagement& decoder) : decoder(decoder) {}
    EquisupportItemOutputIterator& operator= (const item_t item) { decoder.pushEquisupportItem(item); return *this; }
    EquisupportItemOutputIterator& operator* () { return *this; }
    EquisupportItemOutputIterator& operator++ () { return *this; }
    EquisupportItemOutputIterator& operator++ (int) { return *this; }
  private:
    DFDecoderWithEEManagement& decoder;
  };
  
private:
  std::vector<item_t> ee_buffer;
  
  std::vector<size_t> ee_buffer_segment_length;


  void write1();

  void popEquisupportItem();

  void popEquisupportItems(int numEEItems);

};


template <class DF> inline void DFDecoderWithEEManagement<DF>::
pushEquisupportItem(item_t item)
{
#if DEBUG_LEVEL >= LEVEL_DBG
  std::cout << "pushEE " << item << std::endl; 
#endif
  ee_buffer_segment_length.back()++;
  ee_buffer.push_back(item);
}

template <class DF> inline void DFDecoderWithEEManagement<DF>::
pushEquisupportItemSet(const std::vector<item_t>& itemset)
{
#if DEBUG_LEVEL >= LEVEL_DBG
   std::cout<< "pushEEItemset "<<std::endl; 
   std::copy( itemset.begin(), itemset.end(), 
              std::ostream_iterator<item_t>(std::cout, " "));
   std::cout<<std::endl; 
#endif
  ee_buffer_segment_length.back()+=itemset.size();
  ee_buffer.insert(ee_buffer.end(), itemset.begin(), itemset.end() );
}

template <class DF> inline void DFDecoderWithEEManagement<DF>::
popEquisupportItem()
{
  assert(!ee_buffer.empty());
#if DEBUG_LEVEL >= LEVEL_DBG
  std::cout << "popEE " << ee_buffer.back() << std::endl; 
#endif
  ee_buffer.pop_back();
  ee_buffer_segment_length.back()--;
}

template <class DF> inline void DFDecoderWithEEManagement<DF>::
popEquisupportItems(int numEEItems)
{
  assert(int(ee_buffer.size()) >= numEEItems);
#if DEBUG_LEVEL >= LEVEL_DBG
  std::cout << "popEEs ";
  if (numEEItems ==  0)
    std::cout << "[empty]";
  for(int i = 0; i < numEEItems; i++) 
    std::cout << ee_buffer[ee_buffer.size()-1-i] << " ";
  std::cout << " [" << numEEItems << "]" << std::endl; 
#endif
  ee_buffer.resize(ee_buffer.size() - numEEItems);
  ee_buffer_segment_length.back() -= numEEItems;
}



template <class DF> inline void DFDecoderWithEEManagement<DF>::
write1()
{
  std::vector<item_t>::size_type ee_buffer_length = ee_buffer.size();

  if (ee_buffer_length == 0)
    return;

  std::vector<bool> isMember(ee_buffer_length, false);



  // set only containing (numItems-1)
  isMember[ee_buffer_length-1] = true;
  DF::pushItemWithPrevSupport(ee_buffer[ee_buffer_length-1]);
  DF::popItem();

  int pos = ee_buffer_length-2;

  while (pos >= 0) {
    // a. subset containing ee_buffer[pos] but items with larger ee-index:
    isMember[pos] = true;
    DF::pushItemWithPrevSupport(ee_buffer[pos]);
    
    // b. add item (numItems-1):
    DF::pushItemWithPrevSupport(ee_buffer[ee_buffer_length-1]);

    // c. search next non-member (and remove all items on our way):
    pos = ee_buffer_length-2;
    while (pos >= 0 && isMember[pos]) {
      isMember[pos] = false;
      pos--;
    }
    // popEquisupportItems(ee_buffer_length-1 - pos);
    for (int i = ee_buffer_length-1 - pos;  i > 0; i--)
      DF::popItem();
  }
}

#endif

---