Trait InboundPipeline

Source

pub trait InboundPipeline<R> {
    // Required methods
    fn transport_active(&self);
    fn transport_inactive(&self);
    fn handle_read(&self, msg: R);
    fn poll_write(&self) -> Option<R>;
    fn handle_timeout(&self, now: Instant);
    fn poll_timeout(&self, eto: &mut Instant);
    fn handle_eof(&self);
    fn handle_error(&self, err: Box<dyn Error>);
}

Expand description

Pipeline traits for inbound and outbound message processing Inbound operations for a pipeline.

The InboundPipeline trait defines operations for pushing data and events into the pipeline (from the network/transport toward the application).

These methods are typically called by your I/O layer when:

Data arrives from the network
Connection state changes
Timeouts occur
Errors happen

§Type Parameters

R: The input message type (what you push into the pipeline)

§Example

use sansio::{Pipeline, InboundPipeline, Handler, Context};
use std::time::Instant;

// Simple pass-through handler for the example
struct SimpleHandler;
impl Handler for SimpleHandler {
    type Rin = Vec<u8>;
    type Rout = String;
    type Win = String;
    type Wout = Vec<u8>;
    fn name(&self) -> &str { "SimpleHandler" }
    fn handle_read(&mut self, ctx: &Context<Self::Rin, Self::Rout, Self::Win, Self::Wout>, msg: Self::Rin) {
        // Convert Vec<u8> to String
        if let Ok(s) = String::from_utf8(msg) {
            ctx.fire_handle_read(s);
        }
    }
    fn poll_write(&mut self, ctx: &Context<Self::Rin, Self::Rout, Self::Win, Self::Wout>) -> Option<Self::Wout> {
        // Convert String to Vec<u8>
        ctx.fire_poll_write().map(|s| s.into_bytes())
    }
}

let pipeline: Pipeline<Vec<u8>, String> = Pipeline::new();
pipeline.add_back(SimpleHandler);
let pipeline = pipeline.finalize();

// Push data into the pipeline
pipeline.transport_active();
pipeline.handle_read(vec![72, 101, 108, 108, 111]); // "Hello"
pipeline.handle_timeout(Instant::now());