class MessageReader

Whether the |MessageReader| is currently bound.

See |Bind()| and |Unbind()|.

The channel to which this |MessageReader| is bound, if any.

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

Binds the given channel to this |MessageReader|.

The |MessageReader| will wait asynchronously for messages on this channel

and dispatch them to the message handler using |dispatcher|. After this

method returns, the |MessageReader| will be waiting for incomming messages.

If the |MessageReader| is already bound, the |MessageReader| will first

be unbound.

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

async_dispatcher_t.

The given message handler is called whenever the |MessageReader| reads a

message from the channel.

The |Message| given to the message handler will be valid until the message

handler returns.

The handler should return ZX_OK if the message was handled and an error

otherwise. If the handler returns ZX_OK, the |MessageReader| will continue

to wait for messages.

The handler can destroy the |MessageReader|, in which case the

handler MUST return |ZX_ERR_STOP|. If the handler returns

|ZX_ERR_SHOULD_WAIT|, the |MessageReader| will continue waiting. Other

errors cause the |MessageReader| to unbind from the channel and call the

error handler.

Whether an error handler has been set.

See |set_error_handler()|.

Unbinds the channel from this |MessageReader|.

The |MessageReader| will stop waiting for the messages on this channel.

Returns the channel to which this |MessageReader| was previously bound, if

any.

Unbinds the channel from this |MessageReader| and clears the error handler.

The given error handler is called whenever the |MessageReader| encounters

an error on the channel.

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.

The handler can destroy the |MessageReader|.

Unbinds the channel from |other| and bindings it to this |MessageReader|.

Also moves the error handler from |other| to this |MessageReader|.

Useful for implementing move semantics for objects that have a

|MessageReader|.

Sends an epitaph with the given value, unbinds, and then closes the channel

associated with this |MessageReader|.

The |MessageReader| will send an Epitaph with the given error, unbind

the channel, and then close it.

The return value can be any of the return values of zx_channel_write.

Synchronously waits on |channel()| until either a message is available or

the peer closes. If the channel is readable, reads a single message from

the channel and dispatches it to the message handler.

Returns |ZX_ERR_BAD_STATE| if this |MessageReader| is not bound, or if it

receives a malformed Epitaph.