msg.h

Go to the documentation of this file.

#ifndef SESSTYPE__MSG_H__
#define SESSTYPE__MSG_H__

#ifdef __cplusplus
#include <algorithm>
#include <stdexcept>
#include <string>
#include <vector>
#endif

#include "sesstype/util/clonable.h"

#ifdef __cplusplus
namespace sesstype {
#endif

#ifdef __cplusplus

class MsgPayload : public util::Clonable {
    std::string name_;
    std::string type_;

  public:
    MsgPayload(std::string type) : name_(), type_(type) { }

    MsgPayload(std::string type, std::string name) : name_(name),
                                                     type_(type) { }

    MsgPayload(const MsgPayload &payload) : name_(payload.name_),
                                            type_(payload.type_) { }

    ~MsgPayload() { }

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

    std::string name() const
    {
        return name_;
    }

    std::string type() const
    {
        return type_;
    }

};

class MsgSig : public util::Clonable {
    std::string label_;
    std::vector<MsgPayload *> payloads_;

  public:
    typedef std::vector<MsgPayload *> PayloadContainer;

    MsgSig(std::string label) : label_(label), payloads_() { }

    MsgSig(const MsgSig &msgsig) : label_(msgsig.label_), payloads_()
    {
        for (auto payload : msgsig.payloads_) {
            payloads_.push_back(payload);
        }
    }

    virtual ~MsgSig()
    {
        for (auto payload : payloads_) {
            delete payload;
        }
    }

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

    std::string label() const
    {
        return label_;
    }

    void add_payload(MsgPayload *payload)
    {
        payloads_.push_back(payload->clone());
    }

    unsigned int num_payloads() const
    {
        return payloads_.size();
    }

    bool has_payload(std::string name) const
    {
        return (std::find_if(payloads_.begin(), payloads_.end(),
                    [name](const MsgPayload *const payload)
                    -> bool { return payload->name() == name; }) != payloads_.end());
    }

    MsgPayload *payload(unsigned int idx) const
    {
        return payloads_.at(idx);
    }

    MsgPayload *payload(std::string name) const
    {
        auto it = std::find_if(payloads_.begin(), payloads_.end(),
            [name](const MsgPayload *const payload)
                -> bool { return payload->name() == name; });
        if (it == payloads_.end()) {
            throw std::out_of_range("Payload "+name+" not found");
        }
        return *it;
    }

    PayloadContainer::const_iterator payload_begin() const
    {
        return payloads_.begin();
    }

    PayloadContainer::const_iterator payload_end() const
    {
        return payloads_.end();
    }
};
#endif // __cplusplus

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
typedef MsgSig st_msg;
typedef MsgPayload st_msg_payload;
#else
typedef struct MsgSig st_msg;
typedef struct MsgPayload st_msg_payload;
#endif

st_msg *st_mk_msg(const char *op);

st_msg *st_msg_add_payload(st_msg *msg, st_msg_payload *payload);

void st_msg_free(st_msg *msg);

st_msg_payload *st_mk_msg_payload(const char *type);

st_msg_payload *st_mk_msg_payload_annotated(const char *type, const char *name);

void st_msg_payload_free(st_msg_payload *payload);

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

#ifdef __cplusplus
} // namespace sesstype
#endif

#endif//SESSTYPE__MSG_H__