Struct precis_profiles::OpaqueString

pub struct OpaqueString { /* fields omitted */ }

OpaqueString Profile Profile designed to deal with passwords and other opaque strings in security and application protocols. Replaces: The SASLprep profile of Stringprep. Look at the IANA Considerations section for more details.

Example

use precis_core::Error;
use precis_core::profile::Profile;
use precis_profiles::OpaqueString;
use std::borrow::Cow;

// create OpaqueString profile
let profile = OpaqueString::new();

// prepare string
assert_eq!(profile.prepare("I'm Guybrush Threepwood, Mighty Pirate ☠"),
    Ok(Cow::from("I'm Guybrush Threepwood, Mighty Pirate ☠")));

// enforce string
assert_eq!(profile.enforce("Look behind you, a three-headed monkey!🐒"),
    Ok(Cow::from("Look behind you, a three-headed monkey!🐒")));

// compare strings
assert_eq!(profile.compare("That’s the second biggest 🐵 I’ve ever seen!",
    "That’s the second biggest 🐵 I’ve ever seen!"), Ok(true));

Implementations

impl OpaqueString

pub fn new() -> Self

Trait Implementations

impl Default for OpaqueString

fn default() -> Self

Returns the “default value” for a type.

impl PrecisFastInvocation for OpaqueString

fn prepare(s: &str) -> Result<Cow<'_, str>, Error>

fn enforce<'a>(s: &str) -> Result<Cow<'_, str>, Error>

fn compare(s1: &str, s2: &str) -> Result<bool, Error>

impl Profile for OpaqueString

fn prepare<'a>(&self, s: &'a str) -> Result<Cow<'a, str>, Error>

Ensures that the code points in a single input string are allowed by the underlying PRECIS string class, and sometimes also entails applying one or more of the rules specified for a particular string class or profile thereof.

fn enforce<'a>(&self, s: &'a str) -> Result<Cow<'a, str>, Error>

Applies all of the rules specified for a particular string class, or profile thereof, to a single input string, for the purpose of checking whether the string conforms to all of the rules and thus determining if the string can be used in a given protocol slot.

fn compare(&self, s1: &str, s2: &str) -> Result<bool, Error>

Comparison entails applying all of the rules specified for a particular string class, or profile thereof, to two separate input strings, for the purpose of determining if the two strings are equivalent.

impl Rules for OpaqueString

fn additional_mapping_rule<'a, T>(&self, s: T) -> Result<Cow<'a, str>, Error> where
    T: Into<Cow<'a, str>>, 

Appies the additional mapping rule of a profile to an input string.

fn normalization_rule<'a, T>(&self, s: T) -> Result<Cow<'a, str>, Error> where
    T: Into<Cow<'a, str>>, 

Applies the normalization rule of a profile to an input string

fn width_mapping_rule<'a, T>(&self, _s: T) -> Result<Cow<'a, str>, Error> where
    T: Into<Cow<'a, str>>, 

Applies the width mapping rule of a profile to an input string.

fn case_mapping_rule<'a, T>(&self, _s: T) -> Result<Cow<'a, str>, Error> where
    T: Into<Cow<'a, str>>, 

Applies the case mapping rule of a profile to an input string

fn directionality_rule<'a, T>(&self, _s: T) -> Result<Cow<'a, str>, Error> where
    T: Into<Cow<'a, str>>, 

Applies the directionality rule of a profile to an input string