#include "cppa/cppa.hpp"

#include "cppa/group.hpp"

#include "cppa/any_tuple.hpp"

#include "cppa/util/shared_spinlock.hpp"

#include "cppa/util/shared_lock_guard.hpp"

#include "cppa/util/upgrade_lock_guard.hpp"

#include "cppa/detail/group_manager.hpp"

#include "cppa/detail/singleton_manager.hpp"

namespace cppa {

namespace {

inline detail::group_manager* manager() {

return detail::singleton_manager::get_group_manager();

}

} // <anonymous>

intrusive_ptr<group> group::get(const std::string& arg0,

const std::string& arg1) {

return manager()->get(arg0, arg1);

}

intrusive_ptr<group> group::anonymous() {

return manager()->anonymous();

}

void group::add_module(group::unique_module_ptr ptr) {

manager()->add_module(std::move(ptr));

}

group::module_ptr group::get_module(const std::string& module_name) {

return manager()->get_module(module_name);

}

group::subscription::subscription(const channel_ptr& s,

const intrusive_ptr<group>& g)

: m_subscriber(s), m_group(g) { }

group::subscription::~subscription() {

if (valid()) m_group->unsubscribe(m_subscriber);

}

group::module::module(std::string name) : m_name(std::move(name)) { }

const std::string& group::module::name() {

return m_name;

}

group::group(group::module_ptr mod, std::string id)

: m_module(mod), m_identifier(std::move(id)) { }

const std::string& group::identifier() const {

return m_identifier;

}

group::module_ptr group::get_module() const {

return m_module;

}

const std::string& group::module_name() const {

return get_module()->name();

}

struct group_nameserver : event_based_actor {

};

void publish_local_groups_at(std::uint16_t port, const char* addr) {

}

} // namespace cppa