Struct encode_unicode::Utf8Char

[+] Show declaration

pub struct Utf8Char { /* fields omitted */ }

[−] Expand description

An unicode codepoint stored as UTF-8.

It can be borrowed as a str, and has the same size as char.

Implementations

impl Utf8Char[−]

pub fn from_str_start(src: &str) -> Result<(Self, usize), EmptyStrError>[−]

Create an Utf8Char from the first codepoint in a str.

Returns an error if the str is empty.

Examples

use encode_unicode::Utf8Char;

assert_eq!(Utf8Char::from_str_start("a"), Ok((Utf8Char::from('a'),1)));
assert_eq!(Utf8Char::from_str_start("ab"), Ok((Utf8Char::from('a'),1)));
assert_eq!(Utf8Char::from_str_start("🂠 "), Ok((Utf8Char::from('🂠'),4)));
assert_eq!(Utf8Char::from_str_start("é"), Ok((Utf8Char::from('e'),1)));// 'e'+u301 combining mark
assert!(Utf8Char::from_str_start("").is_err());

pub fn from_slice_start(src: &[u8]) -> Result<(Self, usize), InvalidUtf8Slice>[−]

Create an Utf8Char of the first codepoint in an UTF-8 slice.
Also returns the length of the UTF-8 sequence for the codepoint.

If the slice is from a str, use ::from_str_start() to skip UTF-8 validation.

Errors

Returns an Err if the slice is empty, doesn’t start with a valid UTF-8 sequence or is too short for the sequence.

Examples

use encode_unicode::Utf8Char;
use encode_unicode::error::InvalidUtf8Slice::*;
use encode_unicode::error::InvalidUtf8::*;

assert_eq!(Utf8Char::from_slice_start(&[b'A', b'B', b'C']), Ok((Utf8Char::from('A'),1)));
assert_eq!(Utf8Char::from_slice_start(&[0xdd, 0xbb]), Ok((Utf8Char::from('\u{77b}'),2)));

assert_eq!(Utf8Char::from_slice_start(&[]), Err(TooShort(1)));
assert_eq!(Utf8Char::from_slice_start(&[0xf0, 0x99]), Err(TooShort(4)));
assert_eq!(Utf8Char::from_slice_start(&[0xee, b'F', 0x80]), Err(Utf8(NotAContinuationByte(1))));
assert_eq!(Utf8Char::from_slice_start(&[0xee, 0x99, 0x0f]), Err(Utf8(NotAContinuationByte(2))));

pub unsafe fn from_slice_start_unchecked(src: &[u8]) -> (Self, usize)[−]

A from_slice_start() that doesn’t validate the codepoint.

Safety

The slice must be non-empty and start with a valid UTF-8 codepoint.
Invalid or incomplete values might cause reads of uninitalized memory.

pub fn from_array(utf8: [u8; 4]) -> Result<Self, InvalidUtf8Array>[−]

Create an Utf8Char from a byte array after validating it.

The codepoint must start at the first byte.
Unused bytes are set to zero by this function and so can be anything.

Errors

Returns an Err if the array doesn’t start with a valid UTF-8 sequence.

Examples

use encode_unicode::Utf8Char;
use encode_unicode::error::InvalidUtf8Array::*;
use encode_unicode::error::InvalidUtf8::*;
use encode_unicode::error::InvalidCodepoint::*;

assert_eq!(Utf8Char::from_array([b'A', 0, 0, 0]), Ok(Utf8Char::from('A')));
assert_eq!(Utf8Char::from_array([0xf4, 0x8b, 0xbb, 0xbb]), Ok(Utf8Char::from('\u{10befb}')));
assert_eq!(Utf8Char::from_array([b'A', b'B', b'C', b'D']), Ok(Utf8Char::from('A')));
assert_eq!(Utf8Char::from_array([0, 0, 0xcc, 0xbb]), Ok(Utf8Char::from('\0')));

assert_eq!(Utf8Char::from_array([0xef, b'F', 0x80, 0x80]), Err(Utf8(NotAContinuationByte(1))));
assert_eq!(Utf8Char::from_array([0xc1, 0x80, 0, 0]), Err(Utf8(OverLong)));
assert_eq!(Utf8Char::from_array([0xf7, 0xaa, 0x99, 0x88]), Err(Codepoint(TooHigh)));

