1use protocol::{ThriftTyped, Encode, Protocol, Type, MessageType};
2use transport::Transport;
3
4use {Result};
5
6pub type VirtualEncodeObject<'e> = &'e for<'p, 't> VirtualEncode<VirtualProtocolObject<'p>, &'t mut Transport>;
7pub type VirtualProtocolObject<'p> = &'p mut for<'t> VirtualProtocol<&'t mut Transport>;
8
9pub trait VirtualEncode<P, T>: ThriftTyped {
10 fn virt_encode(&self, P, T) -> Result<()>;
11
12 fn should_encode(&self) -> bool { true }
13}
14
15impl<E, P, T> VirtualEncode<P, T> for E
16where E: Encode, P: Protocol, T: Transport {
17 fn virt_encode(&self, mut protocol: P, mut transport: T) -> Result<()> {
18 self.encode(&mut protocol, &mut transport)
19 }
20
21 fn should_encode(&self) -> bool { Encode::should_encode(self) }
22}
23
24impl<'e> Encode for VirtualEncodeObject<'e> {
25 fn encode<'p, 't, P1, T1>(&self, mut protocol: &'p mut P1, mut transport: &'t mut T1) -> Result<()>
26 where P1: Protocol, T1: Transport {
27 let protocol: VirtualProtocolObject<'p> = protocol;
28 (*self).virt_encode(protocol, &mut transport)
29 }
30}
31
32pub trait VirtualProtocol<T> {
33 fn virt_write_message_begin(
34 &mut self,
35 transport: T,
36 name: &str,
37 message_type: MessageType,
38 sequence_id: i32
39 ) -> Result<()>;
40 fn virt_write_message_end(&mut self, transport: T) -> Result<()>;
41
42 fn virt_write_struct_begin(&mut self, transport: T, name: &str) -> Result<()>;
43 fn virt_write_struct_end(&mut self, transport: T) -> Result<()>;
44
45 fn virt_write_field_begin(
46 &mut self,
47 transport: T,
48 name: &str,
49 field_type: Type,
50 field_id: i16
51 ) -> Result<()>;
52 fn virt_write_field_end(&mut self, transport: T) -> Result<()>;
53 fn virt_write_field_stop(&mut self, transport: T) -> Result<()>;
54
55 fn virt_write_map_begin(
56 &mut self,
57 transport: T,
58 key_type: Type,
59 value_type: Type,
60 size: usize
61 ) -> Result<()>;
62 fn virt_write_map_end(&mut self, transport: T) -> Result<()>;
63
64 fn virt_write_list_begin(&mut self, transport: T, elem_type: Type, size: usize) -> Result<()>;
65 fn virt_write_list_end(&mut self, transport: T) -> Result<()>;
66
67 fn virt_write_set_begin(&mut self, transport: T, elem_type: Type, size: usize) -> Result<()>;
68 fn virt_write_set_end(&mut self, transport: T) -> Result<()>;
69
70 fn virt_write_bool(&mut self, transport: T, value: bool) -> Result<()>;
71 fn virt_write_byte(&mut self, transport: T, value: i8) -> Result<()>;
72 fn virt_write_i16(&mut self, transport: T, value: i16) -> Result<()>;
73 fn virt_write_i32(&mut self, transport: T, value: i32) -> Result<()>;
74 fn virt_write_i64(&mut self, transport: T, value: i64) -> Result<()>;
75 fn virt_write_double(&mut self, transport: T, value: f64) -> Result<()>;
76 fn virt_write_str(&mut self, transport: T, value: &str) -> Result<()>;
77 fn virt_write_string(&mut self, transport: T, value: &String) -> Result<()>;
78 fn virt_write_binary(&mut self, transport: T, value: &[u8]) -> Result<()>;
79
80 fn virt_read_message_begin(&mut self, transport: T) -> Result<(String, MessageType, i32)>;
81 fn virt_read_message_end(&mut self, transport: T) -> Result<()>;
82
83 fn virt_read_struct_begin(&mut self, transport: T) -> Result<String>;
84 fn virt_read_struct_end(&mut self, transport: T) -> Result<()>;
85
86 fn virt_read_field_begin(&mut self, transport: T) -> Result<(String, Type, i16)>;
87 fn virt_read_field_end(&mut self, transport: T) -> Result<()>;
88
89 fn virt_read_map_begin(&mut self, transport: T) -> Result<(Type, Type, i32)>;
90 fn virt_read_map_end(&mut self, transport: T) -> Result<()>;
91
92 fn virt_read_list_begin(&mut self, transport: T) -> Result<(Type, i32)>;
93 fn virt_read_list_end(&mut self, transport: T) -> Result<()>;
94
95 fn virt_read_set_begin(&mut self, transport: T) -> Result<(Type, i32)>;
96 fn virt_read_set_end(&mut self, transport: T) -> Result<()>;
97
98 fn virt_read_bool(&mut self, transport: T) -> Result<bool>;
99 fn virt_read_byte(&mut self, transport: T) -> Result<i8>;
100 fn virt_read_i16(&mut self, transport: T) -> Result<i16>;
101 fn virt_read_i32(&mut self, transport: T) -> Result<i32>;
102 fn virt_read_i64(&mut self, transport: T) -> Result<i64>;
103 fn virt_read_double(&mut self, transport: T) -> Result<f64>;
104 fn virt_read_string(&mut self, transport: T) -> Result<String>;
105 fn virt_read_binary(&mut self, transport: T) -> Result<Vec<u8>>;
106
107 fn virt_skip(&mut self, transport: T, type_: Type) -> Result<()>;
108}
109
110impl<P, T> VirtualProtocol<T> for P where P: Protocol, T: Transport {
111 fn virt_write_message_begin(&mut self, mut transport: T, name: &str,
112 message_type: MessageType, sequence_id: i32) -> Result<()> {
113 Protocol::write_message_begin(self, &mut transport, name, message_type, sequence_id)
114 }
115
116 fn virt_write_message_end(&mut self, mut transport: T) -> Result<()> {
117 Protocol::write_message_end(self, &mut transport)
118 }
119
120 fn virt_write_struct_begin(&mut self, mut transport: T, name: &str) -> Result<()> {
121 Protocol::write_struct_begin(self, &mut transport, name)
122 }
123
124 fn virt_write_struct_end(&mut self, mut transport: T) -> Result<()> {
125 Protocol::write_struct_end(self, &mut transport)
126 }
127
128 fn virt_write_field_begin(&mut self, mut transport: T, name: &str,
129 field_type: Type, field_id: i16) -> Result<()> {
130 Protocol::write_field_begin(self, &mut transport, name, field_type, field_id)
131 }
132
133 fn virt_write_field_end(&mut self, mut transport: T) -> Result<()> {
134 Protocol::write_field_end(self, &mut transport)
135 }
136
137 fn virt_write_field_stop(&mut self, mut transport: T) -> Result<()> {
138 Protocol::write_field_stop(self, &mut transport)
139 }
140
141 fn virt_write_map_begin(&mut self, mut transport: T, key_type: Type,
142 value_type: Type, size: usize) -> Result<()> {
143 Protocol::write_map_begin(self, &mut transport, key_type, value_type, size)
144 }
145
146 fn virt_write_map_end(&mut self, mut transport: T) -> Result<()> {
147 Protocol::write_map_end(self, &mut transport)
148 }
149
150 fn virt_write_list_begin(&mut self, mut transport: T, elem_type: Type, size: usize) -> Result<()> {
151 Protocol::write_list_begin(self, &mut transport, elem_type, size)
152 }
153
154 fn virt_write_list_end(&mut self, mut transport: T) -> Result<()> {
155 Protocol::write_list_end(self, &mut transport)
156 }
157
158 fn virt_write_set_begin(&mut self, mut transport: T, elem_type: Type, size: usize) -> Result<()> {
159 Protocol::write_set_begin(self, &mut transport, elem_type, size)
160 }
161
162 fn virt_write_set_end(&mut self, mut transport: T) -> Result<()> {
163 Protocol::write_set_end(self, &mut transport)
164 }
165
166 fn virt_write_bool(&mut self, mut transport: T, value: bool) -> Result<()> {
167 Protocol::write_bool(self, &mut transport, value)
168 }
169
170 fn virt_write_byte(&mut self, mut transport: T, value: i8) -> Result<()> {
171 Protocol::write_byte(self, &mut transport, value)
172 }
173
174 fn virt_write_i16(&mut self, mut transport: T, value: i16) -> Result<()> {
175 Protocol::write_i16(self, &mut transport, value)
176 }
177
178 fn virt_write_i32(&mut self, mut transport: T, value: i32) -> Result<()> {
179 Protocol::write_i32(self, &mut transport, value)
180 }
181
182 fn virt_write_i64(&mut self, mut transport: T, value: i64) -> Result<()> {
183 Protocol::write_i64(self, &mut transport, value)
184 }
185
186 fn virt_write_double(&mut self, mut transport: T, value: f64) -> Result<()> {
187 Protocol::write_double(self, &mut transport, value)
188 }
189
190 fn virt_write_str(&mut self, mut transport: T, value: &str) -> Result<()> {
191 Protocol::write_str(self, &mut transport, value)
192 }
193
194 fn virt_write_string(&mut self, mut transport: T, value: &String) -> Result<()> {
195 Protocol::write_string(self, &mut transport, value)
196 }
197
198 fn virt_write_binary(&mut self, mut transport: T, value: &[u8]) -> Result<()> {
199 Protocol::write_binary(self, &mut transport, value)
200 }
201
202 fn virt_read_message_begin(&mut self, mut transport: T) -> Result<(String, MessageType, i32)> {
203 Protocol::read_message_begin(self, &mut transport)
204 }
205
206 fn virt_read_message_end(&mut self, mut transport: T) -> Result<()> {
207 Protocol::read_message_end(self, &mut transport)
208 }
209
210 fn virt_read_struct_begin(&mut self, mut transport: T) -> Result<String> {
211 Protocol::read_struct_begin(self, &mut transport)
212 }
213
214 fn virt_read_struct_end(&mut self, mut transport: T) -> Result<()> {
215 Protocol::read_struct_end(self, &mut transport)
216 }
217
218 fn virt_read_field_begin(&mut self, mut transport: T) -> Result<(String, Type, i16)> {
219 Protocol::read_field_begin(self, &mut transport)
220 }
221
222 fn virt_read_field_end(&mut self, mut transport: T) -> Result<()> {
223 Protocol::read_field_end(self, &mut transport)
224 }
225
226 fn virt_read_map_begin(&mut self, mut transport: T) -> Result<(Type, Type, i32)> {
227 Protocol::read_map_begin(self, &mut transport)
228 }
229
230 fn virt_read_map_end(&mut self, mut transport: T) -> Result<()> {
231 Protocol::read_map_end(self, &mut transport)
232 }
233
234 fn virt_read_list_begin(&mut self, mut transport: T) -> Result<(Type, i32)> {
235 Protocol::read_list_begin(self, &mut transport)
236 }
237
238 fn virt_read_list_end(&mut self, mut transport: T) -> Result<()> {
239 Protocol::read_list_end(self, &mut transport)
240 }
241
242 fn virt_read_set_begin(&mut self, mut transport: T) -> Result<(Type, i32)> {
243 Protocol::read_set_begin(self, &mut transport)
244 }
245
246 fn virt_read_set_end(&mut self, mut transport: T) -> Result<()> {
247 Protocol::read_set_end(self, &mut transport)
248 }
249
250 fn virt_read_bool(&mut self, mut transport: T) -> Result<bool> {
251 Protocol::read_bool(self, &mut transport)
252 }
253
254 fn virt_read_byte(&mut self, mut transport: T) -> Result<i8> {
255 Protocol::read_byte(self, &mut transport)
256 }
257
258 fn virt_read_i16(&mut self, mut transport: T) -> Result<i16> {
259 Protocol::read_i16(self, &mut transport)
260 }
261
262 fn virt_read_i32(&mut self, mut transport: T) -> Result<i32> {
263 Protocol::read_i32(self, &mut transport)
264 }
265
266 fn virt_read_i64(&mut self, mut transport: T) -> Result<i64> {
267 Protocol::read_i64(self, &mut transport)
268 }
269
270 fn virt_read_double(&mut self, mut transport: T) -> Result<f64> {
271 Protocol::read_double(self, &mut transport)
272 }
273
274 fn virt_read_string(&mut self, mut transport: T) -> Result<String> {
275 Protocol::read_string(self, &mut transport)
276 }
277
278 fn virt_read_binary(&mut self, mut transport: T) -> Result<Vec<u8>> {
279 Protocol::read_binary(self, &mut transport)
280 }
281
282 fn virt_skip(&mut self, mut transport: T, type_: Type) -> Result<()> {
283 Protocol::skip(self, &mut transport, type_)
284 }
285}
286
287impl<'p> Protocol for VirtualProtocolObject<'p> {
288 fn write_message_begin<T: Transport>(&mut self, transport: &mut T, name: &str,
289 message_type: MessageType, sequence_id: i32) -> Result<()> {
290 (*self).virt_write_message_begin(transport, name, message_type, sequence_id)
291 }
292
293 fn write_message_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
294 (*self).virt_write_message_end(transport)
295 }
296
297 fn write_struct_begin<T: Transport>(&mut self, transport: &mut T, name: &str) -> Result<()> {
298 (*self).virt_write_struct_begin(transport, name)
299 }
300
301 fn write_struct_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
302 (*self).virt_write_struct_end(transport)
303 }
304
305 fn write_field_begin<T: Transport>(&mut self, transport: &mut T, name: &str,
306 field_type: Type, field_id: i16) -> Result<()> {
307 (*self).virt_write_field_begin(transport, name, field_type, field_id)
308 }
309
310 fn write_field_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
311 (*self).virt_write_field_end(transport)
312 }
313
314 fn write_field_stop<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
315 (*self).virt_write_field_stop(transport)
316 }
317
318 fn write_map_begin<T: Transport>(&mut self, transport: &mut T, key_type: Type,
319 value_type: Type, size: usize) -> Result<()> {
320 (*self).virt_write_map_begin(transport, key_type, value_type, size)
321 }
322
323 fn write_map_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
324 (*self).virt_write_map_end(transport)
325 }
326
327 fn write_list_begin<T: Transport>(&mut self, transport: &mut T, elem_type: Type, size: usize) -> Result<()> {
328 (*self).virt_write_list_begin(transport, elem_type, size)
329 }
330
331 fn write_list_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
332 (*self).virt_write_list_end(transport)
333 }
334
335 fn write_set_begin<T: Transport>(&mut self, transport: &mut T, elem_type: Type, size: usize) -> Result<()> {
336 (*self).virt_write_set_begin(transport, elem_type, size)
337 }
338
339 fn write_set_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
340 (*self).virt_write_set_end(transport)
341 }
342
343 fn write_bool<T: Transport>(&mut self, transport: &mut T, value: bool) -> Result<()> {
344 (*self).virt_write_bool(transport, value)
345 }
346
347 fn write_byte<T: Transport>(&mut self, transport: &mut T, value: i8) -> Result<()> {
348 (*self).virt_write_byte(transport, value)
349 }
350
351 fn write_i16<T: Transport>(&mut self, transport: &mut T, value: i16) -> Result<()> {
352 (*self).virt_write_i16(transport, value)
353 }
354
355 fn write_i32<T: Transport>(&mut self, transport: &mut T, value: i32) -> Result<()> {
356 (*self).virt_write_i32(transport, value)
357 }
358
359 fn write_i64<T: Transport>(&mut self, transport: &mut T, value: i64) -> Result<()> {
360 (*self).virt_write_i64(transport, value)
361 }
362
363 fn write_double<T: Transport>(&mut self, transport: &mut T, value: f64) -> Result<()> {
364 (*self).virt_write_double(transport, value)
365 }
366
367 fn write_str<T: Transport>(&mut self, transport: &mut T, value: &str) -> Result<()> {
368 (*self).virt_write_str(transport, value)
369 }
370
371 fn write_string<T: Transport>(&mut self, transport: &mut T, value: &String) -> Result<()> {
372 (*self).virt_write_string(transport, value)
373 }
374
375 fn write_binary<T: Transport>(&mut self, transport: &mut T, value: &[u8]) -> Result<()> {
376 (*self).virt_write_binary(transport, value)
377 }
378
379 fn read_message_begin<T: Transport>(&mut self, transport: &mut T) -> Result<(String, MessageType, i32)> {
380 (*self).virt_read_message_begin(transport)
381 }
382
383 fn read_message_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
384 (*self).virt_read_message_end(transport)
385 }
386
387 fn read_struct_begin<T: Transport>(&mut self, transport: &mut T) -> Result<String> {
388 (*self).virt_read_struct_begin(transport)
389 }
390
391 fn read_struct_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
392 (*self).virt_read_struct_end(transport)
393 }
394
395 fn read_field_begin<T: Transport>(&mut self, transport: &mut T) -> Result<(String, Type, i16)> {
396 (*self).virt_read_field_begin(transport)
397 }
398
399 fn read_field_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
400 (*self).virt_read_field_end(transport)
401 }
402
403 fn read_map_begin<T: Transport>(&mut self, transport: &mut T) -> Result<(Type, Type, i32)> {
404 (*self).virt_read_map_begin(transport)
405 }
406
407 fn read_map_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
408 (*self).virt_read_map_end(transport)
409 }
410
411 fn read_list_begin<T: Transport>(&mut self, transport: &mut T) -> Result<(Type, i32)> {
412 (*self).virt_read_list_begin(transport)
413 }
414
415 fn read_list_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
416 (*self).virt_read_list_end(transport)
417 }
418
419 fn read_set_begin<T: Transport>(&mut self, transport: &mut T) -> Result<(Type, i32)> {
420 (*self).virt_read_set_begin(transport)
421 }
422
423 fn read_set_end<T: Transport>(&mut self, transport: &mut T) -> Result<()> {
424 (*self).virt_read_set_end(transport)
425 }
426
427 fn read_bool<T: Transport>(&mut self, transport: &mut T) -> Result<bool> {
428 (*self).virt_read_bool(transport)
429 }
430
431 fn read_byte<T: Transport>(&mut self, transport: &mut T) -> Result<i8> {
432 (*self).virt_read_byte(transport)
433 }
434
435 fn read_i16<T: Transport>(&mut self, transport: &mut T) -> Result<i16> {
436 (*self).virt_read_i16(transport)
437 }
438
439 fn read_i32<T: Transport>(&mut self, transport: &mut T) -> Result<i32> {
440 (*self).virt_read_i32(transport)
441 }
442
443 fn read_i64<T: Transport>(&mut self, transport: &mut T) -> Result<i64> {
444 (*self).virt_read_i64(transport)
445 }
446
447 fn read_double<T: Transport>(&mut self, transport: &mut T) -> Result<f64> {
448 (*self).virt_read_double(transport)
449 }
450
451 fn read_string<T: Transport>(&mut self, transport: &mut T) -> Result<String> {
452 (*self).virt_read_string(transport)
453 }
454
455 fn read_binary<T: Transport>(&mut self, transport: &mut T) -> Result<Vec<u8>> {
456 (*self).virt_read_binary(transport)
457 }
458
459 fn skip<T: Transport>(&mut self, transport: &mut T, type_: Type) -> Result<()> {
460 (*self).virt_skip(transport, type_)
461 }
462}
463
464fn _test_virt_impls() {
465 fn _is_encode<E: Encode + ?Sized>() {}
466 fn _is_protocol<P: Protocol + ?Sized>() {}
467 fn _is_transport<T: Transport + ?Sized>() {}
468
469 _is_transport::<&mut Transport>();
470 _is_protocol::<&mut VirtualProtocolObject>();
471 _is_encode::<&VirtualEncodeObject>();
472}
473