class WireClient

Create an initialized client which manages the binding of the client end of

a channel to a dispatcher, as if that client had been default-constructed

then later bound to that endpoint via |Bind|.

It is a logic error to use a dispatcher that is shutting down or already

shut down. Doing so will result in a panic.

If any other error occurs during initialization, the

|event_handler->on_fidl_error| handler will be invoked asynchronously with

the reason, if specified.

Create an uninitialized client. The client may then be bound to an endpoint

later via |Bind|.

Prefer using the constructor overload that binds the client to a channel

atomically during construction. Use this default constructor only when the

client must be constructed first before a channel could be obtained (for

example, if the client is an instance variable).

Returns if the |WireClient| is initialized.

The destructor of |WireClient| will initiate binding teardown.

When the client destructs:

- The channel will be closed.

- Pointers obtained via |get| will be invalidated.

- Binding teardown will happen, implying:

* In-progress calls will be forgotten. Async callbacks will be dropped.

|WireClient|s can be safely moved without affecting any in-flight FIDL

method calls. Note that calling methods on a client should be serialized

with respect to operations that consume the client, such as moving it or

destroying it.

Initializes the client by binding the |client_end| endpoint to the

dispatcher.

It is a logic error to invoke |Bind| on a dispatcher that is shutting down

or already shut down. Doing so will result in a panic.

When other errors occur during binding, the |event_handler->on_fidl_error|

handler will be asynchronously invoked with the reason, if specified.

It is not allowed to call |Bind| on an initialized client. To rebind a

|WireClient| to a different endpoint, simply replace the |WireClient|

variable with a new instance.

Returns an interface for making FIDL calls, using the provided |arena| to

allocate buffers necessary for each call. Requests will live on the arena.

Responses on the other hand live on the arena passed along with the

response, which may or may not be the same arena as the request.

## Lifecycle

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

the client object. The return object borrows the arena, hence must not

outlive the arena.

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

fdf::Arena my_arena = /* create the arena */;

fdf::WireClient client(std::move(client_end), some_dispatcher);

auto buffered = client.buffer(my_arena);

buffered->FooMethod(args).ThenExactlyOnce(foo_response_context);

buffered->BarMethod(args).ThenExactlyOnce(bar_response_context);

...

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

to allocate their message buffers.

Returns a veneer object exposing synchronous calls. Example:

fdf::WireClient client(std::move(client_end), some_dispatcher);

fdf::WireResult result = client.sync().buffer(...)->FooMethod(args);

Attempts to disassociate the client object from its endpoint and stop

monitoring it for messages. After this call, subsequent operations will

fail with an unbound error.

If there are pending two-way async calls, the endpoint is closed and this

method will fail with |fidl::Reason::kPendingTwoWayCallPreventsUnbind|. The

caller needs to arrange things such that unbinding happens after any

replies to two-way calls.

If the endpoint was already closed due to an earlier error, that error will

be returned here.

Otherwise, returns the client endpoint.