Struct Bytes

pub struct Bytes<'i> { /* private fields */ }

A byte slice with a movable cursor.

The cursor may be manually moved using Seek methods or by applying Patterns.

Bytes can be created from anything that implements AsRef<[u8]>:

use bparse::Bytes;

let _ = Bytes::from(b"hello");
let _ = Bytes::from("hello");
let _ = Bytes::from(&[1, 2, 3]);

Implementations

impl<'i> Bytes<'i>

pub fn parse<P: Pattern>(&mut self, pattern: P) -> Option<&'i [u8]>

Tests pattern against the bytes at the current position.

If the pattern matches, the cursor is moved, and the matching bytes are returned.

pub fn parse_while<'b, P: Pattern>( &'b mut self, pattern: P, ) -> BytesMatchIterMut<'b, 'i, P>

Returns an iterator that repeatedly tests pattern against self until it stops matching.

Advancing the iterator also advances the cursor.

pub fn parse_delimited<L, R>(&mut self, left: L, right: R) -> Option<&'i [u8]>

where L: Pattern, R: Pattern,

Extracts the byte slice delimited by the given patterns.

The cursor is set to right after the right match, and the bytes between the left and right matches are returned.

Returns None if left does not match. Returns None if no match for right is found after left

pub fn take_until<P: Pattern>(&mut self, pattern: P) -> &'i [u8]

Advances the cursor until the pattern matches or the end of the input is encountered.

The cursor is set right before the match, and the bytes leading up to the match are returned.

pub fn accept<P: Pattern>(&mut self, pattern: P) -> bool

Tests the pattern against the bytes at the current position.

If the pattern matches, the cursor is moved and the function returns true.

pub fn peek<P: Pattern>(&mut self, pattern: P) -> bool

Like Bytes::accept, but the cursor is not moved after a successful match.

pub fn position(&self) -> usize

Returns the cursor’s offset from the start of the input.

pub fn eof(&self) -> bool

Returns true if the cursor is at the end of the input.

Note that you can still use Seek methods to move the cursor back.

pub fn get_ref(&self) -> &'i [u8]

Returns a reference to the complete underlying byte slice

Trait Implementations

impl<'i> Clone for Bytes<'i>

fn clone(&self) -> Bytes<'i>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'i> Debug for Bytes<'i>

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

Formats the value using the given formatter.

impl<'i, B> From<&'i B> for Bytes<'i>

where B: ?Sized + AsRef<[u8]>,

fn from(value: &'i B) -> Self

Converts to this type from the input type.

impl<'i> PartialEq for Bytes<'i>

fn eq(&self, other: &Bytes<'i>) -> 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 Seek for Bytes<'_>

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position.

impl<'i> Copy for Bytes<'i>

impl<'i> Eq for Bytes<'i>

impl<'i> StructuralPartialEq for Bytes<'i>