Fragmentation.h

Go to the documentation of this file.

#ifndef _MADARA_FRAGMENTATION_HEADER_H_
#define _MADARA_FRAGMENTATION_HEADER_H_
 
#include <map>
#include <string>
#include <string.h>
#include "madara/utility/StdInt.h"
#include "madara/utility/ScopedArray.h"
#include "madara/MadaraExport.h"
#include "madara/transport/MessageHeader.h"
 
namespace madara
{
namespace transport
{
#define FRAGMENTATION_MADARA_ID "KFRG1.4"
 
class MADARA_EXPORT FragmentMessageHeader : public MessageHeader
{
public:
  FragmentMessageHeader();
 
  virtual ~FragmentMessageHeader();
 
  virtual uint32_t encoded_size(void) const override;
 
  static uint32_t static_encoded_size(void);
 
  static uint32_t get_updates(const char* buffer);
 
  virtual const char* read(
      const char* buffer, int64_t& buffer_remaining) override;
 
  void operator=(MessageHeader& header);
 
  virtual char* write(char* buffer, int64_t& buffer_remaining) override;
 
  virtual bool equals(const MessageHeader& other) override;
 
  static inline bool fragment_message_header_test(const char* buffer)
  {
    return strncmp(&(buffer[8]), FRAGMENTATION_MADARA_ID, 7) == 0;
  }
 
  virtual std::string to_string (void) override;
 
  uint32_t update_number;
  uint64_t total_size;
};
 
typedef std::map<uint32_t, utility::ScopedArray<const char>> FragmentMap;
 
typedef std::map<uint64_t, FragmentMap> ClockFragmentMap;
 
typedef std::map<std::string, ClockFragmentMap> OriginatorFragmentMap;
 
MADARA_EXPORT char* add_fragment(const char* originator, uint64_t clock,
    uint32_t update_number, const char* fragment, uint32_t queue_length,
    OriginatorFragmentMap& map, uint64_t & total_size, bool clear = true);
 
MADARA_EXPORT char* defrag(FragmentMap& map, uint64_t & total_size);
 
MADARA_EXPORT void delete_fragments(FragmentMap& map);
 
MADARA_EXPORT void frag(
    const char* source, uint64_t total_size,
    const char* originator, const char* domain,
    uint64_t clock,
    uint64_t timestamp,
    uint32_t quality, unsigned char ttl,
    uint64_t fragment_size, FragmentMap& map);
 
MADARA_EXPORT bool is_complete(
    const char* originator, uint64_t clock, OriginatorFragmentMap& map);
 
MADARA_EXPORT bool exists(const char* originator, uint64_t clock,
    uint32_t update_number, OriginatorFragmentMap& map);
}
}
 
#endif  // _MADARA_FRAGMENTATION_HEADER_H_