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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
module websocket
// MessageEventHandler represents a callback on a new message
struct MessageEventHandler {
handler SocketMessageFn // callback function
handler2 SocketMessageFn2 // callback function with reference
is_ref bool // true if has a reference object
ref voidptr // referenced object
}
// ErrorEventHandler represents a callback on error
struct ErrorEventHandler {
handler SocketErrorFn // callback function
handler2 SocketErrorFn2 // callback function with reference
is_ref bool // true if has a reference object
ref voidptr // referenced object
}
// OpenEventHandler represents a callback when connection is opened
struct OpenEventHandler {
handler SocketOpenFn // callback function
handler2 SocketOpenFn2 // callback function with reference
is_ref bool // true if has a reference object
ref voidptr // referenced object
}
// CloseEventHandler represents a callback on a closing event
struct CloseEventHandler {
handler SocketCloseFn // callback function
handler2 SocketCloseFn2 // callback function with reference
is_ref bool // true if has a reference object
ref voidptr // referenced object
}
pub type AcceptClientFn = fn (mut c ServerClient) ?bool
pub type SocketMessageFn = fn (mut c Client, msg &Message) ?
pub type SocketMessageFn2 = fn (mut c Client, msg &Message, v voidptr) ?
pub type SocketErrorFn = fn (mut c Client, err string) ?
pub type SocketErrorFn2 = fn (mut c Client, err string, v voidptr) ?
pub type SocketOpenFn = fn (mut c Client) ?
pub type SocketOpenFn2 = fn (mut c Client, v voidptr) ?
pub type SocketCloseFn = fn (mut c Client, code int, reason string) ?
pub type SocketCloseFn2 = fn (mut c Client, code int, reason string, v voidptr) ?
// on_connect registers a callback when client connects to the server
pub fn (mut s Server) on_connect(fun AcceptClientFn) ? {
if s.accept_client_callbacks.len > 0 {
return error('only one callback can be registered for accept client')
}
s.accept_client_callbacks << fun
}
// on_message registers a callback on new messages
pub fn (mut s Server) on_message(fun SocketMessageFn) {
s.message_callbacks << MessageEventHandler{
handler: fun
}
}
// on_message_ref registers a callback on new messages and provides a reference object
pub fn (mut s Server) on_message_ref(fun SocketMessageFn2, ref voidptr) {
s.message_callbacks << MessageEventHandler{
handler2: fun
ref: ref
is_ref: true
}
}
// on_close registers a callback on closed socket
pub fn (mut s Server) on_close(fun SocketCloseFn) {
s.close_callbacks << CloseEventHandler{
handler: fun
}
}
// on_close_ref registers a callback on closed socket and provides a reference object
pub fn (mut s Server) on_close_ref(fun SocketCloseFn2, ref voidptr) {
s.close_callbacks << CloseEventHandler{
handler2: fun
ref: ref
is_ref: true
}
}
// on_message registers a callback on new messages
pub fn (mut ws Client) on_message(fun SocketMessageFn) {
ws.message_callbacks << MessageEventHandler{
handler: fun
}
}
// on_message_ref registers a callback on new messages and provides a reference object
pub fn (mut ws Client) on_message_ref(fun SocketMessageFn2, ref voidptr) {
ws.message_callbacks << MessageEventHandler{
handler2: fun
ref: ref
is_ref: true
}
}
// on_error registers a callback on errors
pub fn (mut ws Client) on_error(fun SocketErrorFn) {
ws.error_callbacks << ErrorEventHandler{
handler: fun
}
}
// on_error_ref registers a callback on errors and provides a reference object
pub fn (mut ws Client) on_error_ref(fun SocketErrorFn2, ref voidptr) {
ws.error_callbacks << ErrorEventHandler{
handler2: fun
ref: ref
is_ref: true
}
}
// on_open registers a callback on successful opening the websocket
pub fn (mut ws Client) on_open(fun SocketOpenFn) {
ws.open_callbacks << OpenEventHandler{
handler: fun
}
}
// on_open_ref registers a callback on successful opening the websocket
// and provides a reference object
pub fn (mut ws Client) on_open_ref(fun SocketOpenFn2, ref voidptr) {
ws.open_callbacks << OpenEventHandler{
handler2: fun
ref: ref
is_ref: true
}
}
// on_close registers a callback on closed socket
pub fn (mut ws Client) on_close(fun SocketCloseFn) {
ws.close_callbacks << CloseEventHandler{
handler: fun
}
}
// on_close_ref registers a callback on closed socket and provides a reference object
pub fn (mut ws Client) on_close_ref(fun SocketCloseFn2, ref voidptr) {
ws.close_callbacks << CloseEventHandler{
handler2: fun
ref: ref
is_ref: true
}
}
// send_connect_event invokes the on_connect callback
fn (mut s Server) send_connect_event(mut c ServerClient) ?bool {
if s.accept_client_callbacks.len == 0 {
// If no callback all client will be accepted
return true
}
fun := s.accept_client_callbacks[0]
res := fun(mut c) ?
return res
}
// send_message_event invokes the on_message callback
fn (mut ws Client) send_message_event(msg &Message) {
ws.debug_log('sending on_message event')
for ev_handler in ws.message_callbacks {
if !ev_handler.is_ref {
ev_handler.handler(ws, msg) or { ws.logger.error('send_message_event error: $err') }
} else {
ev_handler.handler2(ws, msg, ev_handler.ref) or {
ws.logger.error('send_message_event error: $err')
}
}
}
}
// send_error_event invokes the on_error callback
fn (mut ws Client) send_error_event(error string) {
ws.debug_log('sending on_error event')
for ev_handler in ws.error_callbacks {
if !ev_handler.is_ref {
ev_handler.handler(mut ws, error) or {
ws.logger.error('send_error_event error: $error, err: $err')
}
} else {
ev_handler.handler2(mut ws, error, ev_handler.ref) or {
ws.logger.error('send_error_event error: $error, err: $err')
}
}
}
}
// send_close_event invokes the on_close callback
fn (mut ws Client) send_close_event(code int, reason string) {
ws.debug_log('sending on_close event')
for ev_handler in ws.close_callbacks {
if !ev_handler.is_ref {
ev_handler.handler(mut ws, code, reason) or {
ws.logger.error('send_close_event error: $err')
}
} else {
ev_handler.handler2(mut ws, code, reason, ev_handler.ref) or {
ws.logger.error('send_close_event error: $err')
}
}
}
}
// send_open_event invokes the on_open callback
fn (mut ws Client) send_open_event() {
ws.debug_log('sending on_open event')
for ev_handler in ws.open_callbacks {
if !ev_handler.is_ref {
ev_handler.handler(mut ws) or { ws.logger.error('send_open_event error: $err') }
} else {
ev_handler.handler2(mut ws, ev_handler.ref) or {
ws.logger.error('send_open_event error: $err')
}
}
}
}
|
