Struct Status

pub struct Status<R>
where
    R: ValidationReport,
{
    pub seal_issues: Vec<R::SealIssue>,
    pub failures: Vec<R::Failure>,
    pub warnings: Vec<R::Warning>,
    pub info: Vec<R::Info>,
}

Client-side-validation status containing all reports from the validation process

Fields

seal_issues: Vec<R::SealIssue>

List of seal resolver reported issues (see SealIssue trait for details).

failures: Vec<R::Failure>

Failures generated during client-side-validation.

When the failure happens, the process of client-side-validation is not stopped and proceeds to the rest of data items, such that there might be a multiple validation failures stored in this array.

Does not include issues from single-use-seal resolution, which are stored in Status::seal_issues and must be handled separately.

warnings: Vec<R::Warning>

Warnings generated during client-side-validation.

Warnings are issues which does not render client-side-validated data invalid, but which should be reported to the user anyway

See also ValidationReport::Warning.

info: Vec<R::Info>

Information reports about client-side-validation, which do not affect data safety or validity and may not be presented to the user

See also ValidationReport::Info.

Implementations

impl<R> Status<R>

where R: ValidationReport,

pub fn new() -> Self

Constructs empty status report

pub fn from_failure(failure: R::Failure) -> Self

Constructs status report from a single failure with the rest of log lists set to the empty state.

pub fn add_seal_issue(&mut self, seal_issue: R::SealIssue) -> &Self

Adds a single SealIssue to the validation report logs

pub fn add_failure(&mut self, failure: R::Failure) -> &Self

Adds a single ValidationFailure to the validation report logs

pub fn add_warning(&mut self, warning: R::Warning) -> &Self

Adds a single warning entry to the validation report logs. See ValidationReport::Warning for more details about warnings.

pub fn add_info(&mut self, info: R::Info) -> &Self

Adds a single information record to the validation report logs. See ValidationReport::Info for more details about information log entries.

pub fn validity(&self) -> Validity

Returns validity of the client-side data deduced from the current status containing all reported issues.

Client-side data are valid (Validity::Valid status) only and only if the status report contains no validation failures and seal resolution issues.

See also Validity for the details of possible validation statuses.

Trait Implementations

impl<R> AddAssign for Status<R>

where R: ValidationReport,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<R> Clone for Status<R>

where R: ValidationReport + Clone, R::SealIssue: Clone, R::Failure: Clone, R::Warning: Clone, R::Info: Clone,

fn clone(&self) -> Status<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R> Debug for Status<R>

where R: ValidationReport + Debug, R::SealIssue: Debug, R::Failure: Debug, R::Warning: Debug, R::Info: Debug,

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

Formats the value using the given formatter.

impl<R> Default for Status<R>

where R: ValidationReport + Default, R::SealIssue: Default, R::Failure: Default, R::Warning: Default, R::Info: Default,

fn default() -> Status<R>

Returns the “default value” for a type.

impl<'de, R> Deserialize<'de> for Status<R>

where R: ValidationReport,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R> FromIterator<<R as ValidationReport>::Failure> for Status<R>

where R: ValidationReport,

fn from_iter<T: IntoIterator<Item = R::Failure>>(iter: T) -> Self

Creates a value from an iterator.

impl<R> Hash for Status<R>

where R: ValidationReport + Hash, R::SealIssue: Hash, R::Failure: Hash, R::Warning: Hash, R::Info: Hash,

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<R> PartialEq for Status<R>

where R: ValidationReport + PartialEq, R::SealIssue: PartialEq, R::Failure: PartialEq, R::Warning: PartialEq, R::Info: PartialEq,

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

where R: ValidationReport,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<R> Eq for Status<R>

where R: ValidationReport + Eq, R::SealIssue: Eq, R::Failure: Eq, R::Warning: Eq, R::Info: Eq,

impl<R> StructuralPartialEq for Status<R>

where R: ValidationReport,