Poco

template < class ResultType, class ArgType, class OwnerType, class StarterType = ActiveStarter < OwnerType >>

class ActiveMethod

Library: Foundation
Package: Threading
Header: Poco/ActiveMethod.h

Description

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.

Member Summary

Member Functions: operator (), operator =, swap

Types

ActiveResultType

typedef ActiveResult < ResultType > ActiveResultType;

ActiveRunnableType

typedef ActiveRunnable < ResultType, ArgType, OwnerType > ActiveRunnableType;

ResultType

typedef ResultType (OwnerType::* Callback)(const ArgType &);

Constructors

ActiveMethod inline

ActiveMethod(
    const ActiveMethod & other
);

ActiveMethod inline

ActiveMethod(
    OwnerType * pOwner,
    Callback method
);

Creates an ActiveMethod object.

Member Functions

operator () inline

ActiveResultType operator () (
    const ArgType & arg
);

Invokes the ActiveMethod.

operator = inline

ActiveMethod & operator = (
    const ActiveMethod & other
);

swap inline

void swap(
    ActiveMethod & other
);