pub unsafe fn from_array_unchecked(utf8: [u8; 4]) -> Self[−]

Zero-cost constructor.

Safety

Must contain a valid codepoint starting at the first byte, with the unused bytes zeroed.
Bad values can easily lead to undefined behavior.

pub fn from_ascii(ascii: u8) -> Result<Self, NonAsciiError>[−]

Create an Utf8Char from a single byte.

The byte must be an ASCII character.

Errors

Returns NonAsciiError if the byte greater than 127.

Examples

assert_eq!(Utf8Char::from_ascii(b'a').unwrap(), 'a');
assert!(Utf8Char::from_ascii(128).is_err());

pub unsafe fn from_ascii_unchecked(ascii: u8) -> Self[−]

Create an Utf8Char from a single byte without checking that it’s a valid codepoint on its own, which is only true for ASCII characters.

Safety

The byte must be less than 128.

pub fn len(self) -> usize[−]

The number of bytes this character needs.

Is between 1 and 4 (inclusive) and identical to .as_ref().len() or .as_char().len_utf8().

pub fn is_ascii(&self) -> bool[−]

Checks that the codepoint is an ASCII character.

pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool[−]

Checks that two characters are an ASCII case-insensitive match.

Is equivalent to a.to_ascii_lowercase() == b.to_ascii_lowercase().

pub fn to_ascii_uppercase(&self) -> Self[−]

Converts the character to its ASCII upper case equivalent.

ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.

pub fn to_ascii_lowercase(&self) -> Self[−]

Converts the character to its ASCII lower case equivalent.

ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.

pub fn make_ascii_uppercase(&mut self)[−]

Converts the character to its ASCII upper case equivalent in-place.

ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.

pub fn make_ascii_lowercase(&mut self)[−]

Converts the character to its ASCII lower case equivalent in-place.

ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.

pub fn to_char(self) -> char[−]

Convert from UTF-8 to UTF-32

pub fn to_slice(self, dst: &mut [u8]) -> usize[−]

Write the internal representation to a slice, and then returns the number of bytes written.

Panics

Will panic the buffer is too small; You can get the required length from .len(), but a buffer of length four is always large enough.

pub fn to_array(self) -> ([u8; 4], usize)[−]

Expose the internal array and the number of used bytes.

pub fn as_str(&self) -> &str[−]

Return a str view of the array the codepoint is stored as.

Is an unambiguous version of .as_ref().

Trait Implementations

impl AsRef<[u8]> for Utf8Char[+]

[+] Show hidden undocumented items

fn as_ref(&self) -> &[u8][−]

Performs the conversion.

impl AsRef<str> for Utf8Char[+]

[+] Show hidden undocumented items

fn as_ref(&self) -> &str[−]

Performs the conversion.

impl AsciiExt for Utf8Char[+]

[+] Show hidden undocumented items

type Owned = Utf8Char

👎 Deprecated since 1.26.0:

use inherent methods instead

Container type for copied ASCII characters.

fn is_ascii(&self) -> bool[−]

👎 Deprecated since 1.26.0:

use inherent methods instead

Checks if the value is within the ASCII range.

fn eq_ignore_ascii_case(&self, other: &Self) -> bool[−]

👎 Deprecated since 1.26.0:

use inherent methods instead

Checks that two values are an ASCII case-insensitive match.

fn to_ascii_uppercase(&self) -> Self::Owned[−]

👎 Deprecated since 1.26.0:

use inherent methods instead

Makes a copy of the value in its ASCII upper case equivalent.

fn to_ascii_lowercase(&self) -> Self::Owned[−]

👎 Deprecated since 1.26.0:

use inherent methods instead

Makes a copy of the value in its ASCII lower case equivalent.

fn make_ascii_uppercase(&mut self)[−]

👎 Deprecated since 1.26.0:

use inherent methods instead

Converts this type to its ASCII upper case equivalent in-place.

fn make_ascii_lowercase(&mut self)[−]

👎 Deprecated since 1.26.0:

use inherent methods instead

