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 fn new(slc: &'a [u8]) -> Self

Create new byte object.

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

Get iterator over integer digits.

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

Get iterator over fraction digits.

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

Get iterator over exponent digits.

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

Get iterator over special floating point values.

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.

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

const IS_CONTIGUOUS: bool = _

If each yielded value is adjacent in memory.

fn cursor(&self) -> usize

Get the current index of the iterator in the slice.

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

Set the current index of the iterator in the slice.

Safety

Safe if index <= self.buffer_length().

fn current_count(&self) -> usize

Get the current number of digits returned by the iterator.

For contiguous iterators, this can include the sign character, decimal point, and the exponent sign (that is, it is always the cursor). For non-contiguous iterators, this must always be the only the number of digits returned.

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

Get a slice to the full underlying contiguous buffer,

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

Advance the internal slice by N elements.

unsafe fn peek_many_unchecked<V>(&self) -> V

Read a value of a difference type from the iterator.

fn as_ptr(&self) -> *const u8

Get a ptr to the current start of the buffer.

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

Get a slice to the current start of the buffer.

fn buffer_length(&self) -> usize

Get the total number of elements in the underlying buffer.

fn is_buffer_empty(&self) -> bool

Get if no bytes are available in the buffer.

fn is_contiguous(&self) -> bool

Determine if the buffer is contiguous.

fn first(&self) -> Option<&'a u8>

Get the next value available without consuming it.

fn first_is_cased(&self, value: u8) -> bool

Check if the next element is a given value.

fn first_is_uncased(&self, value: u8) -> bool

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

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

Check if the next item in buffer is a given value with optional case sensitivity.

unsafe fn step_unchecked(&mut self)

Advance the internal slice by 1 element.

fn peek_u32(&self) -> Option<u32>

Try to read a the next four bytes as a u32.

fn peek_u64(&self) -> Option<u64>

Try to read the next eight bytes as a u64.