class SyncEndpointVeneer

Returns a veneer object for the concrete messaging implementation.

Returns a veneer object which exposes the caller-allocating API, using

the provided |resource| to allocate buffers necessary for each call.

The requests and responses (if applicable) will live on those buffers.

Examples of supported memory resources are:

* |fidl::BufferSpan|, referencing a range of bytes.

* |fidl::AnyArena

&

|, referencing an arena.

* Any type for which there is a |MakeAnyBufferAllocator| specialization.

See |AnyBufferAllocator|.

The returned object borrows from this object, hence must not outlive

the current object.

The returned object may be briefly persisted for use over multiple calls:

fidl::Arena my_arena;

auto buffered = fidl::WireCall(client_end).buffer(my_arena);

fidl::WireUnownedResult foo = buffered->FooMethod();

fidl::WireUnownedResult bar = buffered->BarMethod();

...

In this situation, those calls will all use the initially provided memory

resource (`my_arena`) to allocate their message buffers. The memory

resource won't be reset/overwritten across calls. This means it's possible

to access the result from |FooMethod| after making another |BarMethod|

call. Note that if a |BufferSpan| is provided as the memory resource,

sharing memory resource in this manner may eventually exhaust the capacity

of the buffer span since it represents a single fixed size buffer. To reuse

(overwrite) the underlying buffer across multiple calls, obtain a new

caller-allocating veneer object for each call:

fidl::BufferSpan span(some_large_buffer, size);

auto client = fidl::WireCall(client_end);

client.buffer(span)->FooMethod();

client.buffer(span)->BarMethod();