interaction.h

#ifndef SESSTYPE__NODE__INTERACTION_H__
#define SESSTYPE__NODE__INTERACTION_H__

#ifdef __cplusplus
#include <vector>
#endif

#include "sesstype/msg.h"
#include "sesstype/node.h"
#include "sesstype/role.h"

#ifdef __cplusplus
namespace sesstype {
#endif

#ifdef __cplusplus

template <class BaseNode, class RoleType, class MessageType, class VisitorType>
class InteractionNodeTmpl : public BaseNode {
    MessageType *msg_;
    RoleType *sndr_;
    std::vector<RoleType *> rcvrs_;

  public:
    typedef typename std::vector<RoleType *> RoleContainer;

    InteractionNodeTmpl() : BaseNode(ST_NODE_SENDRECV),
                            msg_(new MessageType("")),
                            sndr_(nullptr), rcvrs_() { }

    InteractionNodeTmpl(MessageType *msg) : BaseNode(ST_NODE_SENDRECV),
                                            msg_(msg->clone()),
                                            sndr_(nullptr), rcvrs_() { }

    InteractionNodeTmpl(const InteractionNodeTmpl &node)
        : BaseNode(ST_NODE_SENDRECV),
          msg_(node.msg_->clone()),
          sndr_(node.sndr_ ? node.sndr_->clone() : nullptr), rcvrs_()
    {
        for (auto rcvr : node.rcvrs_) {
            rcvrs_.push_back(rcvr->clone());
        }
    }

    ~InteractionNodeTmpl() override
    {
        delete msg_;
        if (sndr_) delete sndr_;
        for (auto rcvr : rcvrs_) {
            delete rcvr;
        }
    }

    InteractionNodeTmpl *clone() const override
    {
        return new InteractionNodeTmpl(*this);
    }

    void set_msg(MessageType *msg)
    {
        if (msg_) delete msg_;
        msg_ = msg->clone();
    }

    MessageType *msg() const
    {
        return msg_;
    }

    void set_sndr(RoleType *sndr)
    {
        if (sndr_) delete sndr_;
        sndr_ = sndr->clone();
    }

    RoleType *sndr() const
    {
        return sndr_;
    }

    void remove_sndr()
    {
        delete sndr_;
        sndr_ = nullptr;
    }

    void add_rcvr(RoleType *rcvr)
    {
        rcvrs_.push_back(rcvr->clone());
    }

    unsigned int num_rcvrs() const
    {
        return rcvrs_.size();
    }

    RoleType *rcvr() const
    {
        return rcvrs_.at(0);
    }

    RoleType *rcvr(unsigned int idx) const
    {
        return rcvrs_.at(idx);
    }

    void remove_rcvrs()
    {
        for (auto rcvr : rcvrs_) {
            delete rcvr;
        }
        rcvrs_.clear();
    }

    typename RoleContainer::const_iterator rcvr_begin() const
    {
        return rcvrs_.begin();
    }

    typename RoleContainer::const_iterator rcvr_end() const
    {
        return rcvrs_.end();
    }

    void accept(VisitorType &v) override;
};

using InteractionNode = InteractionNodeTmpl<Node, Role, MsgSig, util::NodeVisitor>;
#endif // __cplusplus

#ifdef __cplusplus
extern "C" {
#endif

st_node *st_mk_interaction_node_init();

st_node *st_mk_interaction_node(st_msg *msg);

st_node *st_interaction_node_set_msg(st_node *const node, st_msg *msg);

st_msg *st_interaction_node_get_msg(st_node *const node);

st_node *st_interaction_node_set_from(st_node *const node, st_role *from);

st_role *st_interaction_node_get_from(st_node *const node);

st_node *st_interaction_node_add_to(st_node *const node, st_role *to);

unsigned int st_interaction_node_num_tos(st_node *const node);

st_role **st_interaction_node_get_tos(st_node *const node);

st_role *st_interaction_node_get_to(st_node *const node, unsigned int index);

#ifdef __cplusplus
} // extern "C"
#endif

#ifdef __cplusplus
} // namespace sesstype
#endif

#endif//SESSTYPE__NODE__INTERACTION_H__