Struct Ck

#[repr(transparent)]
pub struct Ck<I: Invariant> {
    pub(crate) _marker: PhantomData<I>,
    pub(crate) slice: str,
}

Borrowed immutable string with invariants.

Ck is a DST, and therefore must always live behind a pointer. This means you’ll usually see it as &Ck<I> in type signatures.

Deserialization

See the crate-level documentation for details on how to use Ck for checked zero-copy deserialization.

Fields

_marker: PhantomData<I>

slice: str

Implementations

impl<I: Invariant> Ck<I>

pub fn from_slice(slice: &str) -> Result<&Self, I::Error>

Returns an Ok if the &str upholds the invariants, otherwise Err.

pub unsafe fn from_str_unchecked(slice: &str) -> &Self

Create a new &Ck without validating the &str.

Safety

The string must be valid.

pub fn to_check<'a, B>(&'a self) -> Check<I, B>

where B: AsRef<str> + From<&'a str>,

Returns an owned Check from &self.

pub fn as_str(&self) -> &str

Returns the &str representation.

Trait Implementations

impl<I: Invariant, B: AsRef<str>> AsRef<Ck<I>> for Check<I, B>

fn as_ref(&self) -> &Ck<I>

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

impl<I: Invariant> AsRef<str> for Ck<I>

fn as_ref(&self) -> &str

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

impl<I: Invariant, B: AsRef<str>> Borrow<Ck<I>> for Check<I, B>

fn borrow(&self) -> &Ck<I>

Immutably borrows from an owned value.

impl<I: Invariant> Borrow<str> for Ck<I>

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<I: Invariant> Debug for Ck<I>

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

Formats the value using the given formatter.

impl<I: Invariant> Display for Ck<I>

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

Formats the value using the given formatter.

impl<'a, I: Invariant, B: AsRef<str>> From<&'a Check<I, B>> for &'a Ck<I>

fn from(check: &'a Check<I, B>) -> Self

Converts to this type from the input type.

impl<'a, I, B> From<&'a Ck<I>> for Check<I, B>

where I: Invariant, B: AsRef<str> + From<&'a str>,

fn from(check: &'a Ck<I>) -> Self

Converts to this type from the input type.

impl<I: Invariant> Hash for Ck<I>

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

Feeds this value into the given Hasher.

impl<I: Invariant> Ord for Ck<I>

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

This method returns an Ordering between self and other.

impl<'a, I: Invariant, B: AsRef<str>> PartialEq<&'a Check<I, B>> for Ck<I>

fn eq(&self, other: &&'a Check<I, B>) -> 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<'a, I: Invariant, B: AsRef<str>> PartialEq<&'a Ck<I>> for Check<I, B>

fn eq(&self, other: &&'a Ck<I>) -> 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<'a, I: Invariant> PartialEq<&'a Ck<I>> for Ck<I>

fn eq(&self, other: &&'a Ck<I>) -> 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<'a, I: Invariant> PartialEq<&'a Ck<I>> for String

fn eq(&self, other: &&'a Ck<I>) -> 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<'a, I: Invariant> PartialEq<&'a Ck<I>> for str

fn eq(&self, other: &&'a Ck<I>) -> 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<'a, I: Invariant> PartialEq<&'a String> for Ck<I>

fn eq(&self, other: &&'a String) -> 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<'a, I: Invariant> PartialEq<&'a str> for Ck<I>

fn eq(&self, other: &&'a 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<'a, I: Invariant, B: AsRef<str>> PartialEq<Check<I, B>> for &'a Ck<I>

fn eq(&self, other: &Check<I, B>) -> 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<I: Invariant, B: AsRef<str>> PartialEq<Check<I, B>> for Ck<I>

fn eq(&self, other: &Check<I, B>) -> 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<'a, I: Invariant, B: AsRef<str>> PartialEq<Ck<I>> for &'a Check<I, B>

fn eq(&self, other: &Ck<I>) -> 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<'a, I: Invariant> PartialEq<Ck<I>> for &'a Ck<I>

fn eq(&self, other: &Ck<I>) -> 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<'a, I: Invariant> PartialEq<Ck<I>> for &'a String

fn eq(&self, other: &Ck<I>) -> 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<'a, I: Invariant> PartialEq<Ck<I>> for &'a str

fn eq(&self, other: &Ck<I>) -> 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<I: Invariant, B: AsRef<str>> PartialEq<Ck<I>> for Check<I, B>

fn eq(&self, other: &Ck<I>) -> 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<I: Invariant> PartialEq<Ck<I>> for String

fn eq(&self, other: &Ck<I>) -> 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<I: Invariant> PartialEq<Ck<I>> for str

fn eq(&self, other: &Ck<I>) -> 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<'a, I: Invariant> PartialEq<String> for &'a Ck<I>

fn eq(&self, other: &String) -> 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<I: Invariant> PartialEq<String> for Ck<I>

fn eq(&self, other: &String) -> 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<'a, I: Invariant> PartialEq<str> for &'a Ck<I>

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<I: Invariant> PartialEq<str> for Ck<I>

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<I: Invariant> PartialEq for Ck<I>

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<I: Invariant> PartialOrd for Ck<I>

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<I: Invariant> ToOwned for Ck<I>

type Owned = Check<I>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl<'a, I: Invariant> TryFrom<&'a str> for &'a Ck<I>

type Error = <I as Invariant>::Error

The type returned in the event of a conversion error.

fn try_from(slice: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl<I: Invariant> Eq for Ck<I>