Struct ValidationResult 

pub struct ValidationResult<TData: Clone, E: Debug> {
    pub errors: Vec<E>,
    pub data: Option<TData>,
}

Fields

errors: Vec<E>

data: Option<TData>

Implementations

impl<TData: Clone, E: Debug> ValidationResult<Vec<TData>, E>

pub fn flatten<I: IntoIterator<Item = ValidationResult<Vec<TData>, E>>>( items: I, ) -> ValidationResult<Vec<TData>, E>

impl<TData: Clone, E: Debug> ValidationResult<TData, E>

pub fn merge_many<I: IntoIterator<Item = ValidationResult<TData, E>>>( items: I, ) -> ValidationResult<Vec<TData>, E>

impl<E: Debug> ValidationResult<(), E>

pub fn merge_many_errors<I: IntoIterator<Item = SimpleValidationResult<E>>>( items: I, ) -> SimpleValidationResult<E>

impl<TData: Clone, E: Debug> ValidationResult<TData, E>

pub fn new() -> Self

pub fn new_with_data(data: TData) -> Self

pub fn new_with_data_and_errors(data: TData, errors: Vec<E>) -> Self

pub fn new_with_error(error: E) -> Self

pub fn new_with_errors(errors: Vec<E>) -> Self

pub fn map<F, U: Clone>(self, f: F) -> ValidationResult<U, E>

where F: FnOnce(TData) -> U,

pub fn map_result<F, U: Clone, G>( self, f: F, ) -> Result<ValidationResult<U, E>, G>

where F: FnOnce(TData) -> Result<U, G>,

pub fn and_then_simple_validation<F>( self, f: F, ) -> Result<ValidationResult<TData, E>, ProtocolError>

where F: FnOnce(&TData) -> Result<SimpleValidationResult<E>, ProtocolError>,

pub fn and_then_validation<F, U: Clone, G>( self, f: F, ) -> Result<ValidationResult<U, E>, G>

where F: FnOnce(TData) -> Result<ValidationResult<U, E>, G>,

pub fn and_then_borrowed_validation<F, U: Clone, G>( self, f: F, ) -> Result<ValidationResult<U, E>, G>

where F: FnOnce(&TData) -> Result<ValidationResult<U, E>, G>,

pub fn add_error<T>(&mut self, error: T)

where T: Into<E>,

pub fn add_errors(&mut self, errors: Vec<E>)

pub fn add_errors_into<EI: Into<E>>(&mut self, errors: Vec<EI>)

pub fn merge<TOtherData: Clone>( &mut self, other: ValidationResult<TOtherData, E>, )

pub fn is_valid(&self) -> bool

pub fn is_err(&self) -> bool

pub fn first_error(&self) -> Option<&E>

pub fn get_error(&self, pos: usize) -> Option<&E>

pub fn into_result_without_data(self) -> ValidationResult<(), E>

pub fn is_valid_with_data(&self) -> bool

pub fn has_data(&self) -> bool

pub fn set_data(&mut self, data: TData)

pub fn into_data(self) -> Result<TData, ProtocolError>

pub fn into_data_with_error(self) -> Result<Result<TData, E>, ProtocolError>

pub fn into_data_and_errors(self) -> Result<(TData, Vec<E>), ProtocolError>

pub fn data_as_borrowed(&self) -> Result<&TData, ProtocolError>

Trait Implementations

impl<TData: Clone + Clone, E: Clone + Debug> Clone for ValidationResult<TData, E>

fn clone(&self) -> ValidationResult<TData, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<TData: Debug + Clone, E: Debug + Debug> Debug for ValidationResult<TData, E>

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

Formats the value using the given formatter.

impl<T: Clone, E: Debug> Default for ValidationResult<T, E>

fn default() -> Self

Returns the “default value” for a type.

impl<TData: Clone, E: Debug, F: Into<E>> From<Result<TData, F>> for ValidationResult<TData, E>

fn from(value: Result<TData, F>) -> Self

Converts to this type from the input type.

impl<TData: Clone, E: Debug> From<TData> for ValidationResult<TData, E>

fn from(value: TData) -> Self

Converts to this type from the input type.