dittolive-ditto 4.9.2

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
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

use super::*;

/// Implementation detail for [`IntoChannel::map`].
pub struct Map<T, U, F, OverloadId, Handler> {
    pub(crate) convert: F,
    pub(crate) handler: Handler,
    pub(crate) marker: core::marker::PhantomData<(T, U, OverloadId)>,
}

impl<T, U, F, OverloadId, Handler: IntoChannel<OverloadId, U>> IntoChannel<ChannelPair, T>
    for Map<T, U, F, OverloadId, Handler>
where
    MapSender<T, U, F, Handler::Sender, OverloadId>: OneShotChannel<ChannelPair, T>,
{
    type Receiver = Handler::Receiver;
    type Sender = MapSender<T, U, F, Handler::Sender, OverloadId>;
    fn into_channel(
        self,
    ) -> (
        MapSender<T, U, F, Handler::Sender, OverloadId>,
        Self::Receiver,
    ) {
        let Map {
            convert, handler, ..
        } = self;
        let (tx, rx) = handler.into_channel();
        (
            MapSender {
                convert,
                tx,
                marker: Default::default(),
            },
            rx,
        )
    }
}

/// Implementation detail for [`IntoChannel::map`].
pub struct MapSender<T, U, F, Sender, OverloadId> {
    convert: F,
    tx: Sender,
    marker: core::marker::PhantomData<(T, U, OverloadId)>,
}
unsafe impl<T, U, F: Send, Sender: Send, OverloadId> Send
    for MapSender<T, U, F, Sender, OverloadId>
{
}
unsafe impl<T, U, F: Sync, Sender: Sync, OverloadId> Sync
    for MapSender<T, U, F, Sender, OverloadId>
{
}
impl<T, U, F, Sender, OverloadId> OneShotChannel<ChannelPair, T>
    for MapSender<T, U, F, Sender, OverloadId>
where
    OverloadId: 'static,
    U: 'static,
    T: 'static,
    F: FnOnce(T) -> U + Send + 'static + Sync,
    Sender: OneShotChannel<OverloadId, U>,
{
    fn send_infallibly_once(self, value: T) {
        self.tx.send_infallibly_once((self.convert)(value))
    }
}
impl<T, U, F, Sender, OverloadId> ConcurrentChannel<ChannelPair, T>
    for MapSender<T, U, F, Sender, OverloadId>
where
    OverloadId: 'static,
    U: 'static,
    T: 'static,
    F: Fn(T) -> U + Send + 'static + Sync,
    Sender: ConcurrentChannel<OverloadId, U>,
{
    fn send_infallibly(&self, value: T) {
        self.tx.send_infallibly((self.convert)(value))
    }
}

impl<T, U, F, Sender, OverloadId> Channel<ChannelPair, T> for MapSender<T, U, F, Sender, OverloadId>
where
    OverloadId: 'static,
    U: 'static,
    T: 'static,
    F: FnMut(T) -> U + Send + 'static + Sync,
    Sender: Channel<OverloadId, U>,
{
    fn send_infallibly_mut(&mut self, value: T) {
        self.tx.send_infallibly_mut((self.convert)(value))
    }
}