Struct UnvalidatedChar 

pub struct UnvalidatedChar(/* private fields */);

A u8 array of little-endian data that is expected to be a Unicode scalar value, but is not validated as such.

Use this type instead of char when you want to deal with data that is expected to be valid Unicode scalar values, but you want control over when or if you validate that assumption.

Examples

use zerovec::ule::UnvalidatedChar;
use zerovec::{ZeroSlice, ZeroVec};

// data known to be little-endian three-byte chunks of valid Unicode scalar values
let data = [0x68, 0x00, 0x00, 0x69, 0x00, 0x00, 0x4B, 0xF4, 0x01];
// ground truth expectation
let real = ['h', 'i', '👋'];

let chars: &ZeroSlice<UnvalidatedChar> = ZeroSlice::parse_byte_slice(&data).expect("invalid data length");
let parsed: Vec<_> = chars.iter().map(|c| unsafe { c.to_char_unchecked() }).collect();
assert_eq!(&parsed, &real);

let real_chars: ZeroVec<_> = real.iter().copied().map(UnvalidatedChar::from_char).collect();
let serialized_data = chars.as_bytes();
assert_eq!(serialized_data, &data);

Implementations

impl UnvalidatedChar

pub const fn from_char(c: char) -> Self

Create a UnvalidatedChar from a char.

Examples

use zerovec::ule::UnvalidatedChar;

let a = UnvalidatedChar::from_char('a');
assert_eq!(a.try_to_char().unwrap(), 'a');

pub fn try_to_char(self) -> Result<char, CharTryFromError>

Attempt to convert a UnvalidatedChar to a char.

Examples

use zerovec::ule::{AsULE, UnvalidatedChar};

let a = UnvalidatedChar::from_char('a');
assert_eq!(a.try_to_char(), Ok('a'));

let b = UnvalidatedChar::from_unaligned([0xFF, 0xFF, 0xFF].into());
assert!(matches!(b.try_to_char(), Err(_)));

pub fn to_char_lossy(self) -> char

Convert a UnvalidatedChar to a char', returning [char::REPLACEMENT_CHARACTER] if the UnvalidatedChar` does not represent a valid Unicode scalar value.

Examples

use zerovec::ule::{AsULE, UnvalidatedChar};

let a = UnvalidatedChar::from_unaligned([0xFF, 0xFF, 0xFF].into());
assert_eq!(a.to_char_lossy(), char::REPLACEMENT_CHARACTER);

pub unsafe fn to_char_unchecked(self) -> char

Convert a UnvalidatedChar to a char without checking that it is a valid Unicode scalar value.

Safety

The UnvalidatedChar must be a valid Unicode scalar value in little-endian order.

Examples

use zerovec::ule::UnvalidatedChar;

let a = UnvalidatedChar::from_char('a');
assert_eq!(unsafe { a.to_char_unchecked() }, 'a');

Trait Implementations

impl AsULE for UnvalidatedChar

type ULE = RawBytesULE<3>

The ULE type corresponding to Self.

fn to_unaligned(self) -> Self::ULE

Converts from Self to Self::ULE.

fn from_unaligned(unaligned: Self::ULE) -> Self

Converts from Self::ULE to Self.

impl Clone for UnvalidatedChar

fn clone(&self) -> UnvalidatedChar

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnvalidatedChar

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

Formats the value using the given formatter.

impl From<char> for UnvalidatedChar

fn from(value: char) -> Self

Converts to this type from the input type.

impl Hash for UnvalidatedChar

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 Ord for UnvalidatedChar

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for UnvalidatedChar

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

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl TryFrom<UnvalidatedChar> for char

type Error = CharTryFromError

The type returned in the event of a conversion error.

fn try_from(value: UnvalidatedChar) -> Result<char, Self::Error>

Performs the conversion.

impl Copy for UnvalidatedChar

impl Eq for UnvalidatedChar

impl EqULE for UnvalidatedChar

impl StructuralPartialEq for UnvalidatedChar

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 3 bytes