fws_actors 0.1.0

fastwebsockets clients and servers in actors.
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

//From Req It

use std::future::Future;

use fastwebsockets::{FragmentCollectorRead, Frame, WebSocketError, WebSocketRead, WebSocketWrite};

use hyper::upgrade::Upgraded;

use hyper_util::rt::TokioIo;

use tokio::io::{ReadHalf, WriteHalf};



pub type WebSocketReadHalf = WebSocketRead<ReadHalf<TokioIo<Upgraded>>>;

pub type WebSocketWriteHalf = WebSocketWrite<WriteHalf<TokioIo<Upgraded>>>;

//#[derive(Debug)]
pub enum WebSocketReader
{

    WebSocketRead(WebSocketReadHalf),
    FragmentCollectorRead(FragmentCollectorRead<ReadHalf<TokioIo<Upgraded>>>)

}

impl WebSocketReader
{

    pub fn is_web_socket_reader(&self) -> bool
    {

        if let WebSocketReader::WebSocketRead(_) = self
        {
            
            return true;

        }

        false

    }

    pub fn is_fragment_collector_read(&self) -> bool
    {

        if let WebSocketReader::FragmentCollectorRead(_) = self
        {
            
            return true;

        }

        false

    }

    pub async fn read_frame<R, E>(&mut self, send_fn: &mut impl FnMut(Frame<'_>) -> R) -> Result<Frame<'_>, WebSocketError>
        where E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
              R: Future<Output = Result<(), E>>
    {

        match self
        {

            WebSocketReader::WebSocketRead(ws) =>
            {

                ws.read_frame(send_fn).await

            },
            WebSocketReader::FragmentCollectorRead(fc) =>
            {

                fc.read_frame(send_fn).await

            }

        }

    }

    /*
    pub async fn write_frame(&mut self, frame: Frame<'_>) -> Result<(), WebSocketError>
    {

        match self
        {

            WebSocketReader::WebSocket(ws) =>
            {

                ws.write_frame(frame).await

            },
            WebSocketReader::FragmentCollector(fc) =>
            {

                fc.write_frame(frame).await

            }

        }

    }

    pub fn into_inner(self) -> TokioIo<Upgraded>
    {

        match self
        {

            WebSocketReader::WebSocketRead(ws) =>
            {

                ws.into_inner()

            },
            WebSocketReader::FragmentCollectorRead(fc) =>
            {

                fc.into_inner()

            }

        }

    }

    pub async fn shutdown(self) -> Result<(), std::io::Error>
    {

        self.into_inner().shutdown().await

    }
    */
    
}