class InterfacePtr

Creates an unbound |InterfacePtr|.

Bind the |InterfacePtr| to one endpoint of a newly created channel and

return the other endpoint as an |InterfaceRequest|.

Typically, the returned |InterfaceRequest| will be sent to a remote process

to be bound to an implementation of |Interface| using a |Binding| object.

After calling this method, clients can start calling methods on this

|InterfacePtr|. The methods will write messages into the underlying

channel created by |NewRequest|, where they will be buffered by the

underlying channel until the |InterfaceRequest| is bound to an

implementation of |Interface|, potentially in a remote process.

Uses the given async_dispatcher_t in order to read messages from the

channel and to monitor the channel for |ZX_CHANNEL_PEER_CLOSED|. If

|dispatcher| is null, the current thread must have a default

async_dispatcher_t.

# Example

Given the following interface:

interface Database {

OpenTable(request

<Table

> table);

};

The client can use the |NewRequest| method to create the |InterfaceRequest|

object needed by the |OpenTable| method:

DatabasePtr database = ...; // Connect to database.

TablePtr table;

database->OpenTable(table.NewRequest());

The client can call methods on |table| immediately.

Binds the |InterfacePtr| to the given |channel|.

The |InterfacePtr| expects the remote end of the |channel| to speak the

protocol defined by |Interface|. Unlike the |Bind| overload that takes a

|InterfaceHandle| parameter, this |Bind| overload lacks type safety.

If the |InterfacePtr| was prevously bound to another channel, that channel

is closed. If the |channel| is invalid, then this method will effectively

unbind the |InterfacePtr|. A more direct way to have that effect is to call

|Unbind|.

Uses the given async_dispatcher_t in order to read messages from the

channel and to monitor the channel for |ZX_CHANNEL_PEER_CLOSED|. If

|dispatcher| is null, the current thread must have a default

async_dispatcher_t.

Returns an error if the binding was not able to be created (e.g., because

the |channel| lacks |ZX_RIGHT_WAIT|).

Binds the |InterfacePtr| to the given |InterfaceHandle|.

The |InterfacePtr| expects the remote end of the |channel| to speak the

protocol defined by |Interface|. Unlike the |Bind| overload that takes a

|channel| parameter, this |Bind| overload provides type safety.

If the |InterfacePtr| was prevously bound to another channel, that channel

is closed. If the |InterfaceHandle| is invalid, then this method will

effectively unbind the |InterfacePtr|. A more direct way to have that

effect is to call |Unbind|.

Uses the given async_dispatcher_t in order to read messages from the

channel and to monitor the channel for |ZX_CHANNEL_PEER_CLOSED|. If

|dispatcher| is null, the current thread must have a default

async_dispatcher_t.

Returns an error if the binding was not able to be created (e.g., because

the |channel| lacks |ZX_RIGHT_WAIT|).

Unbinds the underlying channel from the |InterfacePtr|.

The underlying channel is returned as an |InterfaceHandle|, which is safe

to transport to another thread or process. Any callbacks waiting for

replies from the remote endpoint are discarded and any outstanding

transaction state is erased.

After this method returns, a subsequent call to |Bind| is required before

calling any additional |Interface| methods.

Whether this |InterfacePtr| is currently bound to a channel.

If the |InterfacePtr| is bound to a channel, the |InterfacePtr| has

affinity for the thread to which it was bound and calls to |Interface|

methods are proxied to the remote endpoint of the channel.

See also:

* |Bind|, which binds a channel to this |InterfacePtr|.

* |Unbind|, which unbinds a channel from this |InterfacePtr|.

Whether this |InterfacePtr| is currently bound to a channel.

See |is_bound| for details.

The |Interface| proxy associated with this |InterfacePtr|.

When this |InterfacePtr| is bound, method calls on this |Interface| will

be proxied to the remote endpoint of the connection. Methods that expect

replies will retain the supplied callbacks until the |InterfacePtr| either

receives a reply to that transaction or the |InterfacePtr| is unbound from

the channel.

When this |InterfacePtr| is not bound, calling methods on the returned

|Interface| simply discards the arguments and closes any handles contained

in those arguments.

The returned |Interface| is thread-hostile and can be used only on the

thread to which the |InterfacePtr| was bound.

An object on which to register for FIDL events.

Arriving events are dispatched to the callbacks stored on this object.

Events for unbound callbacks are ignored.

Sets an error handler that will be called if an error causes the underlying

channel to be closed.

If the error is being reported because an error occurred on the local side

of the channel, the zx_status_t of that error will be passed as the

parameter to the handler.

If an Epitaph was present on the channel, its error value will be passed as

the parameter. See the FIDL language specification for more detail on

Epitaphs.

For example, the error handler will be called if the remote side of the

channel sends an invalid message. When the error handler is called, the

|Binding| will no longer be bound to the channel.

WARNING: The |error_handler| is often called from the thread to which the

|InterfacePtr| was bound, but the function can also be called from another

thread if the |InterfacePtr| is still bound to the thread when the

|async::Loop| for the thread is shutdown.

The underlying channel.

The |async_dispatcher_t| to which this interface is bound, if any.