Trait whiteread::stream::FromStream

pub trait FromStream: Sized {
    const REQUEST_CHEAP_ERROR: bool;

    fn read<I: StrStream>(it: &mut I) -> Result<Self>;
}

Trait for values that can be parsed from stream of whitespace-separated words.

Implementations for primitives consume and parse one element from a stream (advancing a stream). Implementations for tuples just parse elements from left to right. Implementation for vector parses till the end of stream.

See adapters module for more types that implement this trait in a special way.

Examples

Using a trait directly

use whiteread::FromStream;
let mut stream = "123".split_whitespace();
assert_eq!(<i32 as FromStream>::read(&mut stream).unwrap(), 123)

Semantics of provided trait implementations:

// tuples (up to 6)
assert_eq!(parse_string("2 1 3 4").ok(), Some( ((2, 1), (3, 4)) ));

// optional elements at the end of stream
assert_eq!(parse_string("2 1 3").ok(), Some( ((2, 1), Some(3)) ));
assert_eq!(parse_string("2 1").ok(), Some( ((2, 1), None::<i32>) ));

// eager vector
assert_eq!(parse_string("2 1 3 4").ok(), Some( vec![2, 1, 3, 4] ));

// vec prefixed with length
assert_eq!(parse_string("2 1 3").ok(), Some( Lengthed(vec![1, 3]) ));

// placeholder
assert_eq!(parse_string("spam 3").ok(), Some( (Skip, 3) ));

// you can mix impls of course
assert_eq!(parse_string("a 1 b 2").ok(), Some( vec![('a', 1), ('b', 2)] ));

There are a few more adapter structs in adapters module, which implement the FromStream trait in various ways.

Associated Constants

const REQUEST_CHEAP_ERROR: bool

Whether a function returning this type should produce cheap errors instead of pretty-printed ones.

For user-facing errors, this should be set to false, so that user can see a nice rendered error. This is the default behaviour. If you expect the error to happen on a hot path and you don't just pass it up, this should be set to false. See WithCheapError.

Loading content...

Required methods

fn read<I: StrStream>(it: &mut I) -> Result<Self>

Reads a value from a str-producing stream.

Loading content...

Implementations on Foreign Types

impl FromStream for bool

fn read<I: StrStream>(it: &mut I) -> Result<bool>

impl FromStream for u8

fn read<I: StrStream>(it: &mut I) -> Result<u8>

impl FromStream for u16

fn read<I: StrStream>(it: &mut I) -> Result<u16>

impl FromStream for u32

fn read<I: StrStream>(it: &mut I) -> Result<u32>

impl FromStream for u64

fn read<I: StrStream>(it: &mut I) -> Result<u64>

impl FromStream for usize

fn read<I: StrStream>(it: &mut I) -> Result<usize>

impl FromStream for i8

fn read<I: StrStream>(it: &mut I) -> Result<i8>

impl FromStream for i16

fn read<I: StrStream>(it: &mut I) -> Result<i16>

impl FromStream for i32

fn read<I: StrStream>(it: &mut I) -> Result<i32>

impl FromStream for i64

fn read<I: StrStream>(it: &mut I) -> Result<i64>

impl FromStream for isize

fn read<I: StrStream>(it: &mut I) -> Result<isize>

impl FromStream for String

fn read<I: StrStream>(it: &mut I) -> Result<String>

impl FromStream for f32

fn read<I: StrStream>(it: &mut I) -> Result<f32>

impl FromStream for f64

fn read<I: StrStream>(it: &mut I) -> Result<f64>

impl FromStream for char

fn read<I: StrStream>(it: &mut I) -> Result<char>

impl FromStream for ()

fn read<I: StrStream>(_: &mut I) -> Result<Self>

impl<A: FromStream> FromStream for (A,)

fn read<I: StrStream>(it: &mut I) -> Result<Self>

impl<A: FromStream, B: FromStream> FromStream for (A, B)

fn read<I: StrStream>(it: &mut I) -> Result<Self>

impl<A: FromStream, B: FromStream, C: FromStream> FromStream for (A, B, C)

fn read<I: StrStream>(it: &mut I) -> Result<Self>

impl<A: FromStream, B: FromStream, C: FromStream, D: FromStream> FromStream for (A, B, C, D)

fn read<I: StrStream>(it: &mut I) -> Result<Self>

impl<A: FromStream, B: FromStream, C: FromStream, D: FromStream, E: FromStream> FromStream for (A, B, C, D, E)

fn read<I: StrStream>(it: &mut I) -> Result<Self>

impl<A: FromStream, B: FromStream, C: FromStream, D: FromStream, E: FromStream, F: FromStream> FromStream for (A, B, C, D, E, F)

fn read<I: StrStream>(it: &mut I) -> Result<Self>

impl<T: FromStream> FromStream for Option<T>

Option<T> is read from the stream in a similar way as T, except of returning None instead of TooShort(Nothing) error variant.

This allows for graceful handling of end-of-stream condition.

Note that partially parsed value (eg. half of a pair) is still considered an error.

fn read<I: StrStream>(it: &mut I) -> Result<Option<T>>

impl<T: FromStream> FromStream for Vec<T>

Vector of elements is read by attempting to read elements from stream until it's drained.

fn read<I: StrStream>(it: &mut I) -> Result<Vec<T>>

Loading content...

Implementors

impl FromStream for Skip

fn read<I: StrStream>(it: &mut I) -> Result<Skip>

impl FromStream for SkipAll

fn read<I: StrStream>(it: &mut I) -> Result<SkipAll>

impl<T: FromStream + Default + PartialEq> FromStream for Zeroed<T>

fn read<I: StrStream>(it: &mut I) -> Result<Zeroed<T>>

impl<T: FromStream> FromStream for Lengthed<T>

fn read<I: StrStream>(it: &mut I) -> Result<Lengthed<T>>

impl<T: FromStream> FromStream for WithCheapError<T>

fn read<I: StrStream>(it: &mut I) -> Result<WithCheapError<T>>

const REQUEST_CHEAP_ERROR: bool

Loading content...