class WireSharedClient

Creates an initialized |WireSharedClient| which manages the binding of the

client end of a channel to a dispatcher.

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.

|event_handler| will be destroyed when teardown completes.

Creates a |WireSharedClient| that supports custom behavior on teardown

completion via |teardown_observer|. Through helpers that return an

|AnyTeardownObserver|, users may link the completion of teardown to the

invocation of a callback or the lifecycle of related business objects. See

for example |fidl::ObserveTeardown| and |fidl::ShareUntilTeardown|.

This overload does not demand taking ownership of |event_handler| by

|std::unique_ptr|, hence is suitable when the |event_handler| needs to be

managed independently of the client lifetime.

See |WireSharedClient| above for other behavior aspects of the constructor.

Overload of |WireSharedClient| that omits the |event_handler|, to

workaround C++ limitations on default arguments.

See |WireSharedClient| above for other behavior aspects of the constructor.

Creates an uninitialized |WireSharedClient|.

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 |WireSharedClient| is initialized.

If the current |WireSharedClient| is the last instance controlling the

current connection, the destructor of this |WireSharedClient| will trigger

teardown.

When the last |WireSharedClient| destructs:

- The channel will be closed.

- Pointers obtained via |get| will be invalidated.

- Teardown will be initiated. See the **Lifecycle** section from the

class documentation of |fidl::WireClient|.

See also: |AsyncTeardown|.

|fidl::WireSharedClient|s can be safely moved without affecting any in-progress

operations. 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.

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

|WireSharedClient| to a different endpoint, simply replace the

|WireSharedClient| variable with a new instance.

When other error occurs during binding, the |event_handler->on_fidl_error|

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

|event_handler| will be destroyed when teardown completes.

Overload of |Bind| that supports custom behavior on teardown completion via

|teardown_observer|. Through helpers that return an |AnyTeardownObserver|,

users may link the completion of teardown to the invocation of a callback

or the lifecycle of related business objects. See for example

|fidl::ObserveTeardown| and |fidl::ShareUntilTeardown|.

This overload does not demand taking ownership of |event_handler| by

|std::unique_ptr|, hence is suitable when the |event_handler| needs to be

managed independently of the client lifetime.

See |Bind| above for other behavior aspects of the function.

Overload of |Bind| that omits the |event_handler|, to

workaround C++ limitations on default arguments.

See |Bind| above for other behavior aspects of the constructor.

Initiates asynchronous teardown of the bindings. See the **Lifecycle**

section from |fidl::WireSharedClient|.

|Bind| must have been called before this.

While it is safe to invoke |AsyncTeardown| from any thread, it is unsafe to

wait for teardown to complete from a dispatcher thread, as that will likely

deadlock.

Returns another |WireSharedClient| instance sharing the same channel.

Prefer to |Clone| only when necessary e.g. extending the lifetime of a

|SharedClient| to a different scope. Any clone will prevent the cleanup

of the channel while the binding is alive.

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

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

See documentation on |WireClient::buffer| for detailed behavior.

TODO(https://fxbug.dev/42172634): Consider taking |const fdf::Arena

&

| or similar.

Returns a veneer object exposing synchronous calls. Example:

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

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