CheckpointSettings.h

Go to the documentation of this file.

#ifndef _MADARA_KNOWLEDGE_CHECKPOINTSETTINGS_H_
#define _MADARA_KNOWLEDGE_CHECKPOINTSETTINGS_H_

#include <string>
#include <map>
#include <memory>

#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/utility/Utility.h"
#include "madara/filters/BufferFilter.h"
#include <stdio.h>

namespace madara
{

  namespace knowledge
  {

    class ThreadSafeContext;

    class CheckpointSettings
    {
      public:

      friend ThreadSafeContext;

      CheckpointSettings ()
        : buffer_size (1024000),
          clear_knowledge (false),
          filename (""),
          initial_timestamp (0), last_timestamp (0),
          initial_lamport_clock (0), last_lamport_clock (0), states (0),
          version (utility::get_version ()),
          override_timestamp (false), override_lamport (false),
          keep_open (false),
          initial_state (0),
          last_state (-1),
          reset_checkpoint (true)

      {
      }

       
      CheckpointSettings (size_t t_buffer_size,
        bool t_clear_knowledge,
        std::string t_filename = "",
        uint64_t t_initial_timestamp = 0,
        uint64_t t_last_timestamp = 0,
        uint64_t t_initial_lamport_clock = 0,
        uint64_t t_last_lamport_clock = 0,
        std::string t_originator = "",
        const std::vector <std::string> & t_prefixes = {},
        uint64_t t_states = 0,
        std::string t_version = "",
        bool t_override_timestamp = false,
        bool t_override_lamport = false,
        bool t_keep_open = false,
        uint64_t t_initial_state = 0,
        uint64_t t_last_state = (uint64_t)-1,
        bool t_reset_checkpoint = true)
        : buffer_size (t_buffer_size),
          clear_knowledge (t_clear_knowledge),
          filename (t_filename),
          initial_timestamp (t_initial_timestamp),
          last_timestamp (t_last_timestamp),
          initial_lamport_clock (t_initial_lamport_clock),
          last_lamport_clock (t_last_lamport_clock),
          originator (t_originator),
          prefixes (t_prefixes),
          states (t_states),
          version (t_version),
          override_timestamp (t_override_timestamp),
          override_lamport (t_override_lamport),
          keep_open (t_keep_open),
          initial_state (t_initial_state),
          last_state (t_last_state),
          reset_checkpoint (t_reset_checkpoint)
      {
      }
       
      CheckpointSettings (const CheckpointSettings & rhs)
        : buffer_size (rhs.buffer_size), 
          clear_knowledge (rhs.clear_knowledge), 
          filename (rhs.filename),
          initial_timestamp (rhs.initial_timestamp),
          last_timestamp (rhs.last_timestamp),
          initial_lamport_clock (rhs.initial_lamport_clock),
          last_lamport_clock (rhs.last_lamport_clock),
          originator (rhs.originator),
          prefixes (rhs.prefixes),
          states (rhs.states),
          version (rhs.version),
          override_timestamp (rhs.override_timestamp),
          override_lamport (rhs.override_lamport),
          buffer_filters (rhs.buffer_filters),
          keep_open (rhs.keep_open),
          initial_state (rhs.initial_state),
          last_state (rhs.last_state),
          reset_checkpoint (rhs.reset_checkpoint),
          checkpoint_file (rhs.checkpoint_file)
      {
      }

       
      ~CheckpointSettings ()
      {
      }

      int encode (
        unsigned char * source, int size, int max_size) const
      {
        // encode from front to back
        for (filters::BufferFilters::const_iterator i = buffer_filters.begin ();
          i != buffer_filters.end (); ++i)
        {
          size = (*i)->encode (source, size, max_size);
        }

        return size;
      }


      int decode (
        unsigned char * source, int size, int max_size) const
      {
        // decode from back to front
        for (filters::BufferFilters::const_reverse_iterator i = buffer_filters.rbegin ();
          i != buffer_filters.rend (); ++i)
        {
          size = (*i)->decode (source, size, max_size);
        }

        return size;
      }

      size_t      buffer_size;

      bool        clear_knowledge;

      std::string filename;

      uint64_t   initial_timestamp;

      uint64_t   last_timestamp;

      uint64_t   initial_lamport_clock;

      uint64_t   last_lamport_clock;

      std::string originator;

      std::vector <std::string> prefixes;

      uint64_t   states;

      std::string version;

      bool override_timestamp;


      bool override_lamport;

      filters::BufferFilters   buffer_filters;

      bool keep_open;

      uint64_t   initial_state;

      uint64_t   last_state;

      bool       reset_checkpoint;

    private:
      std::shared_ptr<FILE>     checkpoint_file;
    };
  }
}
#endif //_MADARA_KNOWLEDGE_CHECKPOINTSETTINGS_H_