#include <GroupsManager.h>

Collaboration diagram for web::websocket::server::GroupsManager:

Public Member Functions
	GroupsManager ()=default

	GroupsManager (const GroupsManager &)=delete

GroupsManager &	operator= (const GroupsManager &)=delete

void	subscribe (SubProtocol *subProtocol, std::string group="")

void	unsubscribe (SubProtocol *subProtocol)

void	sendBroadcast (const std::string &group, const char message, std::size_t messageLength, const SubProtocol excludedClient)

void	sendBroadcast (const std::string &group, const std::string &message, const SubProtocol *excludedClient)

void	sendBroadcastStart (const std::string &group, const char message, std::size_t messageLength, const SubProtocol excludedClient)

void	sendBroadcastStart (const std::string &group, const std::string &message, const SubProtocol *excludedClient)

void	sendBroadcastFrame (const std::string &group, const char message, std::size_t messageLength, const SubProtocol excludedClient)

void	sendBroadcastFrame (const std::string &group, const std::string &message, const SubProtocol *excludedClient)

void	sendBroadcastEnd (const std::string &group, const char message, std::size_t messageLength, const SubProtocol excludedClient)

void	sendBroadcastEnd (const std::string &group, const std::string &message, const SubProtocol *excludedClient)

void	forEachClient (const std::string &group, const std::function< void(const SubProtocol )> &sendToClient, const SubProtocol excludedClient)

Static Public Member Functions
static GroupsManager *	instance ()

Static Public Attributes
static GroupsManager *	groupsManager = nullptr

Private Member Functions
	~GroupsManager ()

Private Attributes
std::map< std::string, std::set< SubProtocol * > >	groups

Detailed Description

Definition at line 39 of file GroupsManager.h.

Constructor & Destructor Documentation

◆ GroupsManager() [1/2]

web::websocket::server::GroupsManager::GroupsManager ( )

default

Referenced by instance().

Here is the caller graph for this function:

◆ GroupsManager() [2/2]

web::websocket::server::GroupsManager::GroupsManager ( const GroupsManager & )

delete

◆ ~GroupsManager()

web::websocket::server::GroupsManager::~GroupsManager ( )

private

Definition at line 32 of file GroupsManager.cpp.

                                  {
        GroupsManager::groupsManager = nullptr;
    }

References groupsManager.

Member Function Documentation

◆ forEachClient()

void web::websocket::server::GroupsManager::forEachClient	(	const std::string &	group,
		const std::function< void(const SubProtocol *)> &	sendToClient,
		const SubProtocol *	excludedClient )

Definition at line 145 of file GroupsManager.cpp.

                                                                         {
        if (groups.contains(group)) {
            for (const SubProtocol* client : groups[group]) {
                if (client != excludedClient) {
                    sendToClient(client);
                }
            }
        }
    }

◆ instance()

GroupsManager * web::websocket::server::GroupsManager::instance ( )

static

Definition at line 36 of file GroupsManager.cpp.

                                           {
        return GroupsManager::groupsManager == nullptr ? GroupsManager::groupsManager = new GroupsManager() : GroupsManager::groupsManager;
    }

References GroupsManager(), and groupsManager.

Here is the call graph for this function:

◆ operator=()

GroupsManager & web::websocket::server::GroupsManager::operator= ( const GroupsManager & )

delete

◆ sendBroadcast() [1/2]

void web::websocket::server::GroupsManager::sendBroadcast	(	const std::string &	group,
		const char *	message,
		std::size_t	messageLength,
		const SubProtocol *	excludedClient )

Definition at line 71 of file GroupsManager.cpp.

                                                                         {
        if (groups.contains(group)) {
            for (const SubProtocol* client : groups[group]) {
                if (client != excludedClient) {
                    client->sendMessage(message, messageLength);
                }
            }
        }
    }

◆ sendBroadcast() [2/2]

void web::websocket::server::GroupsManager::sendBroadcast	(	const std::string &	group,
		const std::string &	message,
		const SubProtocol *	excludedClient )

Definition at line 84 of file GroupsManager.cpp.

                                                                                                                         {
        if (groups.contains(group)) {
            for (const SubProtocol* client : groups[group]) {
                if (client != excludedClient) {
                    client->sendMessage(message);
                }
            }
        }
    }

◆ sendBroadcastEnd() [1/2]

void web::websocket::server::GroupsManager::sendBroadcastEnd	(	const std::string &	group,
		const char *	message,
		std::size_t	messageLength,
		const SubProtocol *	excludedClient )

Definition at line 128 of file GroupsManager.cpp.

                                                                            {
        if (groups.contains(group)) {
            for (const SubProtocol* client : groups[group]) {
                if (client != excludedClient) {
                    client->sendMessageEnd(message, messageLength);
                }
            }
        }
    }

◆ sendBroadcastEnd() [2/2]

void web::websocket::server::GroupsManager::sendBroadcastEnd	(	const std::string &	group,
		const std::string &	message,
		const SubProtocol *	excludedClient )

Definition at line 141 of file GroupsManager.cpp.

                                                                                                                            {
        sendBroadcastEnd(group, message.data(), message.length(), excludedClient);
    }

◆ sendBroadcastFrame() [1/2]

void web::websocket::server::GroupsManager::sendBroadcastFrame	(	const std::string &	group,
		const char *	message,
		std::size_t	messageLength,
		const SubProtocol *	excludedClient )

Definition at line 111 of file GroupsManager.cpp.

                                                                              {
        if (groups.contains(group)) {
            for (const SubProtocol* client : groups[group]) {
                if (client != excludedClient) {
                    client->sendMessageFrame(message, messageLength);
                }
            }
        }
    }

◆ sendBroadcastFrame() [2/2]

void web::websocket::server::GroupsManager::sendBroadcastFrame	(	const std::string &	group,
		const std::string &	message,
		const SubProtocol *	excludedClient )

Definition at line 124 of file GroupsManager.cpp.

                                                                                                                              {
        sendBroadcastFrame(group, message.data(), message.length(), excludedClient);
    }

◆ sendBroadcastStart() [1/2]

void web::websocket::server::GroupsManager::sendBroadcastStart	(	const std::string &	group,
		const char *	message,
		std::size_t	messageLength,
		const SubProtocol *	excludedClient )

Definition at line 94 of file GroupsManager.cpp.

                                                                              {
        if (groups.contains(group)) {
            for (const SubProtocol* client : groups[group]) {
                if (client != excludedClient) {
                    client->sendMessageStart(message, messageLength);
                }
            }
        }
    }

◆ sendBroadcastStart() [2/2]

void web::websocket::server::GroupsManager::sendBroadcastStart	(	const std::string &	group,
		const std::string &	message,
		const SubProtocol *	excludedClient )

Definition at line 107 of file GroupsManager.cpp.

                                                                                                                              {
        sendBroadcastStart(group, message.data(), message.length(), excludedClient);
    }

◆ subscribe()

void web::websocket::server::GroupsManager::subscribe	(	SubProtocol *	subProtocol,
		std::string	group = "" )

Definition at line 40 of file GroupsManager.cpp.

                                                                           {
        if (group.empty()) {
            group = subProtocol->getName();
        }
 
        if (subProtocol->group != group) {
            const std::string newChannel = subProtocol->getName() + "/" + group;
 
            groups[newChannel].insert(subProtocol);
 
            if (!subProtocol->group.empty()) {
                unsubscribe(subProtocol);
            }
 
            subProtocol->group = newChannel;
        }
    }

References web::websocket::server::SubProtocol::group, and unsubscribe().

Here is the call graph for this function:

◆ unsubscribe()

void web::websocket::server::GroupsManager::unsubscribe ( SubProtocol * subProtocol )

Definition at line 58 of file GroupsManager.cpp.

                                                            {
        if (groups.contains(subProtocol->group)) {
            groups[subProtocol->group].erase(subProtocol);
 
            if (groups[subProtocol->group].empty()) {
                groups.erase(subProtocol->group);
                if (groups.empty()) {
                    delete this;
                }
            }
        }
    }

Referenced by subscribe().

Here is the caller graph for this function:

Member Data Documentation

◆ groups

std::map<std::string, std::set<SubProtocol*> > web::websocket::server::GroupsManager::groups

private

Definition at line 76 of file GroupsManager.h.

◆ groupsManager

GroupsManager * web::websocket::server::GroupsManager::groupsManager = nullptr