canary 0.3.3

provides ergonomic abstractions for network communication and more
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

use crate::{
    serialization::formats::{Format, ReadFormat, SendFormat},
    Result,
};
use derive_more::From;
use serde::{de::DeserializeOwned, Serialize};

use super::unformatted::{RefUnformattedRawUnifiedChannel, UnformattedRawUnifiedChannel};

#[derive(From)]
/// Reference unencrypted unified channel with format
pub struct RefRawUnifiedChannel<'a, F = Format> {
    /// Inner reference to unformatted channel
    pub channel: &'a mut RefUnformattedRawUnifiedChannel<'a>,
    /// Inner format
    pub format: F,
}

impl<F> RefRawUnifiedChannel<'_, F> {
    /// Send an object through the channel
    /// ```no_run
    /// chan.send("Hello world!").await?;
    /// ```
    pub async fn send<T: Serialize>(&mut self, obj: T) -> Result<usize>
    where
        F: SendFormat,
    {
        self.channel.send(obj, &mut self.format).await
    }
    /// Receive an object sent through the channel
    /// ```no_run
    /// let string: String = chan.receive().await?;
    /// ```
    pub async fn receive<T: DeserializeOwned>(&mut self) -> Result<T>
    where
        F: ReadFormat,
    {
        self.channel.receive(&mut self.format).await
    }
}

#[derive(From)]
/// Unified unencrypted channel with format
pub struct RawUnifiedChannel<F = Format> {
    /// Inner channel
    pub channel: UnformattedRawUnifiedChannel,
    /// Inner format of channel
    pub format: F,
}

impl<F> RawUnifiedChannel<F> {
    /// Send an object through the channel
    /// ```no_run
    /// chan.send("Hello world!").await?;
    /// ```
    pub async fn send<T: Serialize>(&mut self, obj: T) -> Result<usize>
    where
        F: SendFormat,
    {
        self.channel.send(obj, &mut self.format).await
    }
    /// Receive an object sent through the channel
    /// ```no_run
    /// let string: String = chan.receive().await?;
    /// ```
    pub async fn receive<T: DeserializeOwned>(&mut self) -> Result<T>
    where
        F: ReadFormat,
    {
        self.channel.receive(&mut self.format).await
    }
}