friend class detail::group_manager;

friend class detail::peer_connection; // needs access to remote_enqueue

public:

class subscription;

// needs access to unsubscribe()

friend class subscription;

// unsubscribes its channel from the group on destruction

class subscription {

friend class group;

subscription(const subscription&) = delete;

subscription& operator=(const subscription&) = delete;

public:

subscription() = default;

subscription(subscription&&) = default;

subscription(const channel_ptr& s, const intrusive_ptr<group>& g);

~subscription();

inline bool valid() const { return (m_subscriber) && (m_group); }

private:

channel_ptr m_subscriber;

intrusive_ptr<group> m_group;

};

/**

class module {

std::string m_name;

protected:

module(std::string module_name);

public:

/**

const std::string& name();

/**

virtual intrusive_ptr<group> get(const std::string& group_name) = 0;

virtual intrusive_ptr<group> deserialize(deserializer* source) = 0;

};

typedef module* module_ptr;

typedef std::unique_ptr<module> unique_module_ptr;

virtual void serialize(serializer* sink) = 0;

/**

const std::string& identifier() const;

module_ptr get_module() const;

/**

const std::string& module_name() const;

/**

virtual subscription subscribe(const channel_ptr& who) = 0;

/**

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

const std::string& group_identifier);

/**

static intrusive_ptr<group> anonymous();

/**

static void add_module(unique_module_ptr);

/**

static module_ptr get_module(const std::string& module_name);

protected:

group(module_ptr module, std::string group_id);

virtual void unsubscribe(const channel_ptr& who) = 0;

module_ptr m_module;

std::string m_identifier;