class ServerBinding

|CloseHandler| is invoked when the endpoint managed by the |ServerBinding| is closed, due to a

terminal error or because the user initiated binding teardown.

|CloseHandler| is silently discarded if |ServerBinding| is destroyed, to avoid calling into a

destroyed server implementation.

The handler may have one of these signatures:

void(fidl::UnbindInfo info);

void(Impl* impl, fidl::UnbindInfo info);

|info| contains the detailed reason for stopping message dispatch.

|impl| is the pointer to the server implementation borrowed by the binding.

The second overload allows one to bind the close handler to an instance

method on the server implementation, without capturing extra state:

class Impl : fidl::WireServer

<Protocol

> {

public:

void OnFidlClosed(fidl::UnbindInfo) { /* handle errors */ }

};

fidl::ServerBinding

<Protocol

> binding(

dispatcher, std::move(server_end), impl,

std::mem_fn(

&Impl

::OnFidlClosed));

The close handler will be invoked on a dispatcher thread, unless the user shuts down the async

dispatcher while there are active server bindings associated with it. In that case, the handler

will be synchronously invoked on the thread calling dispatcher shutdown.

In cases where the binding implementation never cares to handle any errors or be notified about

binding closure, one can pass |fidl::kIgnoreBindingClosure| as the |CloseHandler|, as follows:

fidl::ServerBinding

<Protocol

> binding(

dispatcher, std::move(server_end), impl,

fidl::kIgnoreBindingClosure);

Constructs a binding that dispatches messages from |server_end| to |impl|,

using |dispatcher|.

|Impl| should implement |fidl::Server

<FidlProtocol

>| or

|fidl::WireServer

<FidlProtocol

>|.

|impl| and any state captured in |close_handler| should outlive the bindings.

It's not safe to move |impl| while the binding is still referencing it.

|close_handler| is invoked when the endpoint managed by the |ServerBinding|

is closed, due to a terminal error or because the user initiated binding

teardown. See |CloseHandlerRequirement| for details on the error handler.

The usual usage style of |ServerBinding| puts it as a member variable of a

server object, to which it unsafely borrows. Thus it's unsafe to move the

server objects. As a precaution, we do not allow moving the bindings. If

one needs to move a server object, consider wrapping it in a

|std::unique_ptr|.

Tears down the binding and closes the connection.

After the binding destructs, it will release references on |impl|.

Destroying the binding will discard the |close_handler| without calling it.

Tears down the binding and closes the connection with an epitaph.

|close_handler| will be called with the appropriate unbind reason.

Retrieve the implementation used by this |ServerBindingRef| to process incoming messages, and

get exclusive const access to it before passing it to a lambda for further introspection.