This class is used to implement an active object with strictly serialized method execution.

An active object, which is an ordinary object containing ActiveMethod members, executes all active methods in their own thread. This behavior does not fit the "classic" definition of an active object, which serializes the execution of active methods (in other words, only one active method can be running at any given time).

Using this class as a base class, the serializing behavior for active objects can be implemented.

The following example shows how this is done:

class ActiveObject: public ActiveDispatcher
{
public:
    ActiveObject():
        exampleActiveMethod(this, &ActiveObject::exampleActiveMethodImpl)
    {
    }

    ActiveMethod<std::string, std::string, ActiveObject, ActiveStarter<ActiveDispatcher>> exampleActiveMethod;

protected:
    std::string exampleActiveMethodImpl(const std::string& arg)
    {
        ...
    }
};

The only things different from the example in ActiveMethod is that the ActiveObject in this case inherits from ActiveDispatcher, and that the ActiveMethod template for exampleActiveMethod has an additional parameter, specifying the specialized ActiveStarter for ActiveDispatcher.

Creates the ActiveDispatcher.

Creates the ActiveDispatcher and sets the priority of its thread.

Destroys the ActiveDispatcher.

Cancels all queued methods.

Adds the Runnable to the dispatch queue.

See also: Poco::Runnable::run()