QoSTransportSettings.h

Go to the documentation of this file.

#ifndef _MADARA_QOS_TRANSPORT_SETTINGS_H_
#define _MADARA_QOS_TRANSPORT_SETTINGS_H_
 
#include <string>
 
#include "madara/transport/TransportSettings.h"
#include "madara/transport/TransportContext.h"
#include "madara/knowledge/ThreadSafeContext.h"
#include "madara/utility/StdInt.h"
#include "madara/MadaraExport.h"
#include "madara/filters/AggregateFilter.h"
#include "madara/filters/RecordFilter.h"
#include "madara/filters/BufferFilter.h"
#include "madara/knowledge/KnowledgeRecordFilters.h"
 
#ifdef _MADARA_JAVA_
#include <jni.h>
#endif
 
#ifdef _MADARA_PYTHON_CALLBACKS_
#include <boost/python.hpp>
#endif
 
namespace madara
{
namespace transport
{
enum PacketDropType
{
  PACKET_DROP_DETERMINISTIC,
  PACKET_DROP_PROBABLISTIC
};
 
class MADARA_EXPORT QoSTransportSettings : public TransportSettings
{
public:
  QoSTransportSettings();
 
  QoSTransportSettings(const QoSTransportSettings& settings);
 
  QoSTransportSettings(const TransportSettings& settings);
 
  virtual ~QoSTransportSettings();
 
  void operator=(const QoSTransportSettings& settings);
 
  void operator=(const TransportSettings& settings);
 
  void add_send_filter(uint32_t types,
      knowledge::KnowledgeRecord (*function)(
          knowledge::FunctionArguments&, knowledge::Variables&));
 
  void add_send_filter(uint32_t types, filters::RecordFilter* filter);
 
  void add_send_filter(void (*function)(knowledge::KnowledgeMap&,
      const TransportContext&, knowledge::Variables&));
 
  void add_send_filter(filters::AggregateFilter* filter);
 
  void add_filter(filters::BufferFilter* filter);
 
  void add_receive_filter(uint32_t types,
      knowledge::KnowledgeRecord (*function)(
          knowledge::FunctionArguments&, knowledge::Variables&));
 
  void add_receive_filter(uint32_t types, filters::RecordFilter* filter);
 
  void add_receive_filter(void (*function)(knowledge::KnowledgeMap&,
      const TransportContext&, knowledge::Variables&));
 
  void add_receive_filter(filters::AggregateFilter* filter);
 
  void add_rebroadcast_filter(uint32_t types,
      knowledge::KnowledgeRecord (*function)(
          knowledge::FunctionArguments&, knowledge::Variables&));
 
  void add_rebroadcast_filter(uint32_t types, filters::RecordFilter* filter);
 
  void add_rebroadcast_filter(void (*function)(knowledge::KnowledgeMap&,
      const TransportContext&, knowledge::Variables&));
 
  void add_rebroadcast_filter(filters::AggregateFilter* filter);
 
#ifdef _MADARA_JAVA_
 
  void add_receive_filter(uint32_t types, jobject& object);
 
  void add_send_filter(uint32_t types, jobject& object);
 
  void add_rebroadcast_filter(uint32_t types, jobject& object);
 
  void add_receive_filter(jobject& object);
 
  void add_send_filter(jobject& object);
 
  void add_rebroadcast_filter(jobject& object);
 
  void add_filter(jobject& object);
 
#endif
 
#ifdef _MADARA_PYTHON_CALLBACKS_
 
  void add_receive_filter(uint32_t types, boost::python::object& object);
 
  void add_send_filter(uint32_t types, boost::python::object& object);
 
  void add_rebroadcast_filter(uint32_t types, boost::python::object& object);
 
  void add_receive_filter(boost::python::object& object);
 
  void add_send_filter(boost::python::object& object);
 
  void add_rebroadcast_filter(boost::python::object& object);
 
  void add_filter(boost::python::object& object);
 
#endif
 
  void attach(knowledge::ThreadSafeContext* context);
 
  void clear_send_filters(uint32_t types);
 
  void clear_send_aggregate_filters(void);
 
  void clear_receive_filters(uint32_t types);
 
  void clear_buffer_filters(void);
 
  void clear_receive_aggregate_filters(void);
 
  void clear_rebroadcast_filters(uint32_t types);
 
  void clear_rebroadcast_aggregate_filters(void);
 
  knowledge::KnowledgeRecord filter_send(
      const madara::knowledge::KnowledgeRecord& input, const std::string& name,
      transport::TransportContext& context) const;
 
  void filter_send(knowledge::KnowledgeMap& records,
      const transport::TransportContext& transport_context) const;
 
  knowledge::KnowledgeRecord filter_receive(
      const madara::knowledge::KnowledgeRecord& input, const std::string& name,
      transport::TransportContext& context) const;
 
  void filter_receive(knowledge::KnowledgeMap& records,
      const transport::TransportContext& transport_context) const;
 
  knowledge::KnowledgeRecord filter_rebroadcast(
      const madara::knowledge::KnowledgeRecord& input, const std::string& name,
      transport::TransportContext& context) const;
 
  void filter_rebroadcast(knowledge::KnowledgeMap& records,
      const transport::TransportContext& transport_context) const;
 
  int filter_encode(char* source, int size, int max_size) const;
 
  int filter_decode(char* source, int size, int max_size) const;
 
  void print_num_filters_send(void) const;
 
  void print_num_filters_receive(void) const;
 
  void print_num_filters_rebroadcast(void) const;
 
  void set_rebroadcast_ttl(unsigned char ttl);
 
  unsigned char get_rebroadcast_ttl(void) const;
 
  size_t get_number_of_send_filtered_types(void) const;
 
  size_t get_number_of_send_aggregate_filters(void) const;
 
  size_t get_number_of_rebroadcast_aggregate_filters(void) const;
 
  size_t get_number_of_rebroadcast_filtered_types(void) const;
 
  size_t get_number_of_receive_aggregate_filters(void) const;
 
  size_t get_number_of_receive_filtered_types(void) const;
 
  size_t get_number_of_buffer_filters(void) const;
 
  void add_trusted_peer(const std::string& peer);
 
  void add_banned_peer(const std::string& peer);
 
  bool remove_trusted_peer(const std::string& peer);
 
  bool remove_banned_peer(const std::string& peer);
 
  bool is_trusted(const std::string& peer) const;
 
  void enable_participant_ttl(unsigned char maximum_ttl = 255);
 
  unsigned char get_participant_ttl(void) const;
 
  void update_drop_rate(double drop_rate,
      int drop_type = PACKET_DROP_DETERMINISTIC, uint64_t drop_burst = 1);
 
  double get_drop_rate(void) const;
 
  int get_drop_type(void) const;
 
  uint64_t get_drop_burst(void) const;
 
  void set_send_bandwidth_limit(int64_t bandwidth);
 
  int64_t get_send_bandwidth_limit(void) const;
 
  void set_total_bandwidth_limit(int64_t bandwidth);
 
  int64_t get_total_bandwidth_limit(void) const;
 
  void set_deadline(double deadline);
 
  double get_deadline(void) const;
 
  virtual void load(
      const std::string& filename, const std::string& prefix = "transport");
 
  virtual void load_text(
      const std::string& filename, const std::string& prefix = "transport");
 
  virtual void save(const std::string& filename,
      const std::string& prefix = "transport") const;
 
  virtual void save_text(const std::string& filename,
      const std::string& prefix = "transport") const;
 
private:
  unsigned char rebroadcast_ttl_;
 
  unsigned char participant_rebroadcast_ttl_;
 
  std::map<std::string, int> trusted_peers_;
 
  std::map<std::string, int> banned_peers_;
 
  knowledge::KnowledgeRecordFilters rebroadcast_filters_;
 
  knowledge::KnowledgeRecordFilters receive_filters_;
 
  knowledge::KnowledgeRecordFilters send_filters_;
 
  filters::BufferFilters buffer_filters_;
 
  double packet_drop_rate_;
 
  int packet_drop_type_;
 
  uint64_t packet_drop_burst_;
 
  int64_t max_send_bandwidth_;
 
  int64_t max_total_bandwidth_;
 
  double deadline_;
};
}  // end Transport namespace
}  // end Madara namespace
 
#endif  // _MADARA_QOS_TRANSPORT_SETTINGS_H_