Converts this type to its ASCII lower case equivalent in-place.

impl Borrow<[u8]> for Utf8Char[+]

[+] Show hidden undocumented items

fn borrow(&self) -> &[u8][−]

Immutably borrows from an owned value.

impl Borrow<str> for Utf8Char[+]

[+] Show hidden undocumented items

fn borrow(&self) -> &str[−]

Immutably borrows from an owned value.

impl Clone for Utf8Char[+]

[+] Show hidden undocumented items

fn clone(&self) -> Utf8Char[−]

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)[−]

Performs copy-assignment from source.

impl Copy for Utf8Char

impl Debug for Utf8Char[+]

[+] Show hidden undocumented items

fn fmt(&self, fmtr: &mut Formatter<'_>) -> Result[−]

Formats the value using the given formatter.

impl Default for Utf8Char[+]

[+] Show hidden undocumented items

fn default() -> Utf8Char[−]

Returns the “default value” for a type.

impl Deref for Utf8Char[+]

[+] Show hidden undocumented items

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target[−]

Dereferences the value.

impl Display for Utf8Char[+]

[+] Show hidden undocumented items

fn fmt(&self, fmtr: &mut Formatter<'_>) -> Result[−]

Formats the value using the given formatter.

impl Eq for Utf8Char

impl<'a> Extend<&'a Utf8Char> for Vec<u8>[+]

[+] Show hidden undocumented items

fn extend<I: IntoIterator<Item = &'a Utf8Char>>(&mut self, iter: I)[−]

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)[−]

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

pub fn extend_reserve(&mut self, additional: usize)[−]

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a> Extend<&'a Utf8Char> for String[+]

[+] Show hidden undocumented items

fn extend<I: IntoIterator<Item = &'a Utf8Char>>(&mut self, iter: I)[−]

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)[−]

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

pub fn extend_reserve(&mut self, additional: usize)[−]

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<Utf8Char> for Vec<u8>[+]

[+] Show hidden undocumented items

fn extend<I: IntoIterator<Item = Utf8Char>>(&mut self, iter: I)[−]

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)[−]

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

pub fn extend_reserve(&mut self, additional: usize)[−]

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<Utf8Char> for String[+]

[+] Show hidden undocumented items

fn extend<I: IntoIterator<Item = Utf8Char>>(&mut self, iter: I)[−]

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)[−]

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

pub fn extend_reserve(&mut self, additional: usize)[−]

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<Utf16Char> for Utf8Char[+]

[+] Show hidden undocumented items

fn from(utf16: Utf16Char) -> Utf8Char[−]

Performs the conversion.

impl From<Utf8Char> for char[+]

[+] Show hidden undocumented items

fn from(uc: Utf8Char) -> char[−]

Performs the conversion.

impl From<Utf8Char> for Utf8Iterator[+]

[+] Show hidden undocumented items

fn from(uc: Utf8Char) -> Self[−]

Performs the conversion.

impl From<Utf8Char> for Utf16Char[+]

[+] Show hidden undocumented items

fn from(utf8: Utf8Char) -> Utf16Char[−]

Performs the conversion.

impl From<char> for Utf8Char[+]

[+] Show hidden undocumented items

fn from(c: char) -> Self[−]

Performs the conversion.

impl<'a> FromIterator<&'a Utf8Char> for String[+]

[+] Show hidden undocumented items

fn from_iter<I: IntoIterator<Item = &'a Utf8Char>>(iter: I) -> String[−]

Creates a value from an iterator.

impl<'a> FromIterator<&'a Utf8Char> for Vec<u8>[+]

[+] Show hidden undocumented items

fn from_iter<I: IntoIterator<Item = &'a Utf8Char>>(iter: I) -> Self[−]

Creates a value from an iterator.

impl FromIterator<Utf8Char> for String[+]

[+] Show hidden undocumented items

fn from_iter<I: IntoIterator<Item = Utf8Char>>(iter: I) -> String[−]

Creates a value from an iterator.

impl FromIterator<Utf8Char> for Vec<u8>[+]

[+] Show hidden undocumented items

fn from_iter<I: IntoIterator<Item = Utf8Char>>(iter: I) -> Self[−]

