Struct IoManagerBuilder

pub struct IoManagerBuilder<SinkType, StreamType, BF = fn(<StreamType as Stream>::Item, &mut IoWriter<<SinkType as Sink>::SinkItem>) -> Option<<StreamType as Stream>::Item>, BEH = fn(<StreamType as Stream>::Error)>
where
    SinkType: Sink,
    StreamType: Stream,
    BF: FnMut(<StreamType as Stream>::Item, &mut IoWriter<<SinkType as Sink>::SinkItem>) -> Option<<StreamType as Stream>::Item> + Send + 'static,
    BEH: FnMut(<StreamType as Stream>::Error) + Send + 'static,
{ /* private fields */ }

A builder for IoManager, and the only way to build one since the constructors have been deleted.

Implementations

impl<SinkType, StreamType> IoManagerBuilder<SinkType, StreamType>

where SinkType: Sink + Send + 'static, StreamType: Stream + Send + 'static, <StreamType as Stream>::Item: Send + Clone + 'static, <StreamType as Stream>::Error: Send, <SinkType as Sink>::SinkItem: Send + 'static,

pub fn new( sink: SinkType, stream: StreamType, ) -> IoManagerBuilder<SinkType, StreamType, fn(<StreamType as Stream>::Item, &mut IoWriter<<SinkType as Sink>::SinkItem>) -> Option<<StreamType as Stream>::Item>, fn(<StreamType as Stream>::Error)>

Creates a builder for IoManager.

Examples found in repository

examples/tcp_server.rs (line 54)

fn process_socket(socket: TcpStream) {
    println!("New Client");
    let (sink, stream) = LineCodec.framed(socket).split();
    let trx = IoManagerBuilder::new(sink, stream)
        .with_filter(|frame, writer| {
            if frame.to_lowercase().contains("hello there") {
                writer.write("General Kenobi!".to_string());
                return None;
            }
            Some(frame)
        })
        .with_error_handler(move |error| {
            println!("{}", error);
        })
        .build();
    let mut writer = trx.get_writer();
    trx.on_receive(move |frame| {
        println!("Got frame: {}", frame);
        writer.write("Hi there".to_string());
        Ok(())
    });
}

impl<SinkType, StreamType, FilterType, ErrorHandlerType> IoManagerBuilder<SinkType, StreamType, FilterType, ErrorHandlerType>

where SinkType: Sink + Send + 'static, StreamType: Stream + Send + 'static, <StreamType as Stream>::Item: Send + Clone + 'static, <StreamType as Stream>::Error: Send, <SinkType as Sink>::SinkItem: Send + 'static, FilterType: Filter<<SinkType as Sink>::SinkItem, <StreamType as Stream>::Item>, ErrorHandlerType: ErrorHandler<<StreamType as Stream>::Error>,

pub fn with_filter<NewFilterType>( self, filter: NewFilterType, ) -> IoManagerBuilder<SinkType, StreamType, NewFilterType, ErrorHandlerType>

where NewFilterType: Filter<<SinkType as Sink>::SinkItem, <StreamType as Stream>::Item>,

Adds a filter to the IoManager builder. Filters are static in this library. If you need to be able to change the filter without droping the sink and steram passed to this instance, you should probably use Box to encapsulate your filter, and then whatever you need to make it all thread safe for when you’ll need to modify it. Type inference should still work, which is nice.

Examples found in repository

examples/tcp_server.rs (lines 55-61)

fn process_socket(socket: TcpStream) {
    println!("New Client");
    let (sink, stream) = LineCodec.framed(socket).split();
    let trx = IoManagerBuilder::new(sink, stream)
        .with_filter(|frame, writer| {
            if frame.to_lowercase().contains("hello there") {
                writer.write("General Kenobi!".to_string());
                return None;
            }
            Some(frame)
        })
        .with_error_handler(move |error| {
            println!("{}", error);
        })
        .build();
    let mut writer = trx.get_writer();
    trx.on_receive(move |frame| {
        println!("Got frame: {}", frame);
        writer.write("Hi there".to_string());
        Ok(())
    });
}

pub fn with_error_handler<NewErrorHandlerType>( self, handler: NewErrorHandlerType, ) -> IoManagerBuilder<SinkType, StreamType, FilterType, NewErrorHandlerType>

where NewErrorHandlerType: ErrorHandler<<StreamType as Stream>::Error>,

Similar to with_filter, only for error handling. Tip: if you want to be able to catch end of streams with this API, you may want your Codec to implement decode_eof() and throw an error at the last moment, such as this:

fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
    let decode = self.decode(buf);
    match decode {
        Ok(None) => Err(std::io::Error::from(std::io::ErrorKind::ConnectionAborted)),
        _ => decode,
    }
}

Examples found in repository

examples/tcp_server.rs (lines 62-64)

fn process_socket(socket: TcpStream) {
    println!("New Client");
    let (sink, stream) = LineCodec.framed(socket).split();
    let trx = IoManagerBuilder::new(sink, stream)
        .with_filter(|frame, writer| {
            if frame.to_lowercase().contains("hello there") {
                writer.write("General Kenobi!".to_string());
                return None;
            }
            Some(frame)
        })
        .with_error_handler(move |error| {
            println!("{}", error);
        })
        .build();
    let mut writer = trx.get_writer();
    trx.on_receive(move |frame| {
        println!("Got frame: {}", frame);
        writer.write("Hi there".to_string());
        Ok(())
    });
}

pub fn build(self) -> IoManager<SinkType::SinkItem, StreamType::Item>

Examples found in repository

examples/tcp_server.rs (line 65)

fn process_socket(socket: TcpStream) {
    println!("New Client");
    let (sink, stream) = LineCodec.framed(socket).split();
    let trx = IoManagerBuilder::new(sink, stream)
        .with_filter(|frame, writer| {
            if frame.to_lowercase().contains("hello there") {
                writer.write("General Kenobi!".to_string());
                return None;
            }
            Some(frame)
        })
        .with_error_handler(move |error| {
            println!("{}", error);
        })
        .build();
    let mut writer = trx.get_writer();
    trx.on_receive(move |frame| {
        println!("Got frame: {}", frame);
        writer.write("Hi there".to_string());
        Ok(())
    });
}