CacheDFDecoder.hpp

Go to the documentation of this file.

#ifndef CacheDFDecoder_HPP
#define CacheDFDecoder_HPP

#include "io/codec/decoder/CacheDecoderBase.hpp"  
#include "util/Formatter.hpp"  
#include "io/FDRepr.hpp"  
#include "common/debug.hpp"

#include <stack>
#include <string>

template <class FR = FDRepr>
class CacheDFDecoder : public CacheDecoderBase<FR>
{
   public:

      class params_t : public CacheDecoderBase<FR>::params_t
      {
         public:
            std::streamsize support_buffer_size;
            params_t()
            {
               support_buffer_size = 64;
            }
      };

      CacheDFDecoder(const params_t* par) :
         CacheDecoderBase<FR>(par), 
         support_buffer_size(par->support_buffer_size)
      {
         support_buffer = new char[support_buffer_size];
         positions.push(0);
      }
      ~CacheDFDecoder()
      {
         delete[] support_buffer;
      }

      static bool DINLINE isDFO()
      {
         return true;
      }  

      void pushItem(const item_t item);

      void write(counter_t support);

      void writeNEE( counter_t support, 
                     const std::vector<item_t>& nee_items);

      void pushItemWithWrite(const item_t item, counter_t support)
      {   
         pushItem(item);
         write(support);
      }
      void pushItemWithPrevSupport(const item_t item);
      void popItem()
      {
         assert(!positions.empty());
         positions.pop();
      }
      void popAll()
      {
         while( !positions.empty() )
            positions.pop();
         positions.push(0);
      }
      // FIXME: is this a memory leak ? Answer: NO
      std::string getCurrentPatternAsString() 
      {
         return std::string(this->buffer, positions.top());
      }

      void hint(std::string hint) 
      {
         writeToFile(hint.data(), hint.length());
      }
         
   private:
      std::stack<std::streamsize> positions;

      char* support_buffer;

      std::streamsize support_buffer_size;
         
      size_t support_length;
};

template <class FR> inline void 
CacheDFDecoder<FR>::pushItem(const item_t item)
{
   register std::streamsize length = this->code_inverse[item].second,
      pos = positions.top();
   memcpy( &(this->buffer)[pos], this->code_inverse[item].first, 
           length );
   pos += length;
   this->buffer[pos++] = ' ';
   positions.push(pos);
}
   
template <class FR> inline void 
CacheDFDecoder<FR>::write(counter_t support)
{
   register std::streamsize pos = positions.top();
   this->buffer[pos++] = '(';
   register std::streamsize supp_pos(support_buffer_size);
   Formatter::IntToStringBack(support, support_buffer, supp_pos);
   support_length = support_buffer_size - supp_pos;
   memcpy( &(this->buffer)[pos], &support_buffer[supp_pos], 
           support_length );
   pos += support_length;
   this->buffer[pos++] = ')';
   this->buffer[pos++] = '\n';
   writeToFile( this->buffer, pos );
}

template <class FR> inline void 
CacheDFDecoder<FR>::writeNEE( 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);
}

template <class FR>inline void 
CacheDFDecoder<FR>::
pushItemWithPrevSupport(item_t item)
{
   pushItem(item);
   register std::streamsize pos = positions.top();
   this->buffer[pos++] = '(';
   memcpy( &(this->buffer)[pos], 
           &support_buffer[support_buffer_size - support_length], 
           support_length );
   pos += support_length;
   this->buffer[pos++] = ')';
   this->buffer[pos++] = '\n';
   writeToFile( this->buffer, pos );

}
#endif

---