bridge.h

// o2_bridge.h -- headers to support extensions for non-IP transports
//
// Roger B. Dannenberg
// April 2018
 
#ifndef O2_NO_BRIDGES
 
#ifdef O2_NO_DEBUG
#define TO_BRIDGE_INFO(node) ((Bridge_info *) (node))
#else
#define TO_BRIDGE_INFO(node) (assert(ISA_BRIDGE(((Bridge_info *) (node)))),\
                              ((Bridge_info *) (node)))
#endif
 
class Bridge_info;
 
extern int o2_bridge_next_id;
 
class Bridge_protocol : public O2obj {
public:
    char protocol[8];
    Bridge_protocol(const char *name);
 
    // Bridge_info that share this protocol.
    Vec<Bridge_info *> instances;
 
    virtual ~Bridge_protocol();
 
    virtual O2err bridge_poll() { return O2_SUCCESS; }
 
    O2err remove_services(Bridge_info *bi);
 
    int find_loc(int id);
    
    Bridge_info *find(int id) {
        int i = find_loc(id);
        return (i < 0 ? NULL : instances[i]);
    }
 
    void remove_instance(int id) {
        int loc = find_loc(id);
        if (loc >= 0) {
            instances.remove(loc);
        }
    }
 
};
 
 
class Bridge_info : public Proxy_info {
public:
    int id;  // a unique id for the bridged process
    Bridge_protocol *proto;  // this could almost be information returned
    // by a virtual method rather than allocating a pointer in every
    // instance, but we need it for the destructor, where you cannot
    // call virtual methods.
    
    Bridge_info(Bridge_protocol *proto_) :
            Proxy_info(NULL, O2TAG_BRIDGE) {
        proto = proto_;
        id = o2_bridge_next_id++;
        proto->instances.push_back(this);
    }
    virtual ~Bridge_info() { proto->remove_instance(id); }
  
    virtual O2err send(bool block) = 0;
 
    O2err send_to_taps(O2message_ptr msg);
 
#ifndef O2_NO_DEBUG
    virtual void show(int indent);
#endif
    virtual bool local_is_synchronized() { return IS_SYNCED(this); }
    O2status status(const char **process) {
        if (process) {
            *process = get_proc_name();
        }
        return (o2_clock_is_synchronized && IS_SYNCED(this)) ?
               O2_BRIDGE : O2_BRIDGE_NOTIME;
    }
};    
 
void o2_bridge_csget_handler(o2_msg_data_ptr msgdata, int seqno,
                             const char *replyto);
void o2_bridge_cscs_handler();
void o2_bridge_cscs_handler(o2_msg_data_ptr msgdata, const char *types,
                            O2arg_ptr *argv, int argc, const void *user_data);
void o2_bridge_sv_handler(o2_msg_data_ptr msgdata, const char *types,
                          O2arg_ptr *argv, int argc, const void *user_data);
void o2_bridge_st_handler(o2_msg_data_ptr msgdata, const char *types,
                          O2arg_ptr *argv, int argc, const void *user_data);
void o2_bridge_ls_handler(o2_msg_data_ptr msgdata, const char *types,
                          O2arg_ptr *argv, int argc, const void *user_data);
 
void o2_bridge_show(Bridge_info *bridge);
 
int o2_bridge_find_protocol(const char *protocol_name,
                            Bridge_protocol **protocol);
 
int o2_poll_bridges(void);
 
void o2_bridges_initialize(void);
 
void o2_bridges_finish(void);
 
extern Bridge_protocol *o2lite_protocol;
 
#endif