SimpleDFDecoder.hpp

Go to the documentation of this file.

#ifndef SimpleDFDecoder_HPP
#define SimpleDFDecoder_HPP

#include "io/codec/decoder/SimpleDecoderBase.hpp"  
#include "io/output/normal/BufferedNormalOutput.hpp" 

template <class O = BufferedNormalOutput<> >
class SimpleDFDecoder : public SimpleDecoderBase<O>
{
   public:

      typedef typename SimpleDecoderBase<O>::params_t params_t;
      SimpleDFDecoder(const params_t* par)
         : SimpleDecoderBase<O>(par){}

      static bool DINLINE isDFO()
      {
         return true;
      }  

      void pushItem(item_t item)
      {
         decoded_set.push_back(this->code_inverse[item]);
      }

      void write(const counter_t support)
      {
         O::writeItemsetAndCounter( 
            decoded_set.begin(), decoded_set.end(), support );
         last_support = support;
      }
      void writeNEE( const counter_t support, 
                     const std::vector<item_t>& nee_items);

      void pushItemWithWrite(item_t item, counter_t support)
      {
         pushItem(item);
         write(support);            
      }
         
      void pushItemWithPrevSupport(item_t item)
      {
         pushItemWithWrite(item, last_support);
      }
         
      void popItem()
      {
         decoded_set.pop_back();
      }

   private:
      std::vector<item_t> decoded_set; 
      counter_t last_support;

};

template <class O> inline void 
SimpleDFDecoder<O>::writeNEE( const counter_t support, 
                              const std::vector<item_t>& nee_items)
{
   std::vector<bool>::size_type size =  nee_items.size();
   std::vector<bool> pattern( size , false);
   std::vector<bool>::size_type index;

   do
   {
      write(support);
      index=0;
      while(index < size && pattern[index] == true )
      {
         pattern[index] = false;
         popItem();
         index++;
      }
      if( index == size )
         break;
      else
      {
         pattern[index] = true;
         pushItem(nee_items[index]);
      }
   }
   while(true);
}

#endif

---