libratman 0.7.0

Ratman types, client, and interface library
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::{
    frame::{
        parse::{take_address, take_id},
        FrameGenerator, FrameParser,
    },
    types::{Address, Ident32, Recipient},
    Result,
};
use nom::IResult;

/// Create a new subscription
pub struct SubsCreate {
    pub addr: Address,
    pub recipient: Recipient,
}

impl FrameGenerator for SubsCreate {
    fn generate(self, buf: &mut Vec<u8>) -> Result<()> {
        self.addr.generate(buf)?;
        Some(self.recipient).generate(buf)?;
        Ok(())
    }
}

impl FrameParser for SubsCreate {
    type Output = Self;
    fn parse(input: &[u8]) -> IResult<&[u8], Self::Output> {
        let (input, addr) = take_address(input)?;
        let (input, recipient) = Option::<Recipient>::parse(input)?;
        Ok((
            input,
            Self {
                addr,
                recipient: recipient.unwrap(),
            },
        ))
    }
}

/// Delete an existing subscription
pub struct SubsDelete {
    pub sub_id: Ident32,
    pub addr: Address,
}

impl FrameParser for SubsDelete {
    type Output = Self;
    fn parse(input: &[u8]) -> IResult<&[u8], Self::Output> {
        let (input, sub_id) = take_id(input)?;
        let (input, addr) = take_address(input)?;
        Ok((input, Self { sub_id, addr }))
    }
}

impl FrameGenerator for SubsDelete {
    fn generate(self, buf: &mut Vec<u8>) -> Result<()> {
        Some(self.sub_id).generate(buf)?;
        self.addr.generate(buf)?;
        Ok(())
    }
}

/// Restore a previous subscription
pub struct SubsRestore {
    pub sub_id: Ident32,
    pub addr: Address,
}

impl FrameGenerator for SubsRestore {
    fn generate(self, buf: &mut Vec<u8>) -> Result<()> {
        Some(self.sub_id).generate(buf)?;
        self.addr.generate(buf)?;
        Ok(())
    }
}

impl FrameParser for SubsRestore {
    type Output = Self;
    fn parse(input: &[u8]) -> IResult<&[u8], Self::Output> {
        let (input, sub_id) = take_id(input)?;
        let (input, addr) = take_address(input)?;
        Ok((input, Self { sub_id, addr }))
    }
}

/// Request to send a single data stream
pub struct RecvOne {
    pub addr: Address,
    pub to: Recipient,
}

impl FrameGenerator for RecvOne {
    fn generate(self, buf: &mut Vec<u8>) -> Result<()> {
        self.addr.generate(buf)?;
        Some(self.to).generate(buf)?;
        Ok(())
    }
}

impl FrameParser for RecvOne {
    type Output = Self;
    fn parse(input: &[u8]) -> IResult<&[u8], Self::Output> {
        let (input, addr) = take_address(input)?;
        let (input, to) = Option::<Recipient>::parse(input)?;
        Ok((
            input,
            Self {
                addr,
                to: to.expect("invalid RecvOne payload"),
            },
        ))
    }
}

/// Receive many data streams
pub struct RecvMany {
    pub addr: Address,
    pub to: Recipient,
    pub limit: Option<u32>,
}

impl FrameGenerator for RecvMany {
    fn generate(self, buf: &mut Vec<u8>) -> Result<()> {
        self.addr.generate(buf)?;
        Some(self.to).generate(buf)?;
        self.limit.generate(buf)?;
        Ok(())
    }
}

impl FrameParser for RecvMany {
    type Output = Self;
    fn parse(input: &[u8]) -> IResult<&[u8], Self::Output> {
        let (input, addr) = take_address(input)?;
        let (input, to) = Option::<Recipient>::parse(input)?;
        let (input, limit) = Option::<u32>::parse(input)?;
        Ok((
            input,
            Self {
                addr,
                to: to.expect("invalid RecvOne payload"),
                limit,
            },
        ))
    }
}