kutil 0.0.6

Kutil utilities collection
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

/// Define a [String] error type.
///
/// It's a trivial [Option] newtype with a `new(ToString)` constructor.
///
/// The first argument is the type name. The second optional argument is a prefix for the
/// [Display](std::fmt::Display) message.
#[macro_export]
macro_rules! string_error {
    ( $type:ident $(,)? ) => {
        $crate::string_error!($type, "");
    };

    ( $type:ident, $display_prefix:literal $(,)? ) => {
        #[doc = concat!(stringify!($type), ".")]
        #[derive(Clone, Debug, Default, Hash)]
        pub struct $type(pub ::std::option::Option<::std::string::String>);

        impl $type {
            /// Constructor.
            pub fn new<ToStringT>(message: ToStringT) -> Self
            where
                ToStringT: ::std::string::ToString,
            {
                message.to_string().into()
            }
        }

        impl ::std::fmt::Display for $type {
            fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                match self.0.as_ref().filter(|message| !message.is_empty()) {
                    ::std::option::Option::Some(message) => {
                        if $display_prefix.is_empty() {
                            ::std::fmt::Display::fmt(message, formatter)
                        } else {
                            ::std::write!(formatter, "{}: {}", $display_prefix, message)
                        }
                    }

                    ::std::option::Option::None => {
                        if $display_prefix.is_empty() {
                            ::std::fmt::Display::fmt(stringify!($type), formatter)
                        } else {
                            ::std::fmt::Display::fmt($display_prefix, formatter)
                        }
                    }
                }
            }
        }

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

        impl ::std::cmp::PartialEq for $type {
            fn eq(&self, other: &Self) -> bool {
                self.0 == other.0
            }
        }

        impl ::std::cmp::Eq for $type {}

        impl ::std::convert::From<::std::string::String> for $type {
            fn from(message: ::std::string::String) -> Self {
                Self(::std::option::Option::Some(message))
            }
        }

        impl ::std::convert::From<&str> for $type {
            fn from(message: &str) -> Self {
                message.to_string().into()
            }
        }
    };
}

#[allow(unused_imports)]
pub use string_error;