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 |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 the class documentation.

|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 the interface for making outgoing FIDL calls with managed memory

allocation. The client must be initialized first.

If the binding has been torn down, calls on the interface return error with

status |ZX_ERR_CANCELED| and reason |fidl::Reason::kUnbind|.

Persisting this pointer to a local variable is discouraged, since that

results in unsafe borrows. Always prefer making calls directly via the

|WireSharedClient| reference-counting type. A client may be cloned and

handed off through the |Clone| method.

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.

Returns a veneer object exposing synchronous calls. Example:

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

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