Finish serializer

src/schema/serializer.rs

@@ -84,10 +84,44 @@ impl ValueDataType {
                 buffer.append(&mut encoded);
                 Ok(SerializeResult(encoded.len(), bit_start))
             },
-            ValueDataType::BitFlag(_) => todo!(),
-            ValueDataType::String(_) => todo!(),
-            ValueDataType::Optional(value_data_type) => todo!(),
-            ValueDataType::Object(btree_map) => todo!(),
+            ValueDataType::BitFlag(v) => {
+                let (next_bit_start, bytes_written) = next_bitstart_and_byte_written(bit_start, 4)?;
+                if bit_start == 0 {
+                    buffer.push(0); // Add an empty byte to write to
+                    len += 1;
+                }
+
+                if *v {
+                    buffer[len - 1] |= 1 << bit_start;
+                } else {
+                    buffer[len - 1] &= !(1 << bit_start);
+                }
+
+                Ok(SerializeResult(bytes_written, next_bit_start))
+            },
+            ValueDataType::String(str) => {
+                let mut bytes = str.as_bytes().to_vec();
+                buffer.append(&mut bytes);
+
+                Ok(SerializeResult(bytes.len(), bit_start))
+            },
+            ValueDataType::Optional(val) => {
+                match val {
+                    Some(val) => val.serialize(buffer, bit_start),
+                    None => Ok(SerializeResult(0, bit_start)),
+                }
+            },
+            ValueDataType::Object(map) => {
+                let mut bit_start = bit_start;
+                let mut bytes_written = 0;
+                for item in map.values() {
+                    let res = item.serialize(buffer, bit_start)?;
+                    bytes_written += res.0;
+                    bit_start = res.1;
+                }
+
+                Ok(SerializeResult(bytes_written, bit_start))
+            },
         }
     }
 }