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>,

pub fn try_into_atom(self) -> Result<Atom, Wtf8Atom>

Try to convert this to a UTF-8 Atom.

Returns Atom if the string is valid UTF-8, otherwise returns the original Wtf8Atom.

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 is_ascii(&self) -> bool

Return true if the string contains only ASCII characters.

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 contains_char(&self, ch: char) -> bool

Returns true if this WTF-8 string contains the given character.

pub fn contains(&self, code_point: CodePoint) -> bool

Returns true if this WTF-8 string contains the given code point.

pub fn starts_with(&self, pattern: &str) -> bool

Returns true if this WTF-8 string starts with the given UTF-8 string.

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.

pub fn to_uppercase(&self) -> Wtf8Buf

Returns the uppercase equivalent of this wtf8 slice, as a new Wtf8Buf.

pub fn to_lowercase(&self) -> Wtf8Buf

Returns the lowercase equivalent of this wtf8 slice, as a new Wtf8Buf.

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 Borrow<Wtf8Atom> for Atom

fn borrow(&self) -> &Wtf8Atom

Immutably borrows from an owned value.

impl Clone for Wtf8Atom

fn clone(&self) -> Self

Returns a copy 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<'de> Deserialize<'de> for Wtf8Atom

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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<&str> for Wtf8Atom

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

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

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