Struct tweep::ErrorList

pub struct ErrorList {
    pub errors: Vec<Error>,
}

A wrapper type for a list of Errors

Fields

errors: Vec<Error>

The list of Errors

Implementations

impl ErrorList

pub fn new() -> Self

Creates a new ErrorList

Examples

use tweep::ErrorList;
let errors = ErrorList::new();

pub fn push(&mut self, error: Error)

Adds the given Error to the list

Examples

use tweep::{Error, ErrorList, ErrorKind, FullContext};
let mut errors = ErrorList::default();
let context = FullContext::from(None, "::".to_string());
errors.push(Error::new(ErrorKind::EmptyName, Some(context.clone())));

pub fn is_empty(&self) -> bool

Returns true if the list is empty

Examples

use tweep::ErrorList;
let errors = ErrorList::new();
assert!(errors.is_empty());

pub fn merge<T, U>(
    left: &mut Result<T, ErrorList>,
    right: &mut Result<U, ErrorList>
) -> Result<(), ErrorList>

Given two Results with ErrorList as the Err type, returns:

• Ok(()) if both inputs are Ok
• The ErrorList contained by the Err input if one input is Err
• The ErrorList of right appended to the ErrorList of left if both inputs are Err

Note that T and U do not need to have any relation to each other.

Examples

When given two Ok variant inputs, returns Ok(()):

use tweep::ErrorList;
let mut left:Result<u8, ErrorList> = Ok(5);
let mut right:Result<&str, ErrorList> = Ok("foo");
let merged = ErrorList::merge(&mut left, &mut right);
assert_eq!(merged, Ok(()));

When given one Ok and one Err, the output will have the same list of errors as the Err variant:

use tweep::{Error, ErrorList, ErrorKind, FullContext, Position};
let mut left:Result<u8, ErrorList> = Ok(5);
let right_context = FullContext::from(None, "::".to_string());
let mut right:Result<&str, ErrorList> = Err(ErrorList {
    errors: vec![ Error::new(ErrorKind::EmptyName, Some(right_context.clone())) ],
});
let merged = ErrorList::merge(&mut left, &mut right);
assert_eq!(merged.err().unwrap().errors, vec![ Error::new(ErrorKind::EmptyName, Some(right_context.clone())) ]);

When given two Err variants, the output will be have an ErrorList that contains the errors in right appended to the errors in left

use tweep::{Error, ErrorList, ErrorKind, FullContext, Position};
let left_context = FullContext::from(None, "::".to_string());
let mut left:Result<u8, ErrorList> = Err(ErrorList {
    errors: vec![ Error::new(ErrorKind::EmptyName, Some(left_context.clone())) ],
});
let right_context = FullContext::from(None, " :: Blah".to_string());
let mut right:Result<&str, ErrorList> = Err(ErrorList {
    errors: vec![ Error::new(ErrorKind::LeadingWhitespace, Some(right_context.clone())) ],
});
let merged = ErrorList::merge(&mut left, &mut right);
assert_eq!(merged.err().unwrap().errors, vec![ Error::new(ErrorKind::EmptyName, Some(left_context.clone())), Error::new(ErrorKind::LeadingWhitespace, Some(right_context.clone())) ]);

Trait Implementations

impl Debug for ErrorList

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

Formats the value using the given formatter.

impl Default for ErrorList

fn default() -> ErrorList

Returns the "default value" for a type.

impl Display for ErrorList

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

Formats the value using the given formatter.

impl Eq for ErrorList

impl Error for ErrorList

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

if let Err(e) = "xc".parse::<u32>() { // Print e itself, no need for description(). eprintln!("Error: {}", e); }

fn cause(&self) -> Option<&dyn Error>

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

impl From<Error> for ErrorList

fn from(e: Error) -> ErrorList

Performs the conversion.

impl PartialEq<ErrorList> for ErrorList

fn eq(&self, other: &ErrorList) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ErrorList) -> bool

This method tests for !=.

impl StructuralEq for ErrorList

impl StructuralPartialEq for ErrorList