module.h

Go to the documentation of this file.

#ifndef SESSTYPE__MODULE_H__
#define SESSTYPE__MODULE_H__

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

#include "sesstype/import.h"
#include "sesstype/session.h"

#ifdef __cplusplus

namespace sesstype {
#endif

#ifdef __cplusplus

template <class ImportType, class SessionType>
class ModuleTmpl {
    std::string name_;
    // Pair<Import * theimport, bool is_alias>
    std::unordered_map<std::string, std::pair<ImportType *, bool>> imports_;
    std::unordered_map<std::string, SessionType *> sessions_;

  public:
    using ImportContainer  = std::unordered_map<std::string, std::pair<ImportType *, bool>>;
    using SessionContainer = std::unordered_map<std::string, SessionType *>;

    ModuleTmpl() : name_("default"), imports_(), sessions_() { }

    ModuleTmpl(std::string name) : name_(name), imports_(), sessions_() { }

    virtual ~ModuleTmpl()
    {
        for (auto import_pair : imports_) {
            if (!import_pair.second.second /*alias?*/) {
                delete import_pair.second.first;
            }
        }
    }

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

    void set_name(std::string name)
    {
        name_ = name;
    }

    void add_session(SessionType *session)
    {
        sessions_.insert({ session->name(), session });
    }

    unsigned int num_sessions() const
    {
        return sessions_.size();
    }

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

    SessionType *session(std::string name) const
    {
        return sessions_.at(name);
    }

    typename SessionContainer::const_iterator session_begin() const
    {
        return sessions_.begin();
    }

    typename SessionContainer::const_iterator session_end() const
    {
        return sessions_.end();
    }

    void add_import(ImportType *import)
    {
        imports_.insert({ import->name(), std::make_pair(import, false)});
        if (import->as() != "") {
            imports_.insert({ import->as(), std::make_pair(import, true/*alias*/)});
        }
    }

    unsigned int num_imports() const
    {
        return imports_.size();
    }

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

    ImportType *import(std::string name) const
    {
        return imports_.at(name).first;
    }

    typename ImportContainer::const_iterator import_begin() const
    {
        return imports_.begin();
    }

    typename ImportContainer::const_iterator import_end() const
    {
        return imports_.end();
    }
};

using Module = ModuleTmpl<Import, Session>;
#endif // __cplusplus

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
typedef Module st_module;
#else
typedef struct Module st_module;
#endif

st_module *st_module_mk_init(const char *name);

const char *st_module_get_name(st_module *const module);

st_module *st_module_add_tree(st_module *const module, st_tree *tree);

st_tree *st_module_get_tree(st_module *const module, const char *name);

st_tree *st_module_get_tree_at_idx(st_module *const module, unsigned int index);

st_module *st_module_import(st_module *const module, st_import *import);

void st_module_free(st_module *module);

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

#ifdef __cplusplus
} // namespace sesstype
#endif

#endif//SESSTYPE__MODULE_H__