timsrust-utils 0.1.4

Shared utilities for the timsrust crate family (readers, buffers, threading helpers)
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
79
80
81
82
83
84
85
86
87
88
89
90
91

pub trait WrappedError:
    std::fmt::Debug + std::fmt::Display + std::error::Error
{
}

#[macro_export]
macro_rules! simple_error {
    (
        $vis:vis
        $err_ty:ident
    ) => {
        #[derive(Debug, Clone, PartialEq, Eq, Default)]
        $vis struct $err_ty();

        impl std::fmt::Display for $err_ty {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, stringify!($err_ty))
            }
        }

        impl std::error::Error for $err_ty {}

        impl $crate::error::WrappedError for $err_ty {}
    };
}

#[macro_export]
macro_rules! custom_error {
    (
        $vis:vis
        $err_ty:ident
    ) => {
        #[derive(Debug, Clone, PartialEq, Eq)]
        $vis struct $err_ty(String);

        impl $err_ty {
            pub fn new(msg: impl Into<String>) -> Self {
                Self(msg.into())
            }
        }

        impl std::fmt::Display for $err_ty {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, concat!(stringify!($err_ty), "({})"), self.0)
            }
        }

        impl std::error::Error for $err_ty {}

        impl $crate::error::WrappedError for $err_ty {}
    };
}

#[macro_export]
macro_rules! enumerated_error {
    (
        $vis:vis
        $err_ty:ident,
        $($variant:ident($from_ty:ty)),* $(,)?
    ) => {
        #[derive(Debug, Clone, PartialEq, Eq)]
        $vis enum $err_ty {
            $(
                $variant($from_ty),
            )*
        }

        impl std::fmt::Display for $err_ty {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                match self {
                    $(
                    Self::$variant(e) => write!(f, concat!(stringify!($err_ty), "({})"), e),
                    )*
                }
            }
        }

        $(
        impl From<$from_ty> for $err_ty where
            $from_ty: $crate::error::WrappedError{
            fn from(e: $from_ty) -> Self {
                Self::$variant(e)
            }
        }
        )*

        impl std::error::Error for $err_ty {}

        impl $crate::error::WrappedError for $err_ty {}
    };
}