volo 0.12.3

Volo is a high-performance and strong-extensibility Rust RPC framework that helps developers build microservices.
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

#[macro_export]
macro_rules! volo_unreachable {
    () => {
        #[cfg(not(feature = "unsafe_unchecked"))]
        unreachable!();

        #[cfg(feature = "unsafe_unchecked")]
        unsafe {
            std::hint::unreachable_unchecked();
        }
    };
    ($msg:expr $(,)?) => ({
        unreachable!($msg)
    });
    ($fmt:expr, $($arg:tt)*) => ({
        unreachable!($fmt, $($arg)*)
    });
}

#[macro_export]
#[deprecated(since = "0.8.1", note = "use `include!` instead")]
macro_rules! include_service {
    ($service: tt) => {
        include!(concat!(env!("OUT_DIR"), concat!("/", $service)));
    };
}

#[macro_export]
macro_rules! new_type {
    ($($(#[$attrs:meta])* $v:vis struct $name:ident($inner_v:vis $inner:ty);)+) => {
        $(
            $crate::new_type!(
                @attrs        [$(#[$attrs])*]
                @type         [$name]
                @inner        [$inner]
                @vis          [$v]
                @inner_vis    [$inner_v]
            );
        )+
    };



    (
        @attrs        [$(#[$attrs:meta])*]
        @type         [$type:ident]
        @inner        [$inner:ty]
        @vis          [$v:vis]
        @inner_vis    [$inner_v:vis]
    ) => {

        $(#[$attrs])*
        $v struct $type($inner_v $inner);

        impl<T> From<T> for $type where T: Into<$inner> {
            #[inline]
            fn from(t: T) -> Self {
                $type(t.into())
            }
        }

        impl ::std::ops::Deref for $type {
            type Target = $inner;

            #[inline]
            fn deref(&self) -> &Self::Target {
                &self.0
            }
        }
    }
}