Struct ResponseRouter 

pub struct ResponseRouter<T: JsonRpcResponse = Value, P: Protocol = Raw> { /* private fields */ }

Context for handling an incoming JSON-RPC response.

This is the response-side counterpart to Responder. While Responder handles incoming requests (where you send a response over the wire), ResponseRouter handles incoming responses (where you route the response to a local task waiting for it).

Both are fundamentally “sinks” that push the message through a send_fn, but they represent different points in the message lifecycle and carry different metadata.

Drop Behavior

Dropping a ResponseRouter without routing the response (for example, from a dispatch handler that claims a Dispatch::Response) discards the response: the local awaiter observes the response as never received. The request still counts as settled: routing a response this far disarms the originating SentRequest’s drop-time auto-cancellation even if the router is never invoked, since the peer has already answered.

P is the Protocol marker that types id; see Responder.

Implementations

impl<P: Protocol> ResponseRouter<Value, P>

pub fn cast<T: JsonRpcResponse>(self) -> ResponseRouter<T, P>

Cast this response context to a different response type.

The provided type T will be serialized to JSON before sending.

impl<T: JsonRpcResponse, P: Protocol> ResponseRouter<T, P>

pub fn method(&self) -> &str

Method of the original request

pub fn id(&self) -> &P::RequestId

ID of the original request, as this router’s protocol version types it.

pub fn raw_id(&self) -> &RawJsonRpcId

ID of the original request exactly as it was sent on the wire.

This is the same ID as id, in the version-neutral form used by routers, forwarders and tracing.

pub fn role_id(&self) -> RoleId

The peer to which the original request was sent.

This is the peer from which we expect to receive the response.

pub fn erase_to_json(self) -> ResponseRouter<Value, P>

Convert to a ResponseRouter that expects a JSON value and which checks (dynamically) that the JSON value it receives can be converted to T.

pub fn into_raw(self) -> ResponseRouter<T, Raw>

The same router with a version-neutral Raw request ID. This never fails.

pub fn route_with_result(self, response: Result<T, Error>) -> Result<(), Error>

Route the response result to the waiting task.

pub fn route(self, response: T) -> Result<(), Error>

Route a successful response value to the waiting task.

pub fn route_with_internal_error( self, message: impl ToString, ) -> Result<(), Error>

Route an internal error to the waiting task.

pub fn route_with_error(self, error: Error) -> Result<(), Error>

Route an error response to the waiting task.

impl<T: JsonRpcResponse> ResponseRouter<T, Raw>

pub fn into_protocol<Q: Protocol>(self) -> Result<ResponseRouter<T, Q>, Error>

Convert this version-neutral router to protocol Q’s router.

Only the request ID’s type changes. The SDK never assigns null to requests it sends, so this succeeds for every marker.

Trait Implementations

impl<T: JsonRpcResponse, P: Protocol> Debug for ResponseRouter<T, P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.