Enum Bytes

pub enum Bytes {
    Len(usize),
    Pattern(&'static [u8]),
    PatternUntil(&'static [u8], usize),
}

Context for &u8 to determine where the slice ends.

Pattern will be included in the result

Example

use byte::*;
use byte::ctx::*;

let bytes: &[u8] = &[0xde, 0xad, 0xbe, 0xef, 0x00, 0xff];

let sub: &[u8] = bytes.read_with(&mut 0, Bytes::Len(2)).unwrap();
assert_eq!(sub, &[0xde, 0xad]);

static PATTERN: &'static [u8; 2] = &[0x00, 0xff];

let sub: &[u8] = bytes.read_with(&mut 0, Bytes::Pattern(PATTERN)).unwrap();
assert_eq!(sub, &[0xde, 0xad, 0xbe, 0xef, 0x00, 0xff]);

let sub: &[u8] = bytes.read_with(&mut 0, Bytes::PatternUntil(PATTERN, 4)).unwrap();
assert_eq!(sub, &[0xde, 0xad, 0xbe, 0xef]);

Variants

Len(usize)

Take fix-length bytes

Pattern(&'static [u8])

Take bytes until reaching a byte pattern

PatternUntil(&'static [u8], usize)

Take bytes until either byte pattern or length reached

Trait Implementations

impl Clone for Bytes

fn clone(&self) -> Bytes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Bytes

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

Formats the value using the given formatter.

impl PartialEq for Bytes

fn eq(&self, other: &Bytes) -> 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> TryRead<'a, Bytes> for &'a [u8]

fn try_read(bytes: &'a [u8], ctx: Bytes) -> Result<(Self, usize)>

Try to read from a byte slice using a specific context.

impl Copy for Bytes

impl Eq for Bytes

impl StructuralPartialEq for Bytes