oneof.h

#ifndef SESSTYPE__PARAMETERISED__NODE__ONEOF_H__
#define SESSTYPE__PARAMETERISED__NODE__ONEOF_H__

#ifdef __cplusplus
#include <string>
#endif

#include "sesstype/node/block.h"
#include "sesstype/util/visitor_tmpl.h"

#include "sesstype/parameterised/msg.h"
#include "sesstype/parameterised/expr.h"
#include "sesstype/parameterised/expr/rng.h"
#include "sesstype/parameterised/role.h"
#include "sesstype/parameterised/node.h"

#ifdef __cplusplus
namespace sesstype {
namespace parameterised {
#endif

#ifdef __cplusplus

template <class BaseNode, class RoleType, class MessageType, class VisitorType>
class OneofNodeTmpl : public BlockNodeTmpl<BaseNode, RoleType, MessageType, VisitorType> {
    RoleType *selector_role_;
    unsigned int selector_dimen_;
    RngExpr *range_;
    std::string var_;
    bool unordered_;
    bool repeat_;

  public:
    OneofNodeTmpl(RoleType *selector, unsigned int dimen)
        : BlockNodeTmpl<BaseNode, RoleType, MessageType, VisitorType>(ST_NODE_ONEOF),
          selector_role_(selector),
          selector_dimen_(dimen),
          range_(),
          var_(),
          unordered_(false),
          repeat_(false) { }

    OneofNodeTmpl(const OneofNodeTmpl &node)
        : BlockNodeTmpl<BaseNode, RoleType, MessageType, VisitorType>(node),
          selector_role_(node.selector_role_),
          selector_dimen_(node.selector_dimen_),
          range_(),
          var_(),
          unordered_(false),
          repeat_(false) { }

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

    void set_var(std::string var)
    {
        var_ = var;
    }

    std::string var() const
    {
        return var_;
    }

    void set_repeat(bool repeat)
    {
        repeat_ = repeat;
    }

    bool is_repeat() const
    {
        return repeat_;
    }

    void set_range(RngExpr *range)
    {
        range_ = range;
    }

    RngExpr *range() const
    {
        return range_;
    }

    void set_selector(RoleType *selector, unsigned int dimen)
    {
        selector_role_ = selector;
        selector_dimen_ = dimen;
    }

    RoleType *selector_role() const
    {
        return selector_role_;
    }

    unsigned int selector_dimen() const
    {
        return selector_dimen_;
    }

    void set_unordered(bool unordered)
    {
        unordered_ = unordered;
    }

    bool is_unordered() const
    {
        return unordered_;
    }

    virtual void accept(VisitorType &v) override;
};

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

#ifdef __cplusplus
extern "C" {
#endif

st_node *st_mk_oneof_node(st_role *selector_role, unsigned int dimen);

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

#ifdef __cplusplus
} // namespace parameterised
} // namespace sesstype
#endif


#endif//SESSTYPE__PARAMETERISED__NODE__ONEOF_H__