Struct tokio_file_unix::DelimCodec

pub struct DelimCodec<D>(pub D);

A Codec that splits the stream into frames divided by a given delimiter byte. All frames except possibly the last one contain the delimiter byte as the last element (this behavior differs from tokio_io::io::lines).

impl Codec for DelimCodec<u8>;
impl Codec for DelimCodec<Newline>;
impl Codec for DelimCodec<impl Into<u8> + Clone>;

Example: read stdin line by line

extern crate futures;
extern crate tokio_core;
extern crate tokio_io;
extern crate tokio_file_unix;

use futures::Stream;
use tokio_io::{io, AsyncRead, AsyncWrite};
use tokio_io::codec::FramedRead;
use tokio_file_unix::{File, StdFile, DelimCodec, Newline};

// initialize the event loop
let mut core = tokio_core::reactor::Core::new()?;
let handle = core.handle();

// get the standard input as a file
let stdin = std::io::stdin();
let io = File::new_nb(StdFile(stdin.lock()))?.into_io(&handle)?;

// turn it into a stream of lines, decoded as UTF-8
let line_stream = FramedRead::new(io, DelimCodec(Newline)).and_then(|line| {
    String::from_utf8(line).map_err(|_| {
        std::io::Error::from(std::io::ErrorKind::InvalidData)
    })
});

// turn it into a stream of lines and process them
let future = line_stream.for_each(|line| {
    println!("Got: {}", line);
    Ok(())
});

// start the event loop
core.run(future)?;

Trait Implementations

impl<D: Debug> Debug for DelimCodec<D>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<D: Clone> Clone for DelimCodec<D>

fn clone(&self) -> DelimCodec<D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Copy> Copy for DelimCodec<D>

impl<D: Into<u8> + Clone> Decoder for DelimCodec<D>

type Item = Vec<u8>

The type of decoded frames.

type Error = Error

The type of unrecoverable frame decoding errors.

fn decode(
    &mut self,
    buf: &mut BytesMut
) -> Result<Option<Self::Item>, Self::Error>

Attempts to decode a frame from the provided buffer of bytes.

fn decode_eof(
    &mut self,
    buf: &mut BytesMut
) -> Result<Option<Self::Item>, Self::Error>

A default method available to be called when there are no more bytes available to be read from the underlying I/O.

impl<D: Into<u8> + Clone> Encoder for DelimCodec<D>

type Item = Vec<u8>

The type of items consumed by the Encoder

type Error = Error

The type of encoding errors.

fn encode(
    &mut self,
    msg: Self::Item,
    buf: &mut BytesMut
) -> Result<(), Self::Error>

Encodes a frame into the buffer provided.