# Poco

# template < class TArgs, class TStrategy, class TDelegate >

# class AbstractEvent

Library: Foundation
Package: Events
Header: Poco/AbstractEvent.h

## Description

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. The TStrategy parameter must be a subclass of NotificationStrategy. The parameter TDelegate can either be a subclass of AbstractDelegate or of PriorityAbstractDelegate.

Note that AbstractEvent should never be used directly. One ought to use one of its subclasses which set the TStrategy and TDelegate template parameters to fixed values. For most use-cases the BasicEvent template will be sufficient:

    #include "Poco/BasicEvent.h"
    #include "Poco/Delegate.h"

If one requires delegates to be called in the order they registered, use FIFOEvent:

    #include "Poco/FIFOEvent.h"
    #include "Poco/Delegate.h"

Both FIFOEvent and BasicEvent work with a standard delegate. They allow one object to register exactly one delegate at an event. In contrast, a PriorityDelegate comes with an attached priority value and allows one object to register for one priority value one delegate. Note that PriorityDelegates only work with PriorityEvents:

    #include "Poco/PriorityEvent.h"
    #include "Poco/PriorityDelegate.h"

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

    class MyData
    {
    public:
        Poco::BasicEvent<int> AgeChanged;

        MyData();
        ...
    };

Throwing the event can be done either by the events notify() or notifyAsync() method:

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

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

Note that notify and notifyAsync 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 or FIFOEvent the Delegate template is used, in case of an PriorityEvent a PriorityDelegate is used. Mixing of observers, e.g. using a PriorityDelegate with a BasicEvent is not possible and checked for during compile time. 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 += delegate(this, &MyController::onDataChanged);
    }

In some cases it might be desirable to work with automatically expiring registrations. Simply add to delegate as 3rd parameter a expireValue (in milliseconds):

    _data.DataChanged += delegate(this, &MyController::onDataChanged, 1000);

This will add a delegate to the event which will automatically be removed in 1000 millisecs.

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 -= delegate(this, &MyController::onDataChanged);
    }

Working with PriorityDelegates as similar to working with BasicEvent/FIFOEvent.Instead of ''delegate'' simply use ''priorityDelegate''.

For further examples refer to the event testsuites.

## Member Summary

Member Functions: clear, disable, enable, executeAsyncImpl, isEnabled, notify, notifyAsync, operator, operator +=, operator -=

## Nested Classes

### struct NotifyAsyncParams

## Constructors

### AbstractEvent

AbstractEvent();

### AbstractEvent

AbstractEvent(
const TStrategy & strat
);

## Destructor

### ~AbstractEvent

virtual ~AbstractEvent();

## Member Functions

### clear

void clear();

Removes all delegates.

### disable

void disable();

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

### enable

void enable();

Enables the event

### isEnabled

bool isEnabled() const;

### notify

void notify(
const void * pSender,
TArgs & args
);

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.

### notifyAsync

ActiveResult < TArgs > notifyAsync(
const void * pSender,
const TArgs & args
);

Sends a notification to all registered delegates. The order is determined by the TStrategy. This method is not blocking and will immediately return. The delegates are invoked in a seperate thread. Call activeResult.wait() to wait until the notification has ended. While executing, other objects can change the delegate list. 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 execution is aborted and the exception is reported to the caller.

### operator

void operator () (
const void * pSender,
TArgs & args
);

### operator +=

void operator += (
const TDelegate & aDelegate
);

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, FIFOStrategy) follow that guideline but future ones can deviate.

### operator -=

void operator -= (
const TDelegate & aDelegate
);

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

### executeAsyncImpl

TArgs executeAsyncImpl(
const NotifyAsyncParams & par
);

## Variables

### _enabled

bool _enabled;

Stores if an event is enabled. Notfies on disabled events have no effect but it is possible to change the observers.

### _executeAsync

ActiveMethod < TArgs, NotifyAsyncParams, AbstractEvent > _executeAsync;

### _mutex

mutable FastMutex _mutex;

### _strategy

TStrategy _strategy;

The strategy used to notify observers.