Struct Chars

pub struct Chars<'a> { /* private fields */ }

An iterator over Unicode scalar values in a byte string.

When invalid UTF-8 byte sequences are found, they are substituted with the Unicode replacement codepoint (U+FFFD) using the "maximal subpart" strategy.

This iterator is created by the chars method provided by the ByteSlice extension trait for &[u8].

Implementations

impl<'a> Chars<'a>

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

View the underlying data as a subslice of the original data.

The slice returned has the same lifetime as the original slice, and so the iterator can continue to be used while this exists.

Examples

use bstr::ByteSlice;

let mut chars = b"abc".chars();

assert_eq!(b"abc", chars.as_bytes());
chars.next();
assert_eq!(b"bc", chars.as_bytes());
chars.next();
chars.next();
assert_eq!(b"", chars.as_bytes());

Trait Implementations

impl<'a> Clone for Chars<'a>

fn clone(&self) -> Self

impl<'a> Debug for Chars<'a>

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

impl<'a> DoubleEndedIterator for Chars<'a>

fn next_back(&mut self) -> Option<char>

impl<'a> Iterator for Chars<'a>

type Item = char;
fn next(&mut self) -> Option<char>
fn count(self) -> usize

Auto Trait Implementations

impl<'a> Freeze for Chars<'a>

impl<'a> RefUnwindSafe for Chars<'a>

impl<'a> Send for Chars<'a>

impl<'a> Sync for Chars<'a>

impl<'a> Unpin for Chars<'a>

impl<'a> UnsafeUnpin for Chars<'a>

impl<'a> UnwindSafe for Chars<'a>

Blanket Implementations

impl<I> IntoIterator for Chars<'a> where I: Iterator,

type Item = <I as Iterator>::Item;
type IntoIter = I;
fn into_iter(self) -> I

impl<T> Any for Chars<'a> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Chars<'a> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Chars<'a> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Chars<'a> where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for Chars<'a>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Chars<'a> where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for Chars<'a> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for Chars<'a> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Chars<'a> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>