Struct `Utf8Chunk`

struct Utf8Chunk<'a> { ... }

A chunk of valid UTF-8, possibly followed by invalid UTF-8 bytes.

This is yielded by the Utf8Chunks iterator, which can be created via the ByteSlice::utf8_chunks method.

The 'a lifetime parameter corresponds to the lifetime of the bytes that are being iterated over.

Implementations

`impl<'a> Utf8Chunk<'a>`

fn valid(self: &Self) -> &'a str

Returns the (possibly empty) valid UTF-8 bytes in this chunk.

This may be empty if there are consecutive sequences of invalid UTF-8 bytes.

fn invalid(self: &Self) -> &'a [u8]

Returns the (possibly empty) invalid UTF-8 bytes in this chunk that immediately follow the valid UTF-8 bytes in this chunk.

This is only empty when this chunk corresponds to the last chunk in the original bytes.

The maximum length of this slice is 3. That is, invalid UTF-8 byte sequences greater than 1 always correspond to a valid prefix of a valid UTF-8 encoded codepoint. This corresponds to the "substitution of maximal subparts" strategy that is described in more detail in the docs for the ByteSlice::to_str_lossy method.

fn incomplete(self: &Self) -> bool

Returns whether the invalid sequence might still become valid if more bytes are added.

Returns true if the end of the input was reached unexpectedly, without encountering an unexpected byte.

This can only be the case for the last chunk.

`impl<'a> Freeze for Utf8Chunk<'a>`

`impl<'a> RefUnwindSafe for Utf8Chunk<'a>`

`impl<'a> Send for Utf8Chunk<'a>`

`impl<'a> Sync for Utf8Chunk<'a>`

`impl<'a> Unpin for Utf8Chunk<'a>`

`impl<'a> UnsafeUnpin for Utf8Chunk<'a>`

`impl<'a> UnwindSafe for Utf8Chunk<'a>`

`impl<T> Any for Utf8Chunk<'a>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Utf8Chunk<'a>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Utf8Chunk<'a>`

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

`impl<T> From for Utf8Chunk<'a>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for Utf8Chunk<'a>`

fn into(self: 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 for Utf8Chunk<'a>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Utf8Chunk<'a>`

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