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

#[cfg(test)]
mod test;

use crate::tags::{self, Tag};
use crate::{
    Deserialize, DeserializeError, DeserializePrimary, Enum, Serialize, SerializedValue,
    SerializedValueSlice,
};
use std::convert::Infallible;

pub trait AsUnknownVariant {
    type Value: Serialize<tags::Value>;

    fn id(&self) -> u32;
    fn value(self) -> Self::Value;
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UnknownVariant {
    id: u32,
    value: SerializedValue,
}

impl UnknownVariant {
    pub fn new(id: u32, value: SerializedValue) -> Self {
        Self { id, value }
    }

    pub fn id(&self) -> u32 {
        self.id
    }

    pub fn value(&self) -> &SerializedValueSlice {
        &self.value
    }

    pub fn into_value(self) -> SerializedValue {
        self.value
    }

    pub fn deserialize_as<T: Tag, U: Deserialize<T>>(&self) -> Result<U, DeserializeError> {
        self.value.deserialize_as()
    }

    pub fn deserialize<T: DeserializePrimary>(&self) -> Result<T, DeserializeError> {
        self.deserialize_as()
    }

    pub fn deserialize_as_value(&self) -> Result<Enum, DeserializeError> {
        self.deserialize()
    }
}

impl AsUnknownVariant for UnknownVariant {
    type Value = SerializedValue;

    fn id(&self) -> u32 {
        self.id
    }

    fn value(self) -> Self::Value {
        self.value
    }
}

impl<'a> AsUnknownVariant for &'a UnknownVariant {
    type Value = &'a SerializedValueSlice;

    fn id(&self) -> u32 {
        self.id
    }

    fn value(self) -> Self::Value {
        &self.value
    }
}

#[derive(Debug, Copy, Clone)]
pub struct UnknownVariantRef<T> {
    pub id: u32,
    pub value: T,
}

impl<T> UnknownVariantRef<T> {
    pub fn new(id: u32, value: T) -> Self {
        Self { id, value }
    }
}

impl<T: Serialize<tags::Value>> AsUnknownVariant for UnknownVariantRef<T> {
    type Value = T;

    fn id(&self) -> u32 {
        self.id
    }

    fn value(self) -> Self::Value {
        self.value
    }
}

impl AsUnknownVariant for Infallible {
    type Value = Self;

    fn id(&self) -> u32 {
        match *self {}
    }

    fn value(self) -> Self::Value {
        self
    }
}