libzrpc 0.1.0

A RPC library for Rust
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 serde::{Deserialize, Serialize};

pub trait ZRpcDtAuto {
    fn to_zdt(&self) -> ZRpcDt;
}

impl ZRpcDtAuto for &str {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::String(self.to_string())
    }
}

impl ZRpcDtAuto for String {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::String(self.clone())
    }
}

impl ZRpcDtAuto for i8 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::Int8(*self)
    }
}

impl ZRpcDtAuto for i16 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::Int16(*self)
    }
}

impl ZRpcDtAuto for i32 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::Int32(*self)
    }
}

impl ZRpcDtAuto for i64 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::Int64(*self)
    }
}

impl ZRpcDtAuto for u8 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::UInt8(*self)
    }
}

impl ZRpcDtAuto for u16 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::UInt16(*self)
    }
}

impl ZRpcDtAuto for u32 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::UInt32(*self)
    }
}

impl ZRpcDtAuto for u64 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::UInt64(*self)
    }
}

impl ZRpcDtAuto for f32 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::Float32(*self)
    }
}

impl ZRpcDtAuto for f64 {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::Float64(*self)
    }
}

impl ZRpcDtAuto for bool {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::Bool(*self)
    }
}

impl ZRpcDtAuto for Vec<u8> {
    fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::Serialized(self.clone())
    }
}

impl<T: Serialize> ZRpcDtAuto for T {
    default fn to_zdt(&self) -> ZRpcDt {
        ZRpcDt::serialize(self)
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub enum ZRpcDt {
    Int8(i8),
    Int16(i16),
    Int32(i32),
    Int64(i64),
    UInt8(u8),
    UInt16(u16),
    UInt32(u32),
    UInt64(u64),
    Float32(f32),
    Float64(f64),
    String(String),
    Bool(bool),
    Serialized(Vec<u8>),
    Ok,
}

impl ZRpcDt {
    pub fn serialize<T: Serialize>(t: T) -> Self {
        Self::Serialized(bincode::serialize(&t).expect("Failed to serialize type"))
    }

    pub fn deserialize<T: for<'de> Deserialize<'de>>(&self) -> Result<T, ()> {
        if let Self::Serialized(bytes) = self {
            bincode::deserialize::<T>(bytes).map_err(|_| ())
        } else {
            Err(())
        }
    }
}