tokio_thrift/protocol/
mod.rs

1pub mod binary_protocol;
2pub use self::binary_protocol::BinaryProtocol;
3
4use std::{io, convert, error, fmt};
5use byteorder;
6use std::string::FromUtf8Error;
7
8#[derive(Debug)]
9pub enum Error {
10    EOF,
11    Byteorder(byteorder::Error),
12    Io(io::Error),
13    Utf8Error(FromUtf8Error),
14    BadVersion,
15    ProtocolVersionMissing,
16}
17
18impl fmt::Display for Error {
19    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
20        fmt::Debug::fmt(self, f)
21    }
22}
23
24impl error::Error for Error {
25    fn description(&self) -> &str {
26        match self {
27            &Error::EOF => "eof",
28            &Error::Byteorder(_) => "internal error of byteorder",
29            &Error::Io(_) => "internal error of io",
30            &Error::Utf8Error(_) => "internal error of utf8 conversion",
31            &Error::BadVersion => "bad version",
32            &Error::ProtocolVersionMissing => "protocol version missing",
33        }
34    }
35
36    fn cause(&self) -> Option<&error::Error> {
37        match self {
38            &Error::EOF => None,
39            &Error::Byteorder(ref e) => Some(e),
40            &Error::Io(ref e) => Some(e),
41            &Error::Utf8Error(ref e) => Some(e),
42            &Error::BadVersion => None,
43            &Error::ProtocolVersionMissing => None,
44        }
45    }
46}
47
48
49impl convert::From<byteorder::Error> for Error {
50    fn from(err: byteorder::Error) -> Error {
51        match err {
52            byteorder::Error::UnexpectedEOF => Error::EOF,
53            err => Error::Byteorder(err),
54        }
55    }
56}
57
58impl convert::From<FromUtf8Error> for Error {
59    fn from(err: FromUtf8Error) -> Error {
60        Error::Utf8Error(err)
61    }
62}
63
64impl convert::From<io::Error> for Error {
65    fn from(err: io::Error) -> Error {
66        Error::Io(err)
67    }
68}
69
70impl convert::From<Error> for io::Error {
71    fn from(err: Error) -> io::Error {
72        match err {
73            Error::Io(e) => e,
74            e => io::Error::new(io::ErrorKind::InvalidData, e),
75        }
76    }
77}
78
79
80#[derive(PartialEq, Eq, Debug)]
81pub enum ThriftType {
82    Stop = 0,
83    Void = 1,
84    Bool = 2,
85    Byte = 3,
86    Double = 4,
87    I16 = 6,
88    I32 = 8,
89    U64 = 9,
90    I64 = 10,
91    String = 11,
92    Struct = 12,
93    Map = 13,
94    Set = 14,
95    List = 15,
96}
97
98impl convert::From<i8> for ThriftType {
99    fn from(val: i8) -> ThriftType {
100        match val {
101            0 => ThriftType::Stop,
102            1 => ThriftType::Void,
103            2 => ThriftType::Bool,
104            3 => ThriftType::Byte,
105            4 => ThriftType::Double,
106            6 => ThriftType::I16,
107            8 => ThriftType::I32,
108            9 => ThriftType::U64,
109            10 => ThriftType::I64,
110            11 => ThriftType::String,
111            12 => ThriftType::Struct,
112            13 => ThriftType::Map,
113            14 => ThriftType::Set,
114            15 => ThriftType::List,
115            e => panic!("Unexpected value: {}", e),
116        }
117    }
118}
119
120#[derive(PartialEq, Eq, Debug)]
121pub enum ThriftMessageType {
122    Call = 1,
123    Reply = 2,
124    Exception = 3,
125    Oneway = 4,
126}
127
128impl convert::From<i8> for ThriftMessageType {
129    fn from(val: i8) -> ThriftMessageType {
130        match val {
131            1 => ThriftMessageType::Call,
132            2 => ThriftMessageType::Reply,
133            3 => ThriftMessageType::Exception,
134            4 => ThriftMessageType::Oneway,
135            _ => panic!("Unexpected value for ThriftMessageType."),
136        }
137    }
138}
139
140pub trait Serializer {
141    fn serialize_bool(&mut self, val: bool) -> Result<(), Error>;
142    fn serialize_str(&mut self, val: &str) -> Result<(), Error>;
143    fn serialize_string(&mut self, val: String) -> Result<(), Error>;
144    fn serialize_usize(&mut self, val: usize) -> Result<(), Error>;
145    fn serialize_isize(&mut self, val: isize) -> Result<(), Error>;
146    fn serialize_u64(&mut self, val: u64) -> Result<(), Error>;
147    fn serialize_i64(&mut self, val: i64) -> Result<(), Error>;
148    fn serialize_i32(&mut self, val: i32) -> Result<(), Error>;
149    fn serialize_u32(&mut self, val: u32) -> Result<(), Error>;
150    fn serialize_i16(&mut self, val: i16) -> Result<(), Error>;
151    fn serialize_u16(&mut self, val: u16) -> Result<(), Error>;
152    fn serialize_u8(&mut self, val: u8) -> Result<(), Error>;
153    fn serialize_i8(&mut self, val: i8) -> Result<(), Error>;
154    fn serialize_f64(&mut self, val: f64) -> Result<(), Error>;
155    fn serialize_bytes(&mut self, val: &[u8]) -> Result<(), Error>;
156}
157
158pub trait Deserializer {
159    fn deserialize_bool(&mut self) -> Result<bool, Error>;
160    fn deserialize_usize(&mut self) -> Result<usize, Error>;
161    fn deserialize_isize(&mut self) -> Result<isize, Error>;
162    fn deserialize_u64(&mut self) -> Result<u64, Error>;
163    fn deserialize_i64(&mut self) -> Result<i64, Error>;
164    fn deserialize_u32(&mut self) -> Result<u32, Error>;
165    fn deserialize_i32(&mut self) -> Result<i32, Error>;
166    fn deserialize_u16(&mut self) -> Result<u16, Error>;
167    fn deserialize_i16(&mut self) -> Result<i16, Error>;
168    fn deserialize_u8(&mut self) -> Result<u8, Error>;
169    fn deserialize_i8(&mut self) -> Result<i8, Error>;
170    fn deserialize_f64(&mut self) -> Result<f64, Error>;
171    fn deserialize_bytes(&mut self) -> Result<Vec<u8>, Error>;
172    fn deserialize_str(&mut self) -> Result<String, Error>;
173}
174
175pub trait Serialize {
176    fn serialize<S>(&self, s: &mut S) -> Result<(), Error> where S: Serializer + ThriftSerializer;
177}
178
179pub trait ThriftSerializer {
180    fn write_message_begin(&mut self,
181                           _name: &str,
182                           _message_type: ThriftMessageType)
183                           -> Result<(), Error> {
184        Ok(())
185    }
186
187    fn write_struct_begin(&mut self, _name: &str) -> Result<(), Error> {
188        Ok(())
189    }
190
191    fn write_struct_end(&mut self) -> Result<(), Error> {
192        Ok(())
193    }
194
195    fn write_field_begin(&mut self, _name: &str, _ty: ThriftType, _id: i16) -> Result<(), Error> {
196        Ok(())
197    }
198
199    fn write_field_end(&mut self) -> Result<(), Error> {
200        Ok(())
201    }
202
203    fn write_field_stop(&mut self) -> Result<(), Error> {
204        Ok(())
205    }
206
207    fn write_message_end(&mut self) -> Result<(), Error> {
208        Ok(())
209    }
210}
211
212#[derive(Debug)]
213pub struct ThriftMessage {
214    pub name: String,
215    pub ty: ThriftMessageType,
216    pub seq: i16,
217}
218#[derive(Debug)]
219pub struct ThriftField {
220    pub name: Option<String>,
221    pub ty: ThriftType,
222    pub seq: i16,
223}
224
225pub trait ThriftDeserializer {
226    fn read_message_begin(&mut self) -> Result<ThriftMessage, Error>;
227    fn read_message_end(&mut self) -> Result<(), Error>;
228    fn read_struct_begin(&mut self) -> Result<String, Error>;
229    fn read_struct_end(&mut self) -> Result<(), Error>;
230    fn read_field_begin(&mut self) -> Result<ThriftField, Error>;
231    fn read_field_end(&mut self) -> Result<(), Error>;
232}
233
234pub trait Deserialize: Sized {
235    fn deserialize<D>(de: &mut D) -> Result<Self, Error> where D: Deserializer + ThriftDeserializer;
236}
237
238/// ```
239/// use std::io::Cursor;
240/// use tokio_thrift::binary_protocol::BinaryProtocol;
241/// use tokio_thrift::protocol::Deserialize;
242///
243/// let mut de = BinaryProtocol::new(Cursor::new(vec![100u8]));
244/// let val: u8 = Deserialize::deserialize(&mut de).unwrap();
245/// assert_eq!(val, 100);
246/// ```
247impl Deserialize for u8 {
248    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
249        where D: Deserializer + ThriftDeserializer
250    {
251        de.deserialize_u8()
252    }
253}
254
255impl Deserialize for bool {
256    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
257        where D: Deserializer + ThriftDeserializer
258    {
259        de.deserialize_bool()
260    }
261}
262
263/// ```
264/// use std::io::Cursor;
265/// use tokio_thrift::binary_protocol::BinaryProtocol;
266/// use tokio_thrift::protocol::Deserialize;
267///
268/// let mut de = BinaryProtocol::new(Cursor::new(vec![100u8]));
269/// let val: i8 = Deserialize::deserialize(&mut de).unwrap();
270/// assert_eq!(val, 100);
271/// ```
272impl Deserialize for i8 {
273    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
274        where D: Deserializer + ThriftDeserializer
275    {
276        de.deserialize_i8()
277    }
278}
279
280impl Deserialize for u16 {
281    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
282        where D: Deserializer + ThriftDeserializer
283    {
284        de.deserialize_u16()
285    }
286}
287
288impl Deserialize for i16 {
289    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
290        where D: Deserializer + ThriftDeserializer
291    {
292        de.deserialize_i16()
293    }
294}
295
296impl Deserialize for u32 {
297    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
298        where D: Deserializer + ThriftDeserializer
299    {
300        de.deserialize_u32()
301    }
302}
303
304impl Deserialize for i32 {
305    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
306        where D: Deserializer + ThriftDeserializer
307    {
308        de.deserialize_i32()
309    }
310}
311
312impl Deserialize for u64 {
313    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
314        where D: Deserializer + ThriftDeserializer
315    {
316        de.deserialize_u64()
317    }
318}
319
320impl Deserialize for i64 {
321    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
322        where D: Deserializer + ThriftDeserializer
323    {
324        de.deserialize_i64()
325    }
326}
327
328impl Deserialize for f64 {
329    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
330        where D: Deserializer + ThriftDeserializer
331    {
332        de.deserialize_f64()
333    }
334}
335
336impl Deserialize for String {
337    fn deserialize<D>(de: &mut D) -> Result<Self, Error>
338        where D: Deserializer + ThriftDeserializer
339    {
340        de.deserialize_str()
341    }
342}
343
344impl Serialize for () {
345    fn serialize<S>(&self, _s: &mut S) -> Result<(), Error>
346        where S: Serializer + ThriftSerializer
347    {
348        Ok(())
349    }
350}
351
352impl Serialize for bool {
353    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
354        where S: Serializer + ThriftSerializer
355    {
356        s.serialize_bool(*self)
357    }
358}
359
360impl<'a> Serialize for &'a str {
361    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
362        where S: Serializer + ThriftSerializer
363    {
364        s.serialize_str(self)
365    }
366}
367
368impl Serialize for String {
369    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
370        where S: Serializer + ThriftSerializer
371    {
372        s.serialize_string(self.clone())
373    }
374}
375
376impl Serialize for usize {
377    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
378        where S: Serializer + ThriftSerializer
379    {
380        s.serialize_usize(*self)
381    }
382}
383
384impl Serialize for isize {
385    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
386        where S: Serializer + ThriftSerializer
387    {
388        s.serialize_isize(*self)
389    }
390}
391
392impl Serialize for u64 {
393    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
394        where S: Serializer + ThriftSerializer
395    {
396        s.serialize_u64(*self)
397    }
398}
399
400impl Serialize for i64 {
401    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
402        where S: Serializer + ThriftSerializer
403    {
404        s.serialize_i64(*self)
405    }
406}
407
408impl Serialize for i32 {
409    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
410        where S: Serializer + ThriftSerializer
411    {
412        s.serialize_i32(*self)
413    }
414}
415
416impl Serialize for u32 {
417    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
418        where S: Serializer + ThriftSerializer
419    {
420        s.serialize_u32(*self)
421    }
422}
423
424impl Serialize for u16 {
425    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
426        where S: Serializer + ThriftSerializer
427    {
428        s.serialize_u16(*self)
429    }
430}
431
432impl Serialize for i16 {
433    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
434        where S: Serializer + ThriftSerializer
435    {
436        s.serialize_i16(*self)
437    }
438}
439
440impl Serialize for i8 {
441    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
442        where S: Serializer + ThriftSerializer
443    {
444        s.serialize_i8(*self)
445    }
446}
447
448impl Serialize for u8 {
449    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
450        where S: Serializer + ThriftSerializer
451    {
452        s.serialize_u8(*self)
453    }
454}
455
456impl Serialize for f64 {
457    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
458        where S: Serializer + ThriftSerializer
459    {
460        s.serialize_f64(*self)
461    }
462}
463
464impl<'a> Serialize for &'a [u8] {
465    fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
466        where S: Serializer + ThriftSerializer
467    {
468        s.serialize_bytes(self)
469    }
470}
tokio_thrift/protocol/mod.rs

tokio_thrift/protocol/
mod.rs
