Struct TypeHandler 

pub struct TypeHandler { /* private fields */ }

A handler that dispatches messages to other handlers based on a metadata field (e.g., “type”).

Example

use mq_bridge::type_handler::TypeHandler;
use mq_bridge::{CanonicalMessage, Handled};
use serde::Deserialize;

#[derive(Deserialize)]
struct MyCommand { id: String }

let handler = TypeHandler::new()
    .add("my_command", |cmd: MyCommand| async move {
        println!("Received command: {}", cmd.id);
        Ok(Handled::Ack)
    });

Implementations

impl TypeHandler

pub fn new() -> Self

Creates a new TypeHandler that looks for the specified key in message metadata to determine the message type.

pub fn add_handler( self, type_name: &str, handler: impl Handler + 'static, ) -> Self

Registers a generic handler for a specific type name.

pub fn with_fallback(self, handler: Arc<dyn Handler>) -> Self

Sets a fallback handler to be used when no type match is found.

pub fn add<T, H, Args>(self, type_name: &str, handler: H) -> Self

where T: DeserializeOwned + Send + Sync + 'static, H: IntoTypedHandler<T, Args>, Args: Send + Sync + 'static,

Registers a typed handler function.

The handler can accept either:

• fn(T) -> Future<Output = Result<Handled, HandlerError>>
• fn(T, MessageContext) -> Future<Output = Result<Handled, HandlerError>>

Trait Implementations

impl Clone for TypeHandler

fn clone(&self) -> TypeHandler

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for TypeHandler

fn default() -> Self

Returns the “default value” for a type.

impl Handler for TypeHandler

fn handle<'life0, 'async_trait>( &'life0 self, msg: CanonicalMessage, ) -> Pin<Box<dyn Future<Output = Result<Handled, HandlerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn register_handler( &self, type_name: &str, handler: Arc<dyn Handler>, ) -> Option<Arc<dyn Handler>>

Tries to register a handler for a specific type. Returns None if this handler does not support registration (e.g. it’s not a TypeHandler).