TransportBase.hh

Go to the documentation of this file.

#ifndef EUDAQ_INCLUDED_TransportBase
#define EUDAQ_INCLUDED_TransportBase

#include "eudaq/Platform.hh"
#include "eudaq/Mutex.hh"
#include "eudaq/Exception.hh"
#include "eudaq/BufferSerializer.hh"
#include <string>
#include <queue>
#include <iosfwd>
#include <cstring>
#include <iostream>

namespace eudaq {

  class DLLEXPORT ConnectionInfo {
  public:
    explicit ConnectionInfo(const std::string &name = "")
        : m_state(0), m_name(name) { }

    ConnectionInfo(const std::string &name, const std::string type)
        : m_state(0), m_name(name), m_type(type) { }


    virtual ~ConnectionInfo() {}
    virtual void Print(std::ostream &) const;
    virtual bool Matches(const ConnectionInfo &other) const;
    bool IsEnabled() const { return m_state >= 0; }
    int GetState() const { return m_state; }
    void SetState(int state) { m_state = state; }
    std::string GetType() const { return m_type; }
    void SetType(const std::string &type) { m_type = type; }
    std::string GetName() const { return m_name; }
    void SetName(const std::string &name) { m_name = name; }

    int GetRemoteInfo() const;
    virtual std::string GetRemote() const { return m_host; }

    static const ConnectionInfo ALL;

    virtual ConnectionInfo *Clone() const { return new ConnectionInfo(*this); }

    bool operator < (const ConnectionInfo comp) const
    {
      return(GetRemoteInfo() < comp.GetRemoteInfo());
      /*
      std::string comp_host = comp.GetRemote();
      return (
        std::stoi(m_host.substr(m_host.find(":"))) <
        std::stoi(comp_host.substr(comp_host.find(":")))
        ); */
    }

  protected:
    int m_state;
    std::string m_type, m_name;
    std::string m_host;
    /*

       public:
       virtual bool operator = (const ClientID & other) = 0;
       virtual std::string Name() const = 0;
     */
  };

  inline std::ostream &operator<<(std::ostream &os, const ConnectionInfo &id) {
    id.Print(os);
    return os;
  }

  class TransportEvent {
  public:
    enum EventType { CONNECT, DISCONNECT, RECEIVE };
    TransportEvent(EventType et, ConnectionInfo &i, const std::string &p = "")
        : etype(et), id(i), packet(p) {}
    EventType etype;    
    ConnectionInfo &id; 
    std::string packet; 
  };

  class TransportCallback {
    class Helper {
    public:
      virtual void call(TransportEvent &) = 0;
      virtual ~Helper() {}
      virtual Helper *Clone() const = 0;
    };
    class HelperFunction : public Helper {
    public:
      typedef void (*FuncType)(TransportEvent &);
      HelperFunction(FuncType func) : m_func(func) {}
      virtual void call(TransportEvent &ev) { m_func(ev); }
      virtual Helper *Clone() const { return new HelperFunction(*this); }

    private:
      FuncType m_func; 
    };
    template <typename T> class HelperMember : public Helper {
    public:
      typedef T ObjType;
      typedef void (ObjType::*FuncType)(TransportEvent &);
      HelperMember(ObjType *obj, FuncType func) : m_obj(obj), m_func(func) {}
      virtual void call(TransportEvent &ev) { (m_obj->*m_func)(ev); }
      virtual Helper *Clone() const { return new HelperMember(*this); }

    private:
      ObjType *m_obj;  
      FuncType m_func; 
    };

  public:
    TransportCallback() : m_helper(0) {}
    TransportCallback(HelperFunction::FuncType funcptr)
        : m_helper(new HelperFunction(funcptr)) {}
    template <typename T>
    TransportCallback(T *obj, typename HelperMember<T>::FuncType func)
        : m_helper(new HelperMember<T>(obj, func)) {}
    void operator()(TransportEvent &ev) {
      if (m_helper)
        m_helper->call(ev);
    }
    TransportCallback(const TransportCallback &other)
        : m_helper(other.m_helper->Clone()) {}
    TransportCallback &operator=(const TransportCallback &other) {
      delete m_helper;
      m_helper = other.m_helper->Clone();
      return *this;
    }
    ~TransportCallback() { delete m_helper; }

  private:
    Helper *m_helper; 
  };

  class TransportBase {
  public:
    TransportBase();
    virtual ~TransportBase();

    virtual void SendPacket(const unsigned char *data, size_t len,
                            const ConnectionInfo & = ConnectionInfo::ALL,
                            bool duringconnect = false) = 0;
    void SendPacket(const std::string &data,
                    const ConnectionInfo &inf = ConnectionInfo::ALL,
                    bool duringconnect = false) {
      // std::cout << "SendPacket (string)" << std::endl;
      SendPacket(reinterpret_cast<const unsigned char *>(&data[0]),
                 data.length(), inf, duringconnect);
    }
    void SendPacket(const char *str,
                    const ConnectionInfo &inf = ConnectionInfo::ALL,
                    bool duringconnect = false) {
      // std::cout << "SendPacket (char*)" << std::endl;
      SendPacket(reinterpret_cast<const unsigned char *>(str), std::strlen(str),
                 inf, duringconnect);
    }
    void SendPacket(const BufferSerializer &t,
                    const ConnectionInfo &inf = ConnectionInfo::ALL,
                    bool duringconnect = false) {
      SendPacket(&t[0], t.size(), inf, duringconnect);
    }

    virtual void Close(const ConnectionInfo &) {}

    virtual void ProcessEvents(int timeout) = 0;

    void Process(int timeout = -1);
    bool ReceivePacket(std::string *packet, int timeout = -1,
                       const ConnectionInfo & = ConnectionInfo::ALL);
    bool SendReceivePacket(const std::string &sendpacket,
                           std::string *recpacket,
                           const ConnectionInfo &connection, int timeout = -1);
    template <typename T>
    T SendReceivePacket(const std::string &packet,
                        const ConnectionInfo &connection, int timeout = -1);
    void SetCallback(const TransportCallback &);
    virtual bool IsNull() const { return false; }

  protected:
    std::queue<TransportEvent>
        m_events; 
    TransportCallback
        m_callback; 
    Mutex m_mutex;
  };

  template <typename T>
  inline T TransportBase::SendReceivePacket(const std::string &packet,
                                            const ConnectionInfo &connection,
                                            int timeout) {
    std::string buf;
    bool ok = SendReceivePacket(packet, &buf, connection, timeout);
    if (!ok)
      EUDAQ_THROW("Timeout: No response in SendReceivePacket");
    BufferSerializer ser(buf.begin(), buf.end());
    T result;
    ser.read(result);
    return result;
  }
}

#endif // EUDAQ_INCLUDED_TransportBase