aldrin-core 0.13.0

Shared core components of Aldrin, a message bus for service-oriented RPC and interprocess communication.
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::tags::{self, KeyTag, KeyTagImpl, PrimaryKeyTag};
use crate::{DeserializeError, DeserializeKey, SerializeError, SerializeKey};
use std::borrow::Cow;
use uuid::Uuid;

macro_rules! impl_primitive {
    { $ty:ty $( :primary $primary:ty )? } => {
        impl_primitive! {
            $ty $( :primary $primary )?
            :tag tags::U8, tags::I8, tags::U16, tags::I16,
                 tags::U32, tags::I32, tags::U64, tags::I64
        }
    };

    { $ty:ty $( :primary $primary:ty )? :tag $( $tag:ty ),+ } => {
        $(
            impl PrimaryKeyTag for $ty {
                type KeyTag = $primary;
            }
        )?

        $(
            impl SerializeKey<$tag> for $ty {
                fn try_as_key(&self) -> Result<<$tag as KeyTagImpl>::Key<'_>, SerializeError> {
                    (*self).try_into().map_err(|_| SerializeError::UnexpectedValue)
                }
            }

            impl DeserializeKey<$tag> for $ty {
                fn try_from_key(key: <$tag as KeyTagImpl>::Key<'_>,) -> Result<Self, DeserializeError> {
                    key.try_into().map_err(|_| DeserializeError::UnexpectedValue)
                }
            }
        )+
    };
}

impl_primitive!(u8 :primary tags::U8);
impl_primitive!(i8 :primary tags::I8);
impl_primitive!(u16 :primary tags::U16);
impl_primitive!(i16 :primary tags::I16);
impl_primitive!(u32 :primary tags::U32);
impl_primitive!(i32 :primary tags::I32);
impl_primitive!(u64 :primary tags::U64);
impl_primitive!(i64 :primary tags::I64);
impl_primitive!(usize :primary tags::U64);
impl_primitive!(isize :primary tags::I64);
impl_primitive!(u128);
impl_primitive!(i128);

impl PrimaryKeyTag for String {
    type KeyTag = tags::String;
}

impl SerializeKey<tags::String> for String {
    fn try_as_key(&self) -> Result<Cow<'_, str>, SerializeError> {
        Ok(Cow::Borrowed(self))
    }
}

impl DeserializeKey<tags::String> for String {
    fn try_from_key(key: Cow<str>) -> Result<Self, DeserializeError> {
        Ok(key.into_owned())
    }
}

impl PrimaryKeyTag for str {
    type KeyTag = tags::String;
}

impl SerializeKey<tags::String> for str {
    fn try_as_key(&self) -> Result<Cow<'_, Self>, SerializeError> {
        Ok(Cow::Borrowed(self))
    }
}

impl PrimaryKeyTag for Uuid {
    type KeyTag = tags::Uuid;
}

impl SerializeKey<tags::Uuid> for Uuid {
    fn try_as_key(&self) -> Result<Self, SerializeError> {
        Ok(*self)
    }
}

impl DeserializeKey<tags::Uuid> for Uuid {
    fn try_from_key(key: Self) -> Result<Self, DeserializeError> {
        Ok(key)
    }
}

impl<T: PrimaryKeyTag + ?Sized> PrimaryKeyTag for &T {
    type KeyTag = T::KeyTag;
}

impl<T: KeyTag, U: SerializeKey<T> + ?Sized> SerializeKey<T> for &U {
    fn try_as_key(&self) -> Result<<T::Impl as KeyTagImpl>::Key<'_>, SerializeError> {
        (**self).try_as_key()
    }
}

impl<T: PrimaryKeyTag + ?Sized> PrimaryKeyTag for &mut T {
    type KeyTag = T::KeyTag;
}

impl<T: KeyTag, U: SerializeKey<T> + ?Sized> SerializeKey<T> for &mut U {
    fn try_as_key(&self) -> Result<<T::Impl as KeyTagImpl>::Key<'_>, SerializeError> {
        (**self).try_as_key()
    }
}

impl<T: PrimaryKeyTag + ?Sized> PrimaryKeyTag for Box<T> {
    type KeyTag = T::KeyTag;
}

impl<T: KeyTag, U: SerializeKey<T> + ?Sized> SerializeKey<T> for Box<U> {
    fn try_as_key(&self) -> Result<<T::Impl as KeyTagImpl>::Key<'_>, SerializeError> {
        (**self).try_as_key()
    }
}

impl<T: KeyTag, U: DeserializeKey<T>> DeserializeKey<T> for Box<U> {
    fn try_from_key(key: <T::Impl as KeyTagImpl>::Key<'_>) -> Result<Self, DeserializeError> {
        U::try_from_key(key).map(Self::new)
    }
}