Library: Foundation
Package: Threading
Header: Poco/ActiveMethod.h
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 Functions: operator, operator =, swap
typedef ActiveResult < ResultType > ActiveResultType;
typedef ActiveRunnable < ResultType, ArgType, OwnerType > ActiveRunnableType;
typedef ResultType (OwnerType::* Callback)(const ArgType &);
 
 ActiveMethod(
    const ActiveMethod & other
);
 
 ActiveMethod(
    OwnerType * pOwner,
    Callback method
);
Creates an ActiveMethod object.
 
 ActiveResultType operator () (
    const ArgType & arg
);
Invokes the ActiveMethod.
 
 ActiveMethod & operator = (
    const ActiveMethod & other
);
 
 void swap(
    ActiveMethod & other
);