gf::MessageManager Class Reference

A message manager. More...

#include <gf/MessageManager.h>

Public Member Functions
	MessageManager ()
	Constructor. More...
Registering an handler
MessageHandlerId	registerHandler (Id type, MessageHandler handler)
	Register a message handler for a type of message. More...
template<typename E >
MessageHandlerId	registerHandler (MessageHandler handler)
	Register a message handler for a type of message. More...
template<typename R , typename T >
MessageHandlerId	registerHandler (Id type, R T::*pm, T *obj)
	Register a message handler for a type of message. More...
template<typename E , typename R , typename T >
MessageHandlerId	registerHandler (R T::*pm, T *obj)
	Register a message handler for a type of message. More...
Removing an handler
void	removeHandler (MessageHandlerId id)
	Remove a handler. More...
void	removeHandlers (Span< const MessageHandlerId > ids)
	Remove a list of handlers. More...
Sending a message
void	sendMessage (Id type, Message *message)
	Send a message. More...
template<typename E >
void	sendMessage (E *message)
	Send a message. More...

Detailed Description

A message manager.

A message manager is responsible for passing messages synchronously between game entities. It relies on a variant of the observer pattern. Some entities send messages (subclasses of gf::Message identified by their unique message type) to the message manager while some other entities listen to messages of a defined type through a message handler (gf::MessageHandler). As a consequence, there is very low coupling between entities.

Generally, you only need one message manager in a game. It is a good candidate for being a singleton (thanks to gf::Singleton).

gf::Singleton<gf::MessageManager> gMessageManager;
 
int main() {
  gf::SingletonStorage<gf::MessageManager> storageForMessageManager(gMessageManager);
 
  gMessageManager().sendMessage(&foo);
}

See also

gf::Message, gf::MessageHandler, gf::Id

Constructor & Destructor Documentation

MessageManager()

gf::MessageManager::MessageManager

(

)

Constructor.

Member Function Documentation

registerHandler() [1/4]

MessageHandlerId gf::MessageManager::registerHandler	(	Id	type,
		MessageHandler	handler
	)

Register a message handler for a type of message.

struct Foo : public gf::Message {
  static const gf::Id type = "Foo"_id;
  // other fields
};
 
gf::MessageHandler handler = ...;
 
gf::MessageManager messages;
messages.registerHandler(Foo::type, handler);

Parameters

type	The type of message
handler	The message handler

Returns

A handler id

registerHandler() [2/4]

template<typename R , typename T >

MessageHandlerId gf::MessageManager::registerHandler ( Id  type, R T::*  pm, T *  obj  )

inline

Register a message handler for a type of message.

struct Foo : public gf::Message {
  static const gf::Id type = "Foo"_id;
  // other fields
};
 
class Bar {
  gf::MessageStatus onFoo(gf::Id type, gf::Message *msg) {
    // do something useful
    return gf::MessageStatus::Keep;
  }
};
 
Bar bar;
 
gf::MessageManager messages;
messages.registerHandler(Foo::type, &Bar::onFoo, &bar);

Parameters

type	The type of message
pm	A pointer to member function that represents the handler
obj	The destination object that receives the message

Returns

A handler id

registerHandler() [3/4]

template<typename E >

MessageHandlerId gf::MessageManager::registerHandler ( MessageHandler  handler )

inline

Register a message handler for a type of message.

struct Foo : public gf::Message {
  static const gf::Id type = "Foo"_id;
  // other fields
};
 
gf::MessageHandler handler = ...;
 
gf::MessageManager messages;
messages.registerHandler<Foo>(handler);

Parameters

handler

The message handler

Returns

A handler id

registerHandler() [4/4]

template<typename E , typename R , typename T >

MessageHandlerId gf::MessageManager::registerHandler ( R T::*  pm, T *  obj  )

inline

Register a message handler for a type of message.

struct Foo : public gf::Message {
  static const gf::Id type = "Foo"_id;
  // other fields
};
 
class Bar {
  gf::MessageStatus onFoo(gf::Id type, gf::Message *msg) {
    // do something useful
    return gf::MessageStatus::Keep;
  }
};
 
Bar bar;
 
gf::MessageManager messages;
messages.registerHandler<Foo>(&Bar::onFoo, &bar);

Parameters

pm	A pointer to member function that represents the handler
obj	The destination object that receives the message

Returns

A handler id

removeHandler()

void gf::MessageManager::removeHandler

(

MessageHandlerId

id

)

Remove a handler.

Parameters

id	The handler id

removeHandlers()

void gf::MessageManager::removeHandlers ( Span< const MessageHandlerId >  ids )

inline

Remove a list of handlers.

Parameters

ids	The list of handler ids

sendMessage() [1/2]

template<typename E >

void gf::MessageManager::sendMessage ( E *  message )

inline

Send a message.

The message is sent synchronously i.e. immediately when calling the function. A consequence is that the memory for the message can be allocated on the stack because it only has to live during the function call.

struct Foo : public gf::Message {
  static const gf::Id type = "Foo"_id;
  // other fields
};
 
Foo foo;
 
gf::MessageManager messages;
messages.sendMessage(&foo);

Parameters

message

A pointer to the message

sendMessage() [2/2]

void gf::MessageManager::sendMessage	(	Id	type,
		Message *	message
	)

Send a message.

The message is sent synchronously i.e. immediately when calling the function. A consequence is that the memory for the message can be allocated on the stack because it only has to live during the function call.

struct Foo : public gf::Message {
  static const gf::Id type = "Foo"_id;
  // other fields
};
 
Foo foo;
 
gf::MessageManager messages;
messages.sendMessage(Foo::type, &foo);

Parameters

type	The message type
message	A pointer to the message