Struct Ck 

pub struct Ck<I: Invariant> { /* private fields */ }

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.

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>

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: (unsized)