yrs-tokio 0.1.0

Yrs synchronization protocol using tokio
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

#[macro_export]
macro_rules! impl_signal_stream_body {
    ($item_pat:pat => $item_expr:expr) => {
        type Item = Result<$crate::signaling::Message, yrs::sync::Error>;

        fn poll_next(
            mut self: ::core::pin::Pin<&mut Self>,
            cx: &mut ::core::task::Context<'_>,
        ) -> ::core::task::Poll<Option<Self::Item>> {
            let inner = ::core::pin::Pin::new(&mut self.0);
            match inner.poll_next(cx) {
                ::core::task::Poll::Ready(Some(Ok($item_pat))) => {
                    ::core::task::Poll::Ready(Some(Ok($item_expr)))
                }
                ::core::task::Poll::Ready(Some(Err(e))) => {
                    ::core::task::Poll::Ready(Some(Err(yrs::sync::Error::Other(e.into()))))
                }
                ::core::task::Poll::Ready(None) => ::core::task::Poll::Ready(None),
                ::core::task::Poll::Pending => ::core::task::Poll::Pending,
            }
        }
    };
}

#[macro_export]
macro_rules! impl_yrs_signal_stream {
    // 带 external where 子句的泛型
    ($name:ident<$($gen:ident),+> where $($where_clause:tt)+, $item_pat:pat => $item_expr:expr) => {
        impl<$($gen),+> ::futures::stream::Stream for $name<$($gen),+>
        where
            $($gen: ::tokio::io::AsyncRead + ::tokio::io::AsyncWrite + ::core::marker::Unpin),+,
            $($($where_clause)+)?
        {
            $crate::impl_signal_stream_body!($item_pat => $item_expr);
        }
    };

    // 不带 external where 的泛型
    ($name:ident<$($gen:ident),+>, $item_pat:pat => $item_expr:expr) => {
        impl<$($gen),+> ::futures::stream::Stream for $name<$($gen),+>
        where
            $($gen: ::tokio::io::AsyncRead + ::tokio::io::AsyncWrite + ::core::marker::Unpin),+
        {
            $crate::impl_signal_stream_body!($item_pat => $item_expr);
        }
    };

    // 无泛型参数
    ($name:ident, $item_pat:pat => $item_expr:expr) => {
        impl ::futures::stream::Stream for $name {
            $crate::impl_signal_stream_body!($item_pat => $item_expr);
        }
    };
}

#[macro_export]
macro_rules! to_signaling_message_common {
    ($item:ident, custom $($user_logic:tt)*) => {
        match $item {
            Message::Text(text) => SignalingMessage::Text(text.to_string()),
            Message::Binary(bytes) => SignalingMessage::Binary(bytes.into()),
            Message::Ping(_) => SignalingMessage::Ping,
            Message::Pong(_) => SignalingMessage::Pong,
            Message::Close(_) => SignalingMessage::Close,
            $($user_logic)*
        }
    };
}

#[macro_export]
macro_rules! to_signaling_message {
    ($item:ident, frame) => {
        $crate::to_signaling_message_common!($item, custom Message::Frame(frame) => SignalingMessage::Binary(frame.into_payload().into()),)
    };

    ($item:ident, custom $($user_logic:tt)+) => {
         $crate::to_signaling_message_common!($item, custom $($user_logic)+)
    };

    ($item:ident) => {
        $crate::to_signaling_message_common!($item, custom)
    };
}

#[macro_export]
macro_rules! generate_yrs_poll_fn {
    ($fn_name:ident, $inner_expr:expr) => {
        fn $fn_name(
            mut self: ::core::pin::Pin<&mut Self>,
            cx: &mut std::task::Context<'_>,
        ) -> std::task::Poll<Result<(), Self::Error>> {
            match ::core::pin::Pin::new(&mut $inner_expr).$fn_name(cx) {
                std::task::Poll::Pending => std::task::Poll::Pending,
                std::task::Poll::Ready(Err(e)) => {
                    std::task::Poll::Ready(Err(::yrs::sync::Error::Other(e.into())))
                }
                std::task::Poll::Ready(_) => std::task::Poll::Ready(Ok(())),
            }
        }
    };
}