session.h

Go to the documentation of this file.

#ifndef SESSTYPE__SESSION_H__
#define SESSTYPE__SESSION_H__

#ifdef __cplusplus
#include <string>
#include <iterator>
#include <unordered_map>
#endif

#include <sesstype/import.h>
#include <sesstype/node.h>
#include <sesstype/role.h>

#ifdef __cplusplus
namespace sesstype {
#endif

#define ST_TYPE_GLOBAL 1
#define ST_TYPE_LOCAL  2

#ifdef __cplusplus

template <class BaseNode, class RoleType>
class SessionTmpl {
    std::string name_;
    int type_;
    RoleType *me_; // Localised role (only used in endpoint session)
    BaseNode *root_;
    std::unordered_map<std::string, RoleType *> roles_;

  public:
    using RoleContainer = std::unordered_map<std::string, RoleType *>;

    SessionTmpl()
        : name_("default"), type_(ST_TYPE_GLOBAL), me_(), root_(0), roles_() { }

    SessionTmpl(std::string name)
        : name_(name), type_(ST_TYPE_GLOBAL), me_(), root_(0), roles_() { }

    virtual ~SessionTmpl()
    {
        {
            for (auto role_pair : roles_) {
                delete role_pair.second;
            }
            if (root_ != NULL) {
                delete root_;
            }
        }
    }

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

    void set_root(BaseNode *root)
    {
        if (root_ != NULL) {
            delete root_;
        }
        root_ = root;
    }

    BaseNode *root() const
    {
        return root_;
    }

    RoleType *endpoint() const
    {
        return me_;
    }

    void set_endpoint(RoleType *endpoint)
    {
        me_ = endpoint;
        type_ = ST_TYPE_LOCAL;
    }

    void project(Role *role)
    {
//        util::Projection projection_visitor(role);
//        root_->accept(projection_visitor);
    }

    int type() const
    {
        return type_;
    }

    void add_role(RoleType *role)
    {
        roles_.insert(std::pair<std::string, RoleType *>(role->name(), role));
    }

    bool has_role(RoleType *role) const
    {
        return (roles_.find(role->name()) != roles_.end());
    }

    bool has_role(std::string name) const
    {
        return (roles_.find(name) != roles_.end());
    }

    RoleType *role(std::string name) const
    {
        return roles_.at(name);
    }

    unsigned int num_roles() const
    {
        return roles_.size();
    }

    typename RoleContainer::const_iterator role_begin() const
    {
        return roles_.begin();
    }

    typename RoleContainer::const_iterator role_end() const
    {
        return roles_.end();
    }
};

using Session = SessionTmpl<Node, Role>;
#endif

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
typedef Session st_tree;
#else
typedef struct Session st_tree;
#endif

st_tree *st_tree_mk_init(const char *name);

st_tree *st_tree_add_role(st_tree *tree, st_role *role);

st_tree *st_tree_set_root(st_tree *tree, st_node *root);

st_node *st_tree_get_root(st_tree *tree);

void st_tree_free(st_tree *tree);

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

#ifdef __cplusplus
} // namespace sesstype
#endif

#endif//SESSTYPE__SESSION_H__