dittolive-ditto 4.9.3

Ditto is a peer to peer cross-platform database that allows mobile, web, IoT and server apps to sync with or without an internet connection.
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

use super::*;

/// An inbound message, that must be handled by the callback set on a [`StreamCandidate`].
///
/// It simply wraps a [`Payload`] (which it notably [`Deref`]s to) such that additional metadata
/// about an inbound message can be provided without breaking changes in the future.
pub struct Inbound(pub(crate) bus::Inbound);

impl Inbound {
    /// The payload of the inbound message.
    ///
    /// You may also access it though the [`Deref`] and [`DerefMut`] implementations.
    pub fn payload(&self) -> &Payload {
        &self.0.payload
    }
}

impl core::ops::Deref for Inbound {
    type Target = Payload;
    fn deref(&self) -> &Self::Target {
        &self.0.payload
    }
}

impl core::ops::DerefMut for Inbound {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0.payload
    }
}

impl From<Inbound> for Payload {
    fn from(value: Inbound) -> Self {
        value.0.payload
    }
}

impl core::fmt::Debug for Inbound {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Inbound")
            .field("payload", self.payload())
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_inbound() {
        let payload = Bytes::from_static(b"hello");
        let inbound = Inbound(bus::Inbound {
            payload: payload.clone(),
        });
        assert_eq!(&*inbound, &payload);
        assert_eq!(inbound.payload(), &payload);
        assert_eq!(Payload::from(inbound), payload);
    }
}