Struct TypeNotification 

pub struct TypeNotification<R: Role> { /* private fields */ }

Builder for pattern-matching on untyped JSON-RPC notifications.

Similar to MatchDispatch but specifically for notifications (fire-and-forget messages with no response).

Pattern

The typical pattern is:

1. Create a TypeNotification from an untyped message
2. Chain .handle_if() calls for each type you want to try
3. End with .otherwise() for messages that don’t match any type

Example

TypeNotification::new(message, cx)
    .handle_if(|notif: SessionNotification| async move {
        // Handle session notifications
        println!("Session update: {:?}", notif);
        Ok(())
    })
    .await
    .otherwise(|untyped: UntypedMessage| async move {
        // Fallback for unrecognized notifications
        println!("Unknown notification: {}", untyped.method);
        Ok(())
    })
    .await

Since notifications don’t expect responses, handlers only receive the parsed notification (not a request context).

Implementations

impl<R: Role> TypeNotification<R>

pub fn new(request: UntypedMessage, cx: &ConnectionTo<R>) -> Self

Create a new pattern matcher for the given untyped notification message.

pub async fn handle_if<N: JsonRpcNotification>( self, op: impl AsyncFnOnce(N) -> Result<(), Error>, ) -> Self

Try to handle the message as type N.

If the message can be parsed as N, the handler op is called with the parsed notification. If parsing fails or the message was already handled by a previous handle_if, this call has no effect.

Returns self to allow chaining multiple handle_if calls.

pub async fn otherwise( self, op: impl AsyncFnOnce(UntypedMessage) -> Result<(), Error>, ) -> Result<(), Error>

Handle messages that didn’t match any previous handle_if call.

This is the fallback handler that receives the original untyped message if none of the typed handlers matched. You must call this method to complete the pattern matching chain and get the final result.

Trait Implementations

impl<R: Debug + Role> Debug for TypeNotification<R>

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

Formats the value using the given formatter.