serde_hooks 0.1.1

Runtime hooks for serde
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use serde::Serializer;

use crate::{ser::HooksError, Path};

/// Inspect errors and choose recovery actions.
///
/// See [`Hooks::on_scope_error`](crate::ser::Hooks::on_scope_error).
///
/// By default the errors are propagated.
pub struct ErrorScope<'p> {
    path: &'p Path,
    error: HooksError,
    ignore: bool,
}

impl<'p> ErrorScope<'p> {
    pub(crate) fn new(path: &'p Path, error: HooksError) -> Self {
        Self {
            path,
            error,
            ignore: false,
        }
    }

    pub(crate) fn into_result<S: Serializer>(self) -> Result<(), S::Error> {
        if self.ignore {
            Ok(())
        } else {
            Err(serde::ser::Error::custom(self.format_error_message()))
        }
    }

    /// Returns the error the hook was called about.
    pub fn error(&self) -> &HooksError {
        &self.error
    }

    /// Ignore this error and continue serialization.
    pub fn ignore(&mut self) -> &mut Self {
        self.ignore = true;
        self
    }

    /// Immediately panic.
    ///
    /// The panic message will contain the error message.
    pub fn panic(&mut self) {
        panic!("{}", self.format_error_message());
    }

    /// Propagate this error as a custom serialization error.
    pub fn propagate(&mut self) -> &mut Self {
        self.ignore = false;
        self
    }

    fn format_error_message(&self) -> String {
        format!(
            "Error at path '{path}': {err}",
            path = *self.path.borrow_str(),
            err = self.error,
        )
    }
}