Deserialize

Author: thehydroimpulse

src/binary_protocol.rs

@@ -21,7 +21,6 @@ impl<'a> BinarySerializer<'a> {
 }
 
 impl<'a> Serializer for BinarySerializer<'a> {
-    type Error = Error;
 
     fn serialize_bool(&mut self, val: bool) -> Result<(), Error> {
         if val {
@@ -91,9 +90,7 @@ impl<'a> Serializer for BinarySerializer<'a> {
 }
 
 impl<'a> ThriftSerializer for BinarySerializer<'a> {
-    type TError = Error;
-
-    fn write_message_begin(&mut self, name: &str, message_type: ThriftMessageType) -> Result<(), Self::TError> {
+    fn write_message_begin(&mut self, name: &str, message_type: ThriftMessageType) -> Result<(), Error> {
         let version = THRIFT_VERSION_1 | message_type as i32;
 
         try!(self.serialize_i32(version));
@@ -103,30 +100,30 @@ impl<'a> ThriftSerializer for BinarySerializer<'a> {
         Ok(())
     }
 
-    fn write_struct_begin(&mut self, name: &str) -> Result<(), Self::TError> {
+    fn write_struct_begin(&mut self, name: &str) -> Result<(), Error> {
         Ok(())
     }
 
-    fn write_struct_end(&mut self) -> Result<(), Self::TError> {
+    fn write_struct_end(&mut self) -> Result<(), Error> {
         Ok(())
     }
 
-    fn write_field_begin(&mut self, name: &str, ty: ThriftType, id: i16) -> Result<(), Self::TError> {
+    fn write_field_begin(&mut self, name: &str, ty: ThriftType, id: i16) -> Result<(), Error> {
         try!(self.serialize_i8(ty as i8));
         try!(self.serialize_i16(id));
         Ok(())
     }
 
-    fn write_field_end(&mut self) -> Result<(), Self::TError> {
+    fn write_field_end(&mut self) -> Result<(), Error> {
         Ok(())
     }
 
-    fn write_field_stop(&mut self) -> Result<(), Self::TError> {
+    fn write_field_stop(&mut self) -> Result<(), Error> {
         try!(self.serialize_i8(ThriftType::Stop as i8));
         Ok(())
     }
 
-    fn write_message_end(&mut self) -> Result<(), Self::TError> {
+    fn write_message_end(&mut self) -> Result<(), Error> {
         Ok(())
     }
 }
@@ -135,9 +132,15 @@ pub struct BinaryDeserializer<R: Read + ReadBytesExt> {
     rd: R
 }
 
-impl<R: Read + ReadBytesExt> Deserializer for BinaryDeserializer<R> {
-    type Error = Error;
+impl<R: Read + ReadBytesExt> BinaryDeserializer<R> {
+    pub fn new(rd: R) -> BinaryDeserializer<R> {
+        BinaryDeserializer {
+            rd: rd
+        }
+    }
+}
 
+impl<R: Read + ReadBytesExt> Deserializer for BinaryDeserializer<R> {
     fn deserialize_bool(&mut self) -> Result<bool, Error> {
         Ok(try!(self.rd.read_i8()) != 0)
     }
@@ -199,9 +202,7 @@ impl<R: Read + ReadBytesExt> Deserializer for BinaryDeserializer<R> {
 }
 
 impl<R: Read + ReadBytesExt> ThriftDeserializer for BinaryDeserializer<R> {
-    type TError = Error;
-
-    fn read_message_begin(&mut self) -> Result<ThriftMessage, Self::TError> {
+    fn read_message_begin(&mut self) -> Result<ThriftMessage, Error> {
         let size: i32 = try!(self.deserialize_i32());
 
         if size < 0 {
@@ -220,19 +221,19 @@ impl<R: Read + ReadBytesExt> ThriftDeserializer for BinaryDeserializer<R> {
         }
     }
 
-    fn read_message_end(&mut self) -> Result<(), Self::TError> {
+    fn read_message_end(&mut self) -> Result<(), Error> {
         Ok(())
     }
 
-    fn read_struct_begin(&mut self) -> Result<String, Self::TError> {
+    fn read_struct_begin(&mut self) -> Result<String, Error> {
         Ok("".to_string())
     }
 
-    fn read_struct_end(&mut self) -> Result<(), Self::TError> {
+    fn read_struct_end(&mut self) -> Result<(), Error> {
         Ok(())
     }
 
-    fn read_field_begin(&mut self) -> Result<ThriftField, Self::TError> {
+    fn read_field_begin(&mut self) -> Result<ThriftField, Error> {
         let mut field = ThriftField {
             name: None,
             ty: ThriftType::from(try!(self.deserialize_i8())),
@@ -247,7 +248,7 @@ impl<R: Read + ReadBytesExt> ThriftDeserializer for BinaryDeserializer<R> {
         }
     }
 
-    fn read_field_end(&mut self) -> Result<(), Self::TError> {
+    fn read_field_end(&mut self) -> Result<(), Error> {
         Ok(())
     }
 }

src/lib.rs

@@ -19,8 +19,8 @@ mod ast;
 mod generator;
 mod event_loop;
 mod reactor;
-mod protocol;
-mod binary_protocol;
+pub mod protocol;
+pub mod binary_protocol;
 mod service;
 
 pub type ThriftResult<T> = Result<T, ThriftCompilerError>;

src/protocol.rs

@@ -3,6 +3,7 @@ use std::convert;
 use byteorder;
 use std::string::FromUtf8Error;
 
+#[derive(Debug)]
 pub enum Error {
     Byteorder(byteorder::Error),
     Io(io::Error),
@@ -90,8 +91,6 @@ impl convert::From<i8> for ThriftMessageType {
 }
 
 pub trait Serializer {
-    type Error = ();
-
     fn serialize_bool(&mut self, val: bool) -> Result<(), Error>;
     fn serialize_str(&mut self, val: &str) -> Result<(), Error>;
     fn serialize_string(&mut self, val: String) -> Result<(), Error>;
@@ -109,8 +108,6 @@ pub trait Serializer {
 }
 
 pub trait Deserializer {
-    type Error = ();
-
     fn deserialize_bool(&mut self) -> Result<bool, Error>;
     fn deserialize_usize(&mut self) -> Result<usize, Error>;
     fn deserialize_isize(&mut self) -> Result<isize, Error>;
@@ -131,8 +128,6 @@ pub trait Serialize {
 }
 
 pub trait ThriftSerializer {
-    type TError = ();
-
     fn write_message_begin(&mut self, name: &str, message_type: ThriftMessageType) -> Result<(), Error> {
         Ok(())
     }
@@ -175,8 +170,6 @@ pub struct ThriftField {
 }
 
 pub trait ThriftDeserializer {
-    type TError = ();
-
     fn read_message_begin(&mut self) -> Result<ThriftMessage, Error>;
     fn read_message_end(&mut self) -> Result<(), Error>;
     fn read_struct_begin(&mut self) -> Result<String, Error>;
@@ -185,6 +178,25 @@ pub trait ThriftDeserializer {
     fn read_field_end(&mut self) -> Result<(), Error>;
 }
 
+pub trait Deserialize: Sized {
+    fn deserialize(de: &mut Deserializer) -> Result<Self, Error>;
+}
+
+/// ```
+/// use std::io::Cursor;
+/// use thrust::binary_protocol::BinaryDeserializer;
+/// use thrust::protocol::Deserialize;
+///
+/// let mut de = BinaryDeserializer::new(Cursor::new(vec![100u8]));
+/// let val: u8 = Deserialize::deserialize(&mut de).unwrap();
+/// assert_eq!(val, 100);
+/// ```
+impl Deserialize for u8 {
+    fn deserialize(de: &mut Deserializer) -> Result<Self, Error> {
+        de.deserialize_u8()
+    }
+}
+
 impl Serialize for bool {
     fn serialize<S>(&self, s: &mut S) -> Result<(), Error>
         where S: Serializer + ThriftSerializer

src/service.rs

@@ -27,6 +27,19 @@ impl Serialize for QueryArgs {
     }
 }
 
+
+pub struct RpcServer;
+
+impl Service for RpcServer {
+    fn query(&mut self, val: bool) {
+
+    }
+}
+
+fn dispatch_query(service: &mut Service, args: QueryArgs) {
+    service.query(args.val);
+}
+
 pub struct RpcClient;
 
 impl Service for RpcClient {