Public Member Functions | Protected Attributes | Private Member Functions | List of all members
karto::AbstractEvent< TArgs > Class Template Reference

#include <Event.h>

Inheritance diagram for karto::AbstractEvent< TArgs >:
Inheritance graph
[legend]

Public Member Functions

 AbstractEvent ()
 
 AbstractEvent (const DefaultStrategy< TArgs > &rStrategy)
 
void Clear ()
 
void Disable ()
 
void Enable ()
 
kt_bool IsEmpty () const
 
kt_bool IsEnabled () const
 
void Notify (const void *pSender, TArgs &rArgs)
 
void operator() (const void *pSender, TArgs &args)
 
void operator+= (const AbstractDelegate< TArgs > &rDelegate)
 
void operator-= (const AbstractDelegate< TArgs > &rDelegate)
 
virtual ~AbstractEvent ()
 

Protected Attributes

kt_bool m_Enabled
 
Mutex m_Mutex
 
DefaultStrategy< TArgs > m_Strategy
 

Private Member Functions

 AbstractEvent (const AbstractEvent &rOther)
 
AbstractEventoperator= (const AbstractEvent &rOther)
 

Detailed Description

template<class TArgs>
class karto::AbstractEvent< TArgs >

////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////

/** An AbstractEvent is the super-class of all events. It works similar to the way C# handles notifications (aka events in C#). Events can be used to send information to a set of observers which are registered at the event. The type of the data is specified with the template parameter TArgs.

#include <Karto/Event.h>

Use events by adding them as public members to the object which is throwing notifications:

class MyData
{
public:
MyData();
...
};

Throwing the event can be done either by the events Notify() method:

Alternatively, instead of Notify(), operator() can be used.

void MyData::setAge(int i)
{
this->_age = i;
AgeChanged(this, this->_age);
}

Note that Notify() do not catch exceptions, i.e. in case a delegate throws an exception, the notify is immediately aborted and the exception is thrown back to the caller.

Delegates can register methods at the event. In the case of a BasicEvent the Delegate template is used.

Events require the observers to follow one of the following method signature:

void OnEvent(const void* pSender, TArgs& args);
void OnEvent(TArgs& args);
static void OnEvent(const void* pSender, TArgs& args);
static void OnEvent(void* pSender, TArgs& args);
static void OnEvent(TArgs& args);

For performance reasons arguments are always sent by reference. This also allows observers to modify the sent argument. To prevent that, use <const TArg> as template parameter. A non-conformant method signature leads to compile errors.

Assuming that the observer meets the method signature requirement, it can register this method with the += operator:

class MyController
{
protected:
MyData _data;
void onDataChanged(void* pSender, int& data);
...
};
MyController::MyController()
{
_data.AgeChanged += karto::delegate(this, &MyController::onDataChanged);
}

Unregistering happens via the -= operator. Forgetting to unregister a method will lead to segmentation faults later, when one tries to send a notify to a no longer existing object.

MyController::~MyController()
{
_data.DataChanged -= karto::delegate(this, &MyController::onDataChanged);
}

Definition at line 806 of file Event.h.

Constructor & Destructor Documentation

template<class TArgs>
karto::AbstractEvent< TArgs >::AbstractEvent ( )
inline

Default constructor

Definition at line 812 of file Event.h.

template<class TArgs>
karto::AbstractEvent< TArgs >::AbstractEvent ( const DefaultStrategy< TArgs > &  rStrategy)
inline

Constructs an event with a default strategy

Parameters
rStrategy

Definition at line 821 of file Event.h.

template<class TArgs>
virtual karto::AbstractEvent< TArgs >::~AbstractEvent ( )
inlinevirtual

Destructor

Definition at line 830 of file Event.h.

template<class TArgs>
karto::AbstractEvent< TArgs >::AbstractEvent ( const AbstractEvent< TArgs > &  rOther)
private

Member Function Documentation

template<class TArgs>
void karto::AbstractEvent< TArgs >::Clear ( )
inline

Removes all delegates.

Definition at line 935 of file Event.h.

template<class TArgs>
void karto::AbstractEvent< TArgs >::Disable ( )
inline

Disables the event. Notify will be ignored, but adding/removing delegates is still allowed.

Definition at line 917 of file Event.h.

template<class TArgs>
void karto::AbstractEvent< TArgs >::Enable ( )
inline

Enables the event.

Definition at line 907 of file Event.h.

template<class TArgs>
kt_bool karto::AbstractEvent< TArgs >::IsEmpty ( ) const
inline

Checks if any delegates are registered at the delegate.

Definition at line 944 of file Event.h.

template<class TArgs>
kt_bool karto::AbstractEvent< TArgs >::IsEnabled ( ) const
inline

Checks if we are enabled

Definition at line 926 of file Event.h.

template<class TArgs>
void karto::AbstractEvent< TArgs >::Notify ( const void *  pSender,
TArgs &  rArgs 
)
inline

Sends a notification to all registered delegates. The order is determined by the TStrategy. This method is blocking. While executing, other objects can change the list of delegates. These changes don't influence the current active notifications but are activated with the next notify. If one of the delegates throws an exception, the notify method is immediately aborted and the exception is reported to the caller.

Parameters
pSender
rArgs

Definition at line 879 of file Event.h.

template<class TArgs>
void karto::AbstractEvent< TArgs >::operator() ( const void *  pSender,
TArgs &  args 
)
inline

Same as Notify

Definition at line 864 of file Event.h.

template<class TArgs>
void karto::AbstractEvent< TArgs >::operator+= ( const AbstractDelegate< TArgs > &  rDelegate)
inline

Adds a delegate to the event. If the observer is equal to an already existing one (determined by the < operator), it will simply replace the existing observer. This behavior is determined by the TStrategy. Current implementations (DefaultStrategy) follow that guideline but future ones can deviate.

Parameters
rDelegate

Definition at line 843 of file Event.h.

template<class TArgs>
void karto::AbstractEvent< TArgs >::operator-= ( const AbstractDelegate< TArgs > &  rDelegate)
inline

Removes a delegate from the event. If the delegate is equal to an already existing one is determined by the < operator. If the observer is not found, the unregister will be ignored

Parameters
rDelegate

Definition at line 855 of file Event.h.

template<class TArgs>
AbstractEvent& karto::AbstractEvent< TArgs >::operator= ( const AbstractEvent< TArgs > &  rOther)
private

Member Data Documentation

template<class TArgs>
kt_bool karto::AbstractEvent< TArgs >::m_Enabled
protected

Enabled flag

Definition at line 954 of file Event.h.

template<class TArgs>
Mutex karto::AbstractEvent< TArgs >::m_Mutex
mutableprotected

Mutex

Definition at line 964 of file Event.h.

template<class TArgs>
DefaultStrategy<TArgs> karto::AbstractEvent< TArgs >::m_Strategy
protected

Strategy

Definition at line 959 of file Event.h.


The documentation for this class was generated from the following file:


nav2d_karto
Author(s): Sebastian Kasperski
autogenerated on Thu Jun 6 2019 19:20:25