esyn 0.9.1

De/Serialization Rust In Rust.
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use thiserror::Error;

#[macro_export]
macro_rules! err {
    (NotFound: $a:expr) => {
        MyErr::NotFound(format!($a))
    };
    (Panic: $a:expr) => {
        MyErr::Panic(format!($a))
    };
    (Expected: $a:expr, $b:expr) => {
        MyErr::Expected {
            l: format!("{}", $a),
            r: format!("{}", $b),
        }
    };

    (NotFound $a:expr) => {
        Err(err!(NotFound: $a))
    };
    (Panic $a:expr) => {
        Err(err!(Panic: $a))
    };
    (Expected $a:expr, $b:expr) => {
        Err(err!(Expected: $a, $b))
    };
}

pub type Res<T> = Result<T, MyErr>;

// TODO:
#[derive(Debug, Error)]
pub enum MyErr {
    #[error("todo")]
    Todo,

    #[error("Unimplemented")]
    Unimplemented,

    #[error("")]
    Str(&'static str),

    #[error("")]
    Debug(String),

    #[error("not found `{0}`")]
    NotFound(String),

    #[error("parse int")]
    ParseInt(#[from] std::num::ParseIntError),

    #[error("parse int")]
    ParseFloat(#[from] std::num::ParseFloatError),

    #[error("unsupported")]
    Unsupported,

    #[error("{0:?} is unsupported")]
    UnType(String),

    #[error("")]
    Io(#[from] std::io::Error),

    #[error("")]
    UnEqFields,

    #[error("")]
    Syn(#[from] syn::Error),

    #[error("{0:?}")]
    Panic(String),

    #[error("expected `{l}`, found `{r}`")]
    Expected { l: String, r: String },

    #[error("UnknownField")]
    UnknownField,
}