Enum Piece 

pub enum Piece<'a> {
    Terminal(&'a [u8]),
    Partial(&'a [u8]),
    End,
}

A Split read result (from Split::next_piece).

Variants

Terminal(&'a [u8])

A terminal piece, i.e. past it is either the separator or EOF.

It may be the entire separated part, but it may also just be a piece of it if the previous iteration gave a Partial.

Partial(&'a [u8])

The part seems¹ too big to fit in the buffer, one of the future reads will terminate or End¹ it.

You can examine it and decide if you want to ignore it by skipping to after the next Terminal, or keep it by allocating a Vec for it or the like.

¹ It’s possible that the next read will find the separator or EOF immediately, in which case we’d want to yield Terminal, but we couldn’t determine that before reading again. When we find the separator, the next piece will be a Terminal of an empty slice. When we find EOF, the next piece will be End.

E.g. terminal past read:

let mut s = Split::<3,_>::bytes_lines(b"aaa\n");
assert_eq!(s.next_piece()?, Piece::Partial(b"aaa".as_ref()));
assert_eq!(s.next_piece()?, Piece::Terminal(b"".as_ref()));
assert_eq!(s.next_piece()?, Piece::End);

E.g. EOF past read:

let mut s = Split::<3,_>::bytes_lines(b"aaa");
assert_eq!(s.next_piece()?, Piece::Partial(b"aaa".as_ref()));
assert_eq!(s.next_piece()?, Piece::End);

End

End of file.

Trait Implementations

impl<'a> Clone for Piece<'a>

fn clone(&self) -> Piece<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Piece<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for Piece<'a>

fn default() -> Piece<'a>

Returns the “default value” for a type.

impl<'a> Hash for Piece<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for Piece<'a>

fn cmp(&self, other: &Piece<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for Piece<'a>

fn eq(&self, other: &Piece<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for Piece<'a>

fn partial_cmp(&self, other: &Piece<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Copy for Piece<'a>

impl<'a> Eq for Piece<'a>

impl<'a> StructuralPartialEq for Piece<'a>