lxmf-wire 0.2.0

Core LXMF wire format, message primitives, and identity helpers for LXMF-rs.
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

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MessageState {
    Generating = 0x00,
    Outbound = 0x01,
    Sending = 0x02,
    Sent = 0x04,
    Delivered = 0x08,
    Rejected = 0xFD,
    Cancelled = 0xFE,
    Failed = 0xFF,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MessageMethod {
    Unknown = 0x00,
    Packet = 0x01,
    Resource = 0x02,
    Paper = 0x05,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransportMethod {
    Opportunistic = 0x01,
    Direct = 0x02,
    Propagated = 0x03,
    Paper = 0x05,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UnverifiedReason {
    SourceUnknown = 0x01,
    SignatureInvalid = 0x02,
}

impl MessageState {
    pub fn as_u8(self) -> u8 {
        self as u8
    }
}

impl TryFrom<u8> for MessageState {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0x00 => Ok(MessageState::Generating),
            0x01 => Ok(MessageState::Outbound),
            0x02 => Ok(MessageState::Sending),
            0x04 => Ok(MessageState::Sent),
            0x08 => Ok(MessageState::Delivered),
            0xFD => Ok(MessageState::Rejected),
            0xFE => Ok(MessageState::Cancelled),
            0xFF => Ok(MessageState::Failed),
            _ => Err(()),
        }
    }
}

impl UnverifiedReason {
    pub fn as_u8(self) -> u8 {
        self as u8
    }
}

impl TryFrom<u8> for UnverifiedReason {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0x01 => Ok(UnverifiedReason::SourceUnknown),
            0x02 => Ok(UnverifiedReason::SignatureInvalid),
            _ => Err(()),
        }
    }
}

impl MessageMethod {
    pub fn as_u8(self) -> u8 {
        self as u8
    }
}

impl TryFrom<u8> for MessageMethod {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0x00 => Ok(MessageMethod::Unknown),
            0x01 => Ok(MessageMethod::Packet),
            0x02 => Ok(MessageMethod::Resource),
            0x05 => Ok(MessageMethod::Paper),
            _ => Err(()),
        }
    }
}

impl TransportMethod {
    pub fn as_u8(self) -> u8 {
        self as u8
    }
}

impl TryFrom<u8> for TransportMethod {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0x01 => Ok(TransportMethod::Opportunistic),
            0x02 => Ok(TransportMethod::Direct),
            0x03 => Ok(TransportMethod::Propagated),
            0x05 => Ok(TransportMethod::Paper),
            _ => Err(()),
        }
    }
}