class SynchronousInterfacePtr

Creates an unbound |SynchronousInterfacePtr|.

Bind the |SynchronousInterfacePtr| 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

|SynchronousInterfacePtr|. However, methods that have replies will block

until the remote implementation binds the |InterfaceRequest| and replies.

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

TableSyncPtr table;

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

The client can call methods on |table| immediately. Messages that have

replies will block until the Database implementation binds a Table

implementation and replies.

Binds the |SynchronousInterfacePtr| to the given |channel|.

The |SynchronousInterfacePtr| 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 |SynchronousInterfacePtr| was prevously bound to another channel,

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

effectively unbind the |SynchronousInterfacePtr|. A more direct way to have

that effect is to call |Unbind|.

Does not require the current thread to have a default async_dispatcher_t.

Binds the |SynchronousInterfacePtr| to the given |InterfaceHandle|.

The |SynchronousInterfacePtr| 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 |SynchronousInterfacePtr| was prevously bound to another channel,

that channel is closed. If the |InterfaceHandle| is invalid, then this

method will effectively unbind the |SynchronousInterfacePtr|. A more direct

way to have that effect is to call |Unbind|.

Does not require the current thread to have a default async_dispatcher_t.

Unbinds the underlying channel from the |SynchronousInterfacePtr|.

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

to transport to another thread or process.

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

calling any additional |Interface| methods.

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

If the |SynchronousInterfacePtr| is bound to a channel, calls to

|Interface| methods are proxied to the remote endpoint of the channel.

See also:

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

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

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

See |is_bound| for details.

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

When this |SynchronousInterfacePtr| is bound, method calls on this

|Interface| will be proxied to the remote endpoint of the connection.

Methods that expect replies will block until the

|SynchronousInterfacePtr| either receives a reply to that transaction.

When this |SynchronousInterfacePtr| is not bound, this method returns

nullptr.

The returned |Interface| is thread-compatible and can be used from any

thread.

The underlying channel, or null channel if not currently bound.