Struct HashValidator 

pub struct HashValidator {
    pub comment: String,
    pub link: Option<Box<Validator>>,
    pub schema: Vec<Option<Hash>>,
    pub in_list: Vec<Hash>,
    pub nin_list: Vec<Hash>,
    pub query: bool,
    pub link_ok: bool,
    pub schema_ok: bool,
}

Validator for hashes.

This validator type will only pass hash values. Validation passes if:

• If the in list is not empty, the hash must be among the hashes in the list.
• The hash must not be among the hashes in the nin list.
• If link has a validator, the data in the Document referred to by the hash must pass that validator.
• If the schema list is not empty, the Document referred to by the hash must use one of the schemas listed. A null value on the list means the schema containing this validator is also accepted.

The link and schema checks only apply when validating Entries, not Documents.

Hash validators are unique in that they do not always complete validation after examining a single value. If used for checking an Entry, they can require an additional Document for validation. For this reason, completing validation of an Entry requires completing a DataChecklist. See the Schema documentation for more details.

Defaults

Fields that aren’t specified for the validator use their defaults instead. The defaults for each field are:

• comment: “”
• link: None
• schema: empty
• in_list: empty
• nin_list: empty
• query: false
• link_ok: false
• schema_ok: false

Query Checking

Queries for hashes are only allowed to use non-default values for each field if the corresponding query permission is set in the schema’s validator:

• query: in and nin lists
• link_ok: link
• schema_ok: schema

In addition, if there is a validator for link, it is validated against the schema validator’s link validator.

Fields

comment: String

An optional comment explaining the validator.

link: Option<Box<Validator>>

An optional validator used to validate the data in a Document linked to by the hash. If not present, any data is allowed in the linked Document.

schema: Vec<Option<Hash>>

A list of allowed schemas for a Document linked to by the hash. A None value refers to the validator’s containing schema. For validators used in queries, None is skipped. If empty, this list is ignored during checking.

in_list: Vec<Hash>

A vector of specific allowed values, stored under the in field. If empty, this vector is not checked against.

nin_list: Vec<Hash>

A vector of specific unallowed values, stored under the nin field.

query: bool

If true, queries against matching spots may have values in the in or nin lists.

link_ok: bool

If true, queries against matching spots may have a validator in link.

schema_ok: bool

If true, queries against matching spots may have values in the schema list.

Implementations

impl HashValidator

pub fn new() -> Self

Make a new validator with the default configuration.

pub fn link(self, link: Validator) -> Self

Set the link validator.

pub fn schema_add(self, add: impl Into<Hash>) -> Self

Add a Hash to the schema list.

pub fn schema_self(self) -> Self

Allow referred-to documents to use this validator’s containing schema.

pub fn in_add(self, add: impl Into<Hash>) -> Self

Add a value to the in list.

pub fn nin_add(self, add: impl Into<Hash>) -> Self

Add a value to the nin list.

pub fn query(self, query: bool) -> Self

Set whether or not queries can use the in and nin lists.

pub fn link_ok(self, link_ok: bool) -> Self

Set whether or not queries can use link.

pub fn schema_ok(self, schema_ok: bool) -> Self

Set whether or not queries can use schema.

pub fn build(self) -> Validator

Build this into a Validator enum.

Trait Implementations

impl Clone for HashValidator

fn clone(&self) -> HashValidator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HashValidator

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

Formats the value using the given formatter.

impl Default for HashValidator

fn default() -> HashValidator

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for HashValidator

where HashValidator: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for HashValidator

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

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 HashValidator