rust-protocol: Implement decoding/encoding for the remaining packet types.

common/rust-protocol/src/lib.rs

                 report.encode(&mut data[1..])
             }
             Self::GetValues(get_values) => {
-                data[0] = (get_values.count << 5) | 2;
+                data[0] = (get_values.count << 5) | 3;
                 get_values.encode(&mut data[1..])
             }
             Self::Values(values) => {
-                data[0] = (values.count << 5) | 2;
+                data[0] = (values.count << 5) | 4;
                 values.encode(&mut data[1..])
             }
         }
 pub struct GetValues {
     pub count: u8,
     pub location: Location,
-    pub types_: [ValueType; 8],
+    pub types: [ValueType; 8],
 }
 
 impl GetValues {
-    fn decode(_count: u8, _data: &[u8]) -> Result<GetValues, Error> {
-        // TODO
-        Err(Error::InvalidPacketType)
+    fn decode(count: u8, data: &[u8]) -> Result<GetValues, Error> {
+        let location = Location::decode(data[0])?;
+        let mut get_values = GetValues {
+            count,
+            location,
+            types: [ValueType::Time; 8],
+        };
+        for i in 0..count as usize {
+            get_values.types[i] = ValueType::decode(data[i + 1])?;
+        }
+        Ok(get_values)
     }
 
-    fn encode(&self, mut _data: &[u8]) -> bool {
-        // TODO
-        false
+    fn encode(&self, data: &mut [u8]) -> bool {
+        data[0] = self.location.encode();
+        for i in 0..self.count as usize {
+            data[i + 1] = self.types[i].encode();
+        }
+        true
     }
 }
 
 }
 
 impl Values {
-    fn decode(_count: u8, _data: &[u8]) -> Result<Values, Error> {
-        // TODO
-        Err(Error::InvalidPacketType)
+    fn decode(count: u8, mut data: &[u8]) -> Result<Values, Error> {
+        let mut report = Self {
+            count,
+            location: Location::decode(data[0])?,
+            values: [Value::Invalid; 8],
+        };
+        data = &data[1..];
+        for i in 0..count {
+            report.values[i as usize] = Value::decode(&mut data)?;
+        }
+        Ok(report)
     }
 
-    fn encode(&self, mut _data: &[u8]) -> bool {
-        // TODO
-        false
+    fn encode(&self, mut data: &mut [u8]) -> bool {
+        data[0] = self.location.encode();
+        data = &mut data[1..];
+        for i in 0..self.count {
+            let value_len = self.values[i as usize].encoded_length();
+            if data.len() < value_len {
+                return false;
+            }
+            if !self.values[i as usize].encode(data) {
+                return false;
+            }
+            data = &mut data[value_len..];
+        }
+        true
     }
 }
 
     Balcony,
 }
 
+impl Location {
+    fn encode(self) -> u8 {
+        match self {
+            Self::Livingroom => 0,
+            Self::Bathroom => 1,
+            Self::Bedroom => 2,
+            Self::Kitchen => 3,
+            Self::Balcony => 4,
+        }
+    }
+
+    fn decode(value: u8) -> Result<Location, Error> {
+        match value {
+            0 => Ok(Self::Livingroom),
+            1 => Ok(Self::Bathroom),
+            2 => Ok(Self::Bedroom),
+            3 => Ok(Self::Kitchen),
+            4 => Ok(Self::Balcony),
+            _ => Err(Error::InvalidLocation),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Value {
     Invalid,
     Humidity,
 }
 
+impl ValueType {
+    fn encode(self) -> u8 {
+        match self {
+            Self::Time => 0,
+            Self::Temperature => 1,
+            Self::Pressure => 2,
+            Self::Humidity => 3,
+        }
+    }
+
+    fn decode(value: u8) -> Result<ValueType, Error> {
+        match value {
+            0 => Ok(Self::Time),
+            1 => Ok(Self::Temperature),
+            2 => Ok(Self::Pressure),
+            3 => Ok(Self::Humidity),
+            _ => Err(Error::InvalidValueType),
+        }
+    }
+}
+
 fn encrypt_cbc(key: &[u8], data: &mut [u8]) {
     for i in 0..data.len() / 8 - 1 {
         let (prev, block) = data[i * 8..i * 8 + 16].split_at_mut(8);