Struct alloc_data::err::ErrorCxt

pub struct ErrorCxt { /* private fields */ }

Error context, a shallow interface over a global list of errors.

The point of this type is to provide a memory of the errors from the global list of errors seen so far. There’s no point in using this just to register errors, use err::register instead.

This type is used by the server and the different client-sockets because they need to report errors.

Examples

let errors = vec![
    ("error 0", false),
    ("error 1", false),
    ("error 2", true),
    ("error 3", false),
    ("error 4", true),
];
let mut cnt = 0;
macro_rules! check {
    () => {
        |err: &str, is_fatal| {
            assert_eq!(err, errors[cnt].0);
            assert_eq!(is_fatal, errors[cnt].1);
            cnt += 1
        }
    };
}

let mut cxt = ErrorCxt::new();

cxt.register(errors[0].0, errors[0].1);
cxt.register(errors[1].0, errors[1].1);

// Applies `check` to the two errors registered so far.
let (err_count, fatal) = cxt.new_errors_do(check!());
assert!(!fatal);
assert_eq!(err_count, 2);
assert_eq!(cnt, 2);

// Applies `check` to nothing, there are no new errors.
let (err_count, fatal) = cxt.new_errors_do(check!());
assert!(!fatal);
assert_eq!(err_count, 0);
assert_eq!(cnt, 2);

cxt.register(errors[2].0, errors[2].1);
cxt.register(errors[3].0, errors[3].1);

// Applies `check` to the two new errors.
let (err_count, fatal) = cxt.new_errors_do(check!());
assert!(fatal);
assert_eq!(err_count, 2);
assert_eq!(cnt, 4);

// Registering from the `err` module is fine too.
err::register(errors[4].0, errors[4].1);

// Applies `check` to the one new error.
let (err_count, fatal) = cxt.new_errors_do(check!());
assert!(fatal);
assert_eq!(err_count, 1);
assert_eq!(cnt, 5);

Implementations

impl ErrorCxt

pub fn new() -> ErrorCxt

Constructor.

pub fn register_non_fatal(&self, e: impl Into<Error>)

Registers a non-fatal error in the global list of errors.

See the type-level documentation for examples.

pub fn register_fatal(&self, e: impl Into<Error>)

Registers a fatal error in the global list of errors.

See the type-level documentation for examples.

pub fn register(&self, e: impl Into<Error>, fatal: bool)

Registers an error in the global list of errors.

See the type-level documentation for examples.

pub fn new_errors_do(&mut self, action: impl FnMut(&str, bool)) -> (usize, bool)

Applies an action to the new errors in the global list of errors.

Returns the number of new errors to which action was applied.

NB: errors only appear once across calls. So when action(e_i) runs, future calls to this function will never run action(e_i) again.

See the type-level documentation for examples.

pub fn new_errors_try<E>(
    &mut self,
    action: impl FnMut(&str, bool) -> Result<(), E>
) -> Result<(usize, bool), E>

Applies an action that can fail to the new errors in the global list of errors.

Returns the number of new errors to which action was applied.

NB: errors only appear once across calls. So when action(e_i) runs, future calls to this function will never run action(e_i) again.

See the type-level documentation for examples.

Trait Implementations

impl Clone for ErrorCxt

fn clone(&self) -> ErrorCxt

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorCxt

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

Formats the value using the given formatter.