Unigine::World Class

// implement the NodeRemoved event handler
void noderemoved_event_handler(const Ptr<Node> & node)
{
	Log::message("\Handling NodeRemoved event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections noderemoved_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
World::getEventNodeRemoved().connect(noderemoved_event_connections, noderemoved_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
World::getEventNodeRemoved().connect(noderemoved_event_connections, [](const Ptr<Node> & node) { 
		Log::message("\Handling NodeRemoved event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
noderemoved_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection noderemoved_event_connection;

// subscribe to the NodeRemoved event with a handler function keeping the connection
World::getEventNodeRemoved().connect(noderemoved_event_connection, noderemoved_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
noderemoved_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
noderemoved_event_connection.setEnabled(true);

// ...

// remove subscription to the NodeRemoved event via the connection
noderemoved_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A NodeRemoved event handler implemented as a class member
	void event_handler(const Ptr<Node> & node)
	{
		Log::message("\Handling NodeRemoved event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
World::getEventNodeRemoved().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId noderemoved_handler_id;

// subscribe to the NodeRemoved event with a lambda handler function and keeping connection ID
noderemoved_handler_id = World::getEventNodeRemoved().connect(e_connections, [](const Ptr<Node> & node) { 
		Log::message("\Handling NodeRemoved event (lambda).\n");
	}
);

// remove the subscription later using the ID
World::getEventNodeRemoved().disconnect(noderemoved_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all NodeRemoved events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
World::getEventNodeRemoved().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
World::getEventNodeRemoved().setEnabled(true);

// implement the NodeAdded event handler
void nodeadded_event_handler(const Ptr<Node> & node)
{
	Log::message("\Handling NodeAdded event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections nodeadded_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
World::getEventNodeAdded().connect(nodeadded_event_connections, nodeadded_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
World::getEventNodeAdded().connect(nodeadded_event_connections, [](const Ptr<Node> & node) { 
		Log::message("\Handling NodeAdded event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
nodeadded_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection nodeadded_event_connection;

// subscribe to the NodeAdded event with a handler function keeping the connection
World::getEventNodeAdded().connect(nodeadded_event_connection, nodeadded_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
nodeadded_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
nodeadded_event_connection.setEnabled(true);

// ...

// remove subscription to the NodeAdded event via the connection
nodeadded_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A NodeAdded event handler implemented as a class member
	void event_handler(const Ptr<Node> & node)
	{
		Log::message("\Handling NodeAdded event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
World::getEventNodeAdded().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId nodeadded_handler_id;

// subscribe to the NodeAdded event with a lambda handler function and keeping connection ID
nodeadded_handler_id = World::getEventNodeAdded().connect(e_connections, [](const Ptr<Node> & node) { 
		Log::message("\Handling NodeAdded event (lambda).\n");
	}
);

// remove the subscription later using the ID
World::getEventNodeAdded().disconnect(nodeadded_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all NodeAdded events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
World::getEventNodeAdded().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
World::getEventNodeAdded().setEnabled(true);

// implement the PostWorldShutdown event handler
void postworldshutdown_event_handler()
{
	Log::message("\Handling PostWorldShutdown event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections postworldshutdown_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
World::getEventPostWorldShutdown().connect(postworldshutdown_event_connections, postworldshutdown_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
World::getEventPostWorldShutdown().connect(postworldshutdown_event_connections, []() { 
		Log::message("\Handling PostWorldShutdown event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
postworldshutdown_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection postworldshutdown_event_connection;

// subscribe to the PostWorldShutdown event with a handler function keeping the connection
World::getEventPostWorldShutdown().connect(postworldshutdown_event_connection, postworldshutdown_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
postworldshutdown_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
postworldshutdown_event_connection.setEnabled(true);

// ...

// remove subscription to the PostWorldShutdown event via the connection
postworldshutdown_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A PostWorldShutdown event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling PostWorldShutdown event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
World::getEventPostWorldShutdown().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId postworldshutdown_handler_id;

// subscribe to the PostWorldShutdown event with a lambda handler function and keeping connection ID
postworldshutdown_handler_id = World::getEventPostWorldShutdown().connect(e_connections, []() { 
		Log::message("\Handling PostWorldShutdown event (lambda).\n");
	}
);

// remove the subscription later using the ID
World::getEventPostWorldShutdown().disconnect(postworldshutdown_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all PostWorldShutdown events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
World::getEventPostWorldShutdown().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
World::getEventPostWorldShutdown().setEnabled(true);