add variant impl for char

2 files changed, 41 insertions, 2 deletions

diff --git a/src/primitive/string.rs b/src/primitive/string.rs
index 478bc0a..5addff2 100644
--- a/src/primitive/string.rs
+++ b/src/primitive/string.rs
@@ -7,8 +7,25 @@ use failure::Error;
 
 use log::trace;
 
-use crate::util;
-use crate::{deserialize::*, serialize::*};
+use crate::{deserialize::*, error::ProtocolError, serialize::*, util};
+
+impl Deserialize for char {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let (slen, qchar): (usize, u16) = u16::parse(&b[0..2])?;
+        let qchar = char::from_u32(qchar as u32).ok_or(ProtocolError::CharError)?;
+
+        return Ok((slen, qchar));
+    }
+}
+
+impl Serialize for char {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        let mut b = [0, 0];
+        self.encode_utf16(&mut b);
+
+        return Ok(b[0].to_be_bytes().to_vec());
+    }
+}
 
 /// We Shadow the String type here as we can only use impl on types in our own scope.
 ///
diff --git a/src/primitive/variant.rs b/src/primitive/variant.rs
index 3b41b7b..833df25 100644
--- a/src/primitive/variant.rs
+++ b/src/primitive/variant.rs
@@ -40,6 +40,7 @@ pub enum Variant {
     #[from(ignore)]
     ByteArray(String),
     StringList(StringList),
+    char(char),
     bool(bool),
     u64(u64),
     u32(u32),
@@ -204,6 +205,11 @@ impl Serialize for Variant {
                 res.extend(unknown.to_be_bytes().iter());
                 res.extend(v.serialize()?.iter());
             }
+            Variant::char(v) => {
+                res.extend(primitive::QCHAR.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.serialize()?.iter());
+            }
             Variant::String(v) => {
                 res.extend(primitive::QSTRING.to_be_bytes().iter());
                 res.extend(unknown.to_be_bytes().iter());
@@ -304,6 +310,7 @@ impl Serialize for Variant {
 
 impl Deserialize for Variant {
     fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        trace!("trying to parse variant with bytes: {:?}", b);
         let (_, qtype) = i32::parse(&b[0..4])?;
         let qtype = qtype as u32;
 
@@ -322,6 +329,11 @@ impl Deserialize for Variant {
                 let (vlen, value) = VariantList::parse(&b[len..])?;
                 return Ok((len + vlen, Variant::VariantList(value)));
             }
+            primitive::QCHAR => {
+                trace!(target: "primitive::Variant", "Parsing Variant: Char");
+                let (vlen, value) = char::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::char(value)));
+            }
             primitive::QSTRING => {
                 trace!(target: "primitive::Variant", "Parsing Variant: String");
                 let (vlen, value) = String::parse(&b[len..])?;
@@ -655,6 +667,16 @@ mod tests {
     }
 
     #[test]
+    fn char_serialize() {
+        assert_eq!(Variant::char('z').serialize().unwrap(), [0, 0, 0, 7, 0, 0, 122]);
+    }
+
+    #[test]
+    fn char_deserialize() {
+        assert_eq!((7, Variant::char('z')), Variant::parse(&[0, 0, 0, 7, 0, 0, 122]).unwrap());
+    }
+
+    #[test]
     fn strings_serialize() {
         let test_string = "This is a Test!1!!".to_string();
         let test_string_list = vec!["test1".to_string(), "test 2".to_string()];