class SyncProxy

|SyncProxy| is an ergonomic wrapper over |TestDispatcherBound| that simplifies

the |SyncCall| syntax into direct function calls:

auto r = sync_proxy.Foo(arg);

is equivalent to

auto r = test_dispatcher_bound.SyncCall(

&T

::Foo, arg);

To use it, suppose there's a |Background| class with two methods |Foo|, |Bar|.

We will choose |BackgroundSyncProxy| as the name of the sync proxy class.

First tell the library about those methods using this macro:

ASYNC_PATTERNS_DEFINE_SYNC_METHOD(BackgroundSyncProxy, Foo);

ASYNC_PATTERNS_DEFINE_SYNC_METHOD(BackgroundSyncProxy, Bar);

Then define |BackgroundSyncProxy| as the following type alias:

using BackgroundSyncProxy = async_patterns::SyncProxy

<

Background,

ASYNC_PATTERNS_ADD_SYNC_METHOD(BackgroundSyncProxy, Background, Foo),

ASYNC_PATTERNS_ADD_SYNC_METHOD(BackgroundSyncProxy, Background, Bar)

>;

After that, you may use |BackgroundSyncProxy| like so:

// The sync proxy supports the same construction API as |TestDispatcherBound|.

BackgroundSyncProxy background(dispatcher);

background.emplace(constructor_args);

// But instead of |SyncCall|, you can directly call |Foo| and |Bar|.

auto return_value = background.Foo(...);

auto return_value = background.Bar(...);

|SyncProxy| methods cannot be overloaded, or templated. If one of your member functions

uses those features, you may call it through dispatcher bound:

background

.dispatcher_bound()

.SyncCall

<void

(int, int)>(

&Background

::OverloadedFunction, 1, 2);