Struct Wtf8Atom

pub struct Wtf8Atom { /* private fields */ }

A WTF-8 encoded atom. This is like Atom, but can contain unpaired surrogates.

Implementations

impl Wtf8Atom

pub fn new<S>(s: S) -> Self

where Self: From<S>,

Methods from Deref<Target = Wtf8>

pub fn len(&self) -> usize

Return the length, in WTF-8 bytes.

pub fn is_empty(&self) -> bool

Return true if the string has a length of zero bytes.

pub fn slice(&self, begin: usize, end: usize) -> &Wtf8

Return a slice of the given string for the byte range [begin..end).

Failure

Fails when begin and end do not point to code point boundaries, or point beyond the end of the string.

pub fn slice_from(&self, begin: usize) -> &Wtf8

Return a slice of the given string from byte begin to its end.

Failure

Fails when begin is not at a code point boundary, or is beyond the end of the string.

pub fn slice_to(&self, end: usize) -> &Wtf8

Return a slice of the given string from its beginning to byte end.

Failure

Fails when end is not at a code point boundary, or is beyond the end of the string.

pub fn ascii_byte_at(&self, position: usize) -> u8

Return the code point at position if it is in the ASCII range, or `b’\xFF’ otherwise.

Failure

Fails if position is beyond the end of the string.

pub fn code_points(&self) -> Wtf8CodePoints<'_>

Return an iterator for the string’s code points.

pub fn as_str(&self) -> Option<&str>

Try to convert the string to UTF-8 and return a &str slice.

Return None if the string contains surrogates.

This does not copy the data.

pub fn as_bytes(&self) -> &[u8]

Return the underlying WTF-8 bytes.

pub fn to_string_lossy(&self) -> Cow<'_, str>

Lossily convert the string to UTF-8. Return an UTF-8 &str slice if the contents are well-formed in UTF-8.

Surrogates are replaced with "\u{FFFD}" (the replacement character “�”).

This only copies the data if necessary (if it contains any surrogate).

pub fn to_ill_formed_utf16(&self) -> IllFormedUtf16CodeUnits<'_>

Convert the WTF-8 string to potentially ill-formed UTF-16 and return an iterator of 16-bit code units.

This is lossless: calling Wtf8Buf::from_ill_formed_utf16 on the resulting code units would always return the original WTF-8 string.

Trait Implementations

impl AsRef<Wtf8> for Wtf8Atom

fn as_ref(&self) -> &Wtf8

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Wtf8Atom

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Wtf8Atom

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

Formats the value using the given formatter.

impl Default for Wtf8Atom

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Wtf8Atom

type Target = Wtf8

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Drop for Wtf8Atom

fn drop(&mut self)

Executes the destructor for this type.

impl From<&Atom> for Wtf8Atom

fn from(s: &Atom) -> Self

Converts to this type from the input type.

impl From<&Wtf8> for Wtf8Atom

fn from(s: &Wtf8) -> Self

Converts to this type from the input type.

impl From<&str> for Wtf8Atom

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<Atom> for Wtf8Atom

fn from(s: Atom) -> Self

Converts to this type from the input type.

impl From<Box<str>> for Wtf8Atom

fn from(s: Box<str>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, str>> for Wtf8Atom

fn from(s: Cow<'_, str>) -> Self

Converts to this type from the input type.

impl From<String> for Wtf8Atom

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<Wtf8Buf> for Wtf8Atom

fn from(s: Wtf8Buf) -> Self

Converts to this type from the input type.

impl Hash for Wtf8Atom

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<&Wtf8> for Wtf8Atom

fn eq(&self, other: &&Wtf8) -> 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 PartialEq<Atom> for Wtf8Atom

fn eq(&self, other: &Atom) -> 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 PartialEq<Wtf8> for Wtf8Atom

fn eq(&self, other: &Wtf8) -> 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 PartialEq<Wtf8Atom> for Wtf8

fn eq(&self, other: &Wtf8Atom) -> 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 PartialEq for Wtf8Atom

fn eq(&self, other: &Self) -> 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 Eq for Wtf8Atom

impl Send for Wtf8Atom

Immutable, so it’s safe to be shared between threads

impl Sync for Wtf8Atom

Immutable, so it’s safe to be shared between threads