Enum Validator 

pub enum Validator {
    Null,
    Bool(Box<BoolValidator>),
    Int(Box<IntValidator>),
    F32(Box<F32Validator>),
    F64(Box<F64Validator>),
    Bin(Box<BinValidator>),
    Str(Box<StrValidator>),
    Array(Box<ArrayValidator>),
    Map(Box<MapValidator>),
    Time(Box<TimeValidator>),
    Hash(Box<HashValidator>),
    Identity(Box<IdentityValidator>),
    StreamId(Box<StreamIdValidator>),
    LockId(Box<LockIdValidator>),
    BareIdKey,
    DataLockbox(Box<DataLockboxValidator>),
    IdentityLockbox(Box<IdentityLockboxValidator>),
    StreamLockbox(Box<StreamLockboxValidator>),
    LockLockbox(Box<LockLockboxValidator>),
    Ref(String),
    Multi(MultiValidator),
    Enum(EnumValidator),
    Any,
}

A fog-pack Validator, for verifying the form of a fog-pack Document or Entry.

Validators can be used to verify a fog-pack Document or Entry. Schemas use them for verification, and they are also used by Queries to find matching Entries.

This enum contains all possible validators. See the module-level documentation for details.

Variants

Null

Validator::Null - for the null type.

Bool(Box<BoolValidator>)

BoolValidator - for booleans.

Int(Box<IntValidator>)

IntValidator - for Integer and other integer values.

F32(Box<F32Validator>)

F32Validator - for f32 values.

F64(Box<F64Validator>)

F64Validator - for f64 values.

Bin(Box<BinValidator>)

BinValidator - for byte sequences.

Str(Box<StrValidator>)

StrValidator - for UTF-8 strings.

Array(Box<ArrayValidator>)

ArrayValidator - for sequences, like Vec, arrays, or tuples.

Map(Box<MapValidator>)

MapValidator - for maps, like struct, BTreeMap, and HashMap

Time(Box<TimeValidator>)

TimeValidator - for Timestamp

Hash(Box<HashValidator>)

HashValidator - for Hash

Identity(Box<IdentityValidator>)

IdentityValidator - for Identity

StreamId(Box<StreamIdValidator>)

StreamIdValidator - for StreamId

LockId(Box<LockIdValidator>)

LockIdValidator - for LockId

BareIdKey

BareIdKey - for BareIdKey

DataLockbox(Box<DataLockboxValidator>)

DataLockboxValidator - for DataLockbox

IdentityLockbox(Box<IdentityLockboxValidator>)

IdentityLockboxValidator - for IdentityLockbox

StreamLockbox(Box<StreamLockboxValidator>)

StreamLockboxValidator - for StreamLockbox

LockLockbox(Box<LockLockboxValidator>)

LockLockboxValidator - for LockLockbox

Ref(String)

Validator::Ref - a reference to a validator stored in a schema’s map of types. Uses a name to look up the validator.

Multi(MultiValidator)

MultiValidator - Will attempt a sequence of validators, passing if any one of them pass.

Enum(EnumValidator)

EnumValidator - Acts as a validator for serialized Rust enums. This can also be implemented through MapValidator, but this validator is generally easier to use correctly in such cases.

Any

Validator::Any - accepts any fog-pack value without examining it.

Implementations

impl Validator

pub fn new_ref(name: impl Into<String>) -> Self

Create a new reference validator from the given string.

pub fn new_null() -> Self

Create a new validator for the Null value.

pub fn new_bare_id_key() -> Self

Create a new validator for a BareIdKey.

pub fn new_any() -> Self

Create a new validator that passes any value.

Trait Implementations

impl Clone for Validator

fn clone(&self) -> Validator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Validator

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Validator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Validator

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Validator