Transport.h

Go to the documentation of this file.

#ifndef _MADARA_TRANSPORT_H_
#define _MADARA_TRANSPORT_H_

#include <string>
#include <sstream>
#include <vector>
#include <ostream>

#include "madara/utility/ThreadSafeVector.h"
#include "madara/MadaraExport.h"
#include "madara/transport/QoSTransportSettings.h"

#include "ReducedMessageHeader.h"
#include "madara/transport/BandwidthMonitor.h"
#include "madara/transport/PacketScheduler.h"

#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/knowledge/ThreadSafeContext.h"
#include "madara/expression/ExpressionTree.h"
#include "madara/expression/Interpreter.h"

namespace madara
{
  namespace transport
  {
    class MADARA_EXPORT Base
    {
    public:
      typedef    std::vector <std::string>           HostsVector;

      Base (const std::string & id, TransportSettings & new_settings,
        knowledge::ThreadSafeContext & context);

      virtual ~Base () = 0;

      int validate_transport (void);

      virtual int setup (void);

      int check_transport (void);

      TransportSettings & settings (void);

      long prep_send (const knowledge::VariableReferenceMap & orig_updates,
        const char * print_prefix);

      virtual long send_data (const knowledge::VariableReferenceMap &) = 0;


      void invalidate_transport (void);

      virtual void close (void);

    protected:
      volatile bool is_valid_;
      volatile bool shutting_down_;
      HostsVector hosts;

      const std::string id_;

      QoSTransportSettings settings_;

      // context for knowledge base
      madara::knowledge::ThreadSafeContext & context_;
      
#ifndef _MADARA_NO_KARL_
      madara::expression::ExpressionTree  on_data_received_;
      
#endif // _MADARA_NO_KARL_

      BandwidthMonitor send_monitor_;
      
      BandwidthMonitor receive_monitor_;

      PacketScheduler packet_scheduler_;

      madara::utility::ScopedArray<char> buffer_;
    };

    int MADARA_EXPORT process_received_update (
        const char * buffer,
        uint32_t bytes_read,
        const std::string & id,
        knowledge::ThreadSafeContext & context,
        const QoSTransportSettings & settings,
        BandwidthMonitor & send_monitor,
        BandwidthMonitor & receive_monitor,
       knowledge::KnowledgeMap& rebroadcast_records,
#ifndef _MADARA_NO_KARL_

        knowledge::CompiledExpression & on_data_received,
#endif // _MADARA_NO_KARL_

        const char * print_prefix,
        const char * remote_host,
        MessageHeader *& header
        );

    int MADARA_EXPORT prep_rebroadcast (
      knowledge::ThreadSafeContext & context,
      char * buffer,
      int64_t & buffer_remaining,
      const QoSTransportSettings & settings,
      const char * print_prefix,
      MessageHeader * header,
      const knowledge::KnowledgeMap& records,
      PacketScheduler & packet_scheduler);

    typedef   utility::ThreadSafeVector <Base *>   Transports;
  }
}

#include "Transport.inl"

#endif  // _MADARA_TRANSPORT_H_