Creates a value from an iterator.

impl FromStr for Utf8Char[+]

type Err = FromStrError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, FromStrError>[−]

Create an Utf8Char from a string slice. The string must contain exactly one codepoint.

Examples

use encode_unicode::error::FromStrError::*;
use encode_unicode::Utf8Char;
use std::str::FromStr;

assert_eq!(Utf8Char::from_str("a"), Ok(Utf8Char::from('a')));
assert_eq!(Utf8Char::from_str("🂠"), Ok(Utf8Char::from('🂠')));
assert_eq!(Utf8Char::from_str(""), Err(Empty));
assert_eq!(Utf8Char::from_str("ab"), Err(MultipleCodepoints));
assert_eq!(Utf8Char::from_str("é"), Err(MultipleCodepoints));// 'e'+u301 combining mark

impl Hash for Utf8Char[+]

[+] Show hidden undocumented items

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl IntoIterator for Utf8Char[+]

type Item = u8

The type of the elements being iterated over.

type IntoIter = Utf8Iterator

Which kind of iterator are we turning this into?

fn into_iter(self) -> Utf8Iterator[−]

Iterate over the byte values.

impl Ord for Utf8Char[+]

[+] Show hidden undocumented items

fn cmp(&self, other: &Utf8Char) -> Ordering[−]

This method returns an Ordering between self and other.

[+] Expand attributes

#[must_use]pub fn max(self, other: Self) -> Self[−]

Compares and returns the maximum of two values.

[+] Expand attributes

#[must_use]pub fn min(self, other: Self) -> Self[−]

Compares and returns the minimum of two values.

[+] Expand attributes

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self[−]

Restrict a value to a certain interval.

impl PartialEq<Utf16Char> for Utf8Char[+]

[+] Show hidden undocumented items

fn eq(&self, u16c: &Utf16Char) -> bool[−]

This method tests for self and other values to be equal, and is used by ==.

[+] Expand attributes

#[must_use]pub fn ne(&self, other: &Rhs) -> bool[−]

This method tests for !=.

impl PartialEq<Utf8Char> for Utf8Char[+]

[+] Show hidden undocumented items

fn eq(&self, other: &Utf8Char) -> bool[−]

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Utf8Char) -> bool[−]

This method tests for !=.

impl PartialEq<Utf8Char> for char[+]

[+] Show hidden undocumented items

fn eq(&self, u8c: &Utf8Char) -> bool[−]

This method tests for self and other values to be equal, and is used by ==.

[+] Expand attributes

#[must_use]pub fn ne(&self, other: &Rhs) -> bool[−]

This method tests for !=.

impl PartialEq<Utf8Char> for Utf16Char[+]

[+] Show hidden undocumented items

fn eq(&self, u8c: &Utf8Char) -> bool[−]

This method tests for self and other values to be equal, and is used by ==.

[+] Expand attributes

#[must_use]pub fn ne(&self, other: &Rhs) -> bool[−]

This method tests for !=.

impl PartialEq<char> for Utf8Char[+]

[+] Show hidden undocumented items

fn eq(&self, u32c: &char) -> bool[−]

This method tests for self and other values to be equal, and is used by ==.

[+] Expand attributes

#[must_use]pub fn ne(&self, other: &Rhs) -> bool[−]

This method tests for !=.

impl PartialEq<u8> for Utf8Char[+]

Only considers the byte equal if both it and the Utf8Char represents ASCII characters.

There is no impl in the opposite direction, as this should only be used to compare Utf8Chars against constants.

Examples

assert!(Utf8Char::from('8') == b'8');
assert!(Utf8Char::from_array([0xf1,0x80,0x80,0x80]).unwrap() != 0xf1);
assert!(Utf8Char::from('\u{ff}') != 0xff);
assert!(Utf8Char::from('\u{80}') != 0x80);

[+] Show hidden undocumented items

fn eq(&self, byte: &u8) -> bool[−]

This method tests for self and other values to be equal, and is used by ==.

[+] Expand attributes

#[must_use]pub fn ne(&self, other: &Rhs) -> bool[−]

This method tests for !=.

impl PartialOrd<Utf16Char> for Utf8Char[+]

[+] Show hidden undocumented items

fn partial_cmp(&self, u16c: &Utf16Char) -> Option<Ordering>[−]

This method returns an ordering between self and other values if one exists.

[+] Expand attributes

#[must_use]pub fn lt(&self, other: &Rhs) -> bool[−]

This method tests less than (for self and other) and is used by the < operator.

[+] Expand attributes

#[must_use]pub fn le(&self, other: &Rhs) -> bool[−]

This method tests less than or equal to (for self and other) and is used by the <= operator.

[+] Expand attributes

#[must_use]pub fn gt(&self, other: &Rhs) -> bool[−]

This method tests greater than (for self and other) and is used by the > operator.

[+] Expand attributes

#[must_use]pub fn ge(&self, other: &Rhs) -> bool[−]

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Utf8Char> for Utf8Char[+]

[+] Show hidden undocumented items

fn partial_cmp(&self, other: &Utf8Char) -> Option<Ordering>[−]

This method returns an ordering between self and other values if one exists.

[+] Expand attributes

#[must_use]pub fn lt(&self, other: &Rhs) -> bool[−]

This method tests less than (for self and other) and is used by the < operator.

[+] Expand attributes

#[must_use]pub fn le(&self, other: &Rhs) -> bool[−]

This method tests less than or equal to (for self and other) and is used by the <= operator.

[+] Expand attributes

#[must_use]pub fn gt(&self, other: &Rhs) -> bool[−]

This method tests greater than (for self and other) and is used by the > operator.

[+] Expand attributes

#[must_use]pub fn ge(&self, other: &Rhs) -> bool[−]

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Utf8Char> for char[+]

[+] Show hidden undocumented items

fn partial_cmp(&self, u8c: &Utf8Char) -> Option<Ordering>[−]

This method returns an ordering between self and other values if one exists.

[+] Expand attributes

#[must_use]pub fn lt(&self, other: &Rhs) -> bool[−]

This method tests less than (for self and other) and is used by the < operator.

[+] Expand attributes

#[must_use]pub fn le(&self, other: &Rhs) -> bool[−]

This method tests less than or equal to (for self and other) and is used by the <= operator.

[+] Expand attributes

#[must_use]pub fn gt(&self, other: &Rhs) -> bool[−]

This method tests greater than (for self and other) and is used by the > operator.

[+] Expand attributes

#[must_use]pub fn ge(&self, other: &Rhs) -> bool[−]

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Utf8Char> for Utf16Char[+]

[+] Show hidden undocumented items

fn partial_cmp(&self, u8c: &Utf8Char) -> Option<Ordering>[−]

This method returns an ordering between self and other values if one exists.

[+] Expand attributes

#[must_use]pub fn lt(&self, other: &Rhs) -> bool[−]

This method tests less than (for self and other) and is used by the < operator.

[+] Expand attributes

#[must_use]pub fn le(&self, other: &Rhs) -> bool[−]

This method tests less than or equal to (for self and other) and is used by the <= operator.

[+] Expand attributes

#[must_use]pub fn gt(&self, other: &Rhs) -> bool[−]

This method tests greater than (for self and other) and is used by the > operator.

[+] Expand attributes

#[must_use]pub fn ge(&self, other: &Rhs) -> bool[−]

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<char> for Utf8Char[+]

[+] Show hidden undocumented items

fn partial_cmp(&self, u32c: &char) -> Option<Ordering>[−]

This method returns an ordering between self and other values if one exists.

[+] Expand attributes

#[must_use]pub fn lt(&self, other: &Rhs) -> bool[−]

This method tests less than (for self and other) and is used by the < operator.

[+] Expand attributes

#[must_use]pub fn le(&self, other: &Rhs) -> bool[−]

This method tests less than or equal to (for self and other) and is used by the <= operator.

[+] Expand attributes

#[must_use]pub fn gt(&self, other: &Rhs) -> bool[−]

This method tests greater than (for self and other) and is used by the > operator.

[+] Expand attributes

#[must_use]pub fn ge(&self, other: &Rhs) -> bool[−]

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for Utf8Char

impl StructuralPartialEq for Utf8Char