Struct MessageHandler 

pub struct MessageHandler { /* private fields */ }

Handler that matches updates based on the composable Filter trait system.

This is the most general-purpose handler. It mirrors the Python MessageHandler which delegates to a BaseFilter tree. The Rust port uses crate::filters::base::F – the operator-overloaded filter wrapper – so filters compose naturally with &, |, ^, !.

When a filter returns FilterResult::MatchWithData, the extracted data is stored in MatchResult::Custom and flows through to the handler callback.

Ergonomic constructor

use rust_tg_bot_ext::prelude::*;

async fn echo(update: Update, context: Context) -> HandlerResult {
    let text = update.effective_message().and_then(|m| m.text.as_deref()).unwrap_or("");
    context.reply_text(&update, text).await?;
    Ok(())
}

MessageHandler::new(TEXT & !COMMAND, echo);

Full-control constructor

use rust_tg_bot_ext::handlers::message::MessageHandler;
use rust_tg_bot_ext::handlers::base::*;
use rust_tg_bot_ext::filters::base::F;
use rust_tg_bot_ext::filters::base::All;
use std::sync::Arc;

let handler = MessageHandler::with_options(
    Some(F::new(All)),
    Arc::new(|update, _mr| Box::pin(async move { HandlerResult::Continue })),
    true,
);

Implementations

impl MessageHandler

pub fn new<Cb, Fut>(filter: F, callback: Cb) -> MessageHandler

where Cb: Fn(Arc<Update>, CallbackContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), HandlerError>> + Send + 'static,

Ergonomic constructor matching python-telegram-bot’s MessageHandler(filters, callback).

Accepts a composable filter and an async handler function with signature async fn(Update, Context) -> HandlerResult.

Example

use rust_tg_bot_ext::prelude::*;

async fn echo(update: Update, context: Context) -> HandlerResult {
    let text = update.effective_message().and_then(|m| m.text.as_deref()).unwrap_or("");
    context.reply_text(&update, text).await?;
    Ok(())
}

MessageHandler::new(TEXT & !COMMAND, echo);

pub fn with_options( filter: Option<F>, callback: Arc<dyn Fn(Arc<Update>, MatchResult) -> Pin<Box<dyn Future<Output = HandlerResult> + Send>> + Sync + Send>, block: bool, ) -> MessageHandler

Full-control constructor for advanced use cases.

If filter is None, every Update matches (equivalent to the Python filters.ALL).

pub fn from_fn( filter: Option<Arc<dyn Fn(&Update) -> bool + Sync + Send>>, callback: Arc<dyn Fn(Arc<Update>, MatchResult) -> Pin<Box<dyn Future<Output = HandlerResult> + Send>> + Sync + Send>, block: bool, ) -> MessageHandler

Create a MessageHandler from a legacy closure filter.

This is a convenience constructor for backward compatibility with code that uses Fn(&Update) -> bool closures instead of the Filter trait.

Trait Implementations

impl Handler for MessageHandler

fn check_update(&self, update: &Update) -> Option<MatchResult>

Determine whether this handler is interested in update.

fn handle_update( &self, update: Arc<Update>, match_result: MatchResult, ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send>>

Process the update. Called only when check_update returned Some.

fn block(&self) -> bool

Whether the application should block on this handler’s future before dispatching to the next handler group.

fn handle_update_with_context( &self, update: Arc<Update>, match_result: MatchResult, context: CallbackContext, ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send>>

Process the update with an Application-provided CallbackContext.

fn collect_additional_context( &self, _context: &mut CallbackContext, _match_result: &MatchResult, )

Populate additional context fields (e.g. context.args, context.matches) from the match result before the handler callback is invoked.