class DispatcherBound

Asynchronously constructs |T| on a task posted to |dispatcher|.

Arguments after |std::in_place| are sent to the constructor of |T|.

See |async_patterns::BindForSending| for detailed requirements on |args|.

If you'd like to pass a |dispatcher| to |T| as a constructor argument,

see |async_patterns::PassDispatcher|.

If the dispatcher is shutdown, |T| will be synchronously constructed.

Constructs a |DispatcherBound| that does not hold an instance of |T|.

One may later construct |T| using |emplace| on the |dispatcher|.

Asynchronously constructs |T| on a task posted to the dispatcher.

If this object already holds an instance of |T|, that older instance will

be asynchronously destroyed on the dispatcher.

If |T2| is specified, it must be same as |T| or a subclass. Then an instance

of |T2| will be constructed. This can be useful for mocking: |T| may be some

interface, and when constructing the object, either a fake (in unit tests)

or a real concrete type (in production) will be specified.

If you'd like to pass a |dispatcher| to |T| as a constructor argument,

see |async_patterns::PassDispatcher|.

See |async_patterns::BindForSending| for detailed requirements on |args|.

Asynchronously calls |member|, a pointer to member function of |T|, using

the provided |args|.

|AsyncCall| returns a |PendingCall| object that lets you asynchronously

monitor the result. You may either:

- Make a fire-and-forget call, by discarding the returned object, or

- Get a promise carrying the return value of the function by calling

`promise()` on the object, yielding a |fpromise::promise

<ReturnType

>|, or

- Call `Then()` on the object and pass a |Callback

<void

(ReturnType)>|.

See |PendingCall| for details.

In particular, if |member| returns void, you could attach promises/callbacks

that take void to asynchronously get notified when |member| has finished execution.

Example:

class Owner {

public:

Owner(async_dispatcher_t* owner_dispatcher) : receiver_{this, owner_dispatcher} {

background_.emplace();

// Tell |background_| to |DoSomething|, then send back the return

// value to |Owner| using |receiver_|.

background_

.AsyncCall(

&Background

::DoSomething)

.Then(receiver_.Once(

&Owner

::DoneSomething));

}

void DoneSomething(Result result) {

// |Background::DoSomething| has completed with |result|...

}

private:

async::Loop background_loop_;

async_patterns::DispatcherBound

<Background

> background_{background_loop_.dispatcher()};

async_patterns::Receiver

<Owner

> receiver_;

};

See |async_patterns::BindForSending| for detailed requirements on |args|.

If |Background::DoSomething| is an overloaded member function, you may

disambiguate it by spelling out its signature:

background_.AsyncCall

<void

(Result)>(

&Background

::DoSomething);

The task will be synchronously called if the dispatcher is shutdown.

Typically, asynchronous classes would contain internal self-pointers that

make moving dangerous, so we disable moves here for now.

If |has_value|, asynchronously destroys the managed |T| on a task

posted to the dispatcher.

If the dispatcher is shutdown, |T| will be synchronously destroyed.

If |has_value|, asynchronously destroys the managed |T| on a task

posted to the dispatcher.

If the dispatcher is shutdown, |T| will be synchronously destroyed.

Returns if this object holds an instance of |T|.