template class Poco::ActiveMethod

Overview

An active method is a method that, when called, executes in its own thread. More…

#include <ActiveMethod.h>

template <
    class ResultType,
    class ArgType,
    class OwnerType,
    class StarterType = ActiveStarter<OwnerType>
    >
class ActiveMethod
{
public:
    // typedefs

    typedef ResultType(OwnerType::* Callback)(const ArgType &);
    typedef ActiveResult<ResultType> ActiveResultType;
    typedef ActiveRunnable<ResultType, ArgType, OwnerType> ActiveRunnableType;

    // construction

    ActiveMethod(
        OwnerType* pOwner,
        Callback method
        );

    ActiveMethod(const ActiveMethod& other);

    // methods

    ActiveResultType
    operator()(const ArgType& arg);

    ActiveMethod&
    operator=(const ActiveMethod& other);

    void
    swap(ActiveMethod& other);
};

Detailed Documentation

An active method is a method that, when called, executes in its own thread.

ActiveMethod ‘s take exactly one argument and can return a value. To pass more than one argument to the method, use a struct. The following example shows how to add an ActiveMethod to a class:

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

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

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

And following is an example that shows how to invoke an ActiveMethod.

ActiveObject myActiveObject;
ActiveResult<std::string> result = myActiveObject.exampleActiveMethod("foo");
...
result.wait();
std::cout << result.data() << std::endl;

The way an ActiveMethod is started can be changed by passing a StarterType template argument with a corresponding class. The default ActiveStarter starts the method in its own thread, obtained from a thread pool.

For an alternative implementation of StarterType, see ActiveDispatcher.

For methods that do not require an argument or a return value, the Void class can be used.

Methods

ActiveResultType
operator()(const ArgType& arg)

Invokes the ActiveMethod.