Struct lexical_util::iterator::Bytes

pub struct Bytes<'a, const FORMAT: u128> { /* private fields */ }

Slice iterator that skips characters matching a given value.

This wraps an iterator over a contiguous block of memory, and only returns values that are not equal to skip.

The format allows us to dictate the actual behavior of the iterator: in what contexts does it skip digit separators.

FORMAT is required to tell us what the digit separator is, and where the digit separators are allowed, as well tell us the radix. The radix is required to allow us to differentiate digit from non-digit characters (see DigitSeparators for a detailed explanation on why).

Implementations

impl<'a, const FORMAT: u128> Bytes<'a, FORMAT>

pub const IS_CONTIGUOUS: bool = NumberFormat::<{ FORMAT }>::DIGIT_SEPARATOR == 0

If each yielded value is adjacent in memory.

pub fn new(slc: &'a [u8]) -> Self

Create new byte object.

pub fn as_ptr(&self) -> *const u8

Get a ptr to the current start of the iterator.

pub fn as_slice(&self) -> &'a [u8]

Get a slice to the current start of the iterator.

pub fn length(&self) -> usize

Get the total number of elements in the underlying slice.

pub fn cursor(&self) -> usize

Get the current index of the iterator in the slice.

pub unsafe fn set_cursor(&mut self, index: usize)

Set the current index of the iterator in the slice.

Safety

Safe if index <= self.length().

pub fn current_count(&self) -> usize

Get the current number of values returned by the iterator.

pub fn is_done(&self) -> bool

Get if the buffer underlying the iterator is empty.

This might not be the same thing as is_consumed: is_consumed checks if any more elements may be returned, which may require peeking the next value. Consumed merely checks if the iterator has an empty slice. It is effectively a cheaper, but weaker variant of is_consumed().

pub fn is_contiguous(&self) -> bool

pub unsafe fn read_unchecked<V>(&self) -> V

Read a value of a difference type from the iterator. This advances the internal state of the iterator.

Safety

Safe as long as the number of the buffer is contains as least as many bytes as the size of V.

pub fn read<V>(&self) -> Option<V>

Try to read a value of a different type from the iterator. This advances the internal state of the iterator.

pub fn first_is(&mut self, value: u8) -> bool

Check if the next element is a given value.

pub fn case_insensitive_first_is(&mut self, value: u8) -> bool

Check if the next element is a given value without case sensitivity.

pub fn integer_iter<'b>(&'b mut self) -> IntegerBytesIterator<'a, 'b, FORMAT>

Get iterator over integer digits.

pub fn fraction_iter<'b>(&'b mut self) -> FractionBytesIterator<'a, 'b, FORMAT>

Get iterator over fraction digits.

pub fn exponent_iter<'b>(&'b mut self) -> ExponentBytesIterator<'a, 'b, FORMAT>

Get iterator over exponent digits.

pub fn special_iter<'b>(&'b mut self) -> SpecialBytesIterator<'a, 'b, FORMAT>

Get iterator over special floating point values.

pub unsafe fn step_by_unchecked(&mut self, count: usize)

Advance the byte by N elements.

Safety

As long as the iterator is at least N elements, this is safe.

pub unsafe fn step_unchecked(&mut self)

Advance the byte by 1 element.

Safety

Safe as long as the iterator is not empty.

Trait Implementations

impl<'a, const FORMAT: u128> Clone for Bytes<'a, FORMAT>

fn clone(&self) -> Bytes<'a, FORMAT>

Returns a copy of the value.

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

Performs copy-assignment from source.