some rust updates and todos based on usage

beschi/writers/boilerplate/Rust.rs

@@ -1,3 +1,5 @@
+#![allow(dead_code)] // some generated functions chains may not be fully exploited
+
 use std::fmt;
 use std::error::Error;
 
@@ -20,28 +22,29 @@ impl fmt::Display for BeschiError {
     }
 }
 
-pub struct BufferReader {
-    buffer: Vec<u8>,
-    current_position: usize,
+pub struct BufferReader<'a> {
+    buffer: &'a [u8],
+    pub current_position: usize,
 }
 
-impl BufferReader {
-    pub fn new(buffer: Vec<u8>) -> Self {
+impl<'a> BufferReader<'a> {
+    pub fn new(buffer: &'a [u8]) -> Self {
         BufferReader { buffer, current_position: 0 }
     }
 
-    pub fn is_finished(&self) -> bool {
-        if self.current_position >= self.buffer.len() {
-            return true
+    pub fn from_vec(buffer: Vec<u8>) -> BufferReader<'static> {
+        BufferReader {
+            buffer: buffer.leak(),
+            current_position: 0
         }
-        false
+    }
+
+    pub fn is_finished(&self) -> bool {
+        self.current_position >= self.buffer.len()
     }
 
     pub fn has_remaining(&self, size: usize) -> bool {
-        if self.current_position + size > self.buffer.len() {
-            return false
-        }
-        true
+        self.current_position + size <= self.buffer.len()
     }
 
     pub fn take_byte(&mut self) -> Result<u8, BeschiError> {
@@ -117,7 +120,22 @@ impl BufferReader {
     }
 }
 
+impl <'a> Drop for BufferReader<'a> {
+    fn drop(&mut self) {
+        if std::mem::needs_drop::<Vec<u8>>() {
+            unsafe {
+                let _ = Vec::from_raw_parts(
+                    self.buffer.as_ptr() as *mut u8,
+                    self.buffer.len(),
+                    self.buffer.len()
+                );
+            }
+        }
+    }
+}
+
 pub trait MessageCodec {
+    fn get_message_type(&self) -> MessageType;
     fn get_size_in_bytes(&self) -> usize;
     fn from_bytes(reader: &mut BufferReader) -> Result<Self, BeschiError>
         where Self: Sized;

beschi/writers/rust.py

@@ -200,9 +200,16 @@ def gen_struct(self, sname: str, sdata: Struct):
 
         if sdata.is_message:
             self.write_line(f"impl MessageCodec for {sname} {{")
+            self.indent_level += 1
+            self.write_line("fn get_message_type(&self) -> MessageType {")
+            self.indent_level += 1
+            self.write_line(f"MessageType::{sname}")
+            self.indent_level -= 1
+            self.write_line("}")
+            self.write_line()
         else:
             self.write_line(f"impl {sname} {{")
-        self.indent_level += 1
+            self.indent_level += 1
 
         self.write_line("fn get_size_in_bytes(&self) -> usize {")
         self.indent_level += 1
@@ -269,6 +276,15 @@ def generate(self) -> str:
             subs.append(("Beschi", self.protocol.namespace))
             self.prefix = self.protocol.namespace
         self.add_boilerplate(substitutions=subs)
+        self.write_line()
+
+        self.write_line("pub enum MessageType {")
+        self.indent_level += 1
+        for mname in self.protocol.messages:
+           self.write_line(f"{mname},")
+        self.indent_level -= 1
+        self.write_line("}")
+        self.write_line()
 
         self.write_line("pub enum Message {")
         self.indent_level += 1
@@ -280,6 +296,17 @@ def generate(self) -> str:
 
         self.write_line("impl MessageCodec for Message {")
         self.indent_level += 1
+        self.write_line("fn get_message_type(&self) -> MessageType {")
+        self.indent_level += 1
+        self.write_line("match self {")
+        self.indent_level += 1
+        for mname in self.protocol.messages:
+            self.write_line(f"Message::{mname}(_) => MessageType::{mname},")
+        self.indent_level -= 1
+        self.write_line("}")
+        self.indent_level -= 1
+        self.write_line("}")
+        self.write_line()
         self.write_line("fn get_size_in_bytes(&self) -> usize {")
         self.indent_level += 1
         self.write_line("match self {")

docs/dev/todo.md

@@ -1,9 +1,10 @@
 This file is a rough todo list for the tool itself.
 
 ## dustoff notes
+- Rust: make a BufferedWriter that takes either a `[u8]` or a `Vec<u8>`
 - update documentation before publishing 0.3.*
     - if you call from_bytes on a generic message, it has to be tagged
-    - Swift the PackMessages and stuff hangs off the array because of Reasons™
+    - Swift: the PackMessages and stuff hangs off the array because of Reasons™
 - UnpackMessages should check for EOF on reads and throw/return errors as appropriate
     - make sure we're consuming the terminator, too
 

test/_harnesses/rust/src/basic.rs

@@ -130,7 +130,7 @@ fn main() {
     else if args.contains_key("read") {
         let filename = args.get("read").unwrap();
         let buffer = fs::read(&filename).unwrap();
-        let mut reader = BufferReader::new(buffer);
+        let mut reader = BufferReader::from_vec(buffer);
         let input = TestingMessage::from_bytes(&mut reader).unwrap();
         checker.soft_assert(input.b == example.b, "byte");
         checker.soft_assert(input.tf == example.tf, "bool");

test/_harnesses/rust/src/broken.rs

@@ -25,7 +25,7 @@ fn main() {
     else if args.contains_key("read") {
         let filename = args.get("read").unwrap();
         let buffer = fs::read(&filename).unwrap();
-        let mut reader = BufferReader::new(buffer);
+        let mut reader = BufferReader::from_vec(buffer);
         let read_res = FullMessage::from_bytes(&mut reader);
         match read_res {
             Ok(_) => checker.soft_assert(false, "reading broken message"),

test/_harnesses/rust/src/multiple.rs

@@ -53,7 +53,7 @@ fn main() {
         let filename = args.get("read").unwrap();
         let mut buffer = fs::read(&filename).unwrap();
         buffer.resize(buffer.len() + 25, 0);
-        let mut reader = small_messages::BufferReader::new(buffer);
+        let mut reader = small_messages::BufferReader::from_vec(buffer);
         let msg_list = small_messages::process_raw_bytes(&mut reader, -1).unwrap();
         checker.soft_assert(msg_list.len() == 12, "reading multiple messages length");
 

test/_harnesses/rust/src/multiple_broken.rs

@@ -43,7 +43,7 @@ fn main() {
     else if args.contains_key("read") {
         let filename = args.get("read").unwrap();
         let buffer = fs::read(&filename).unwrap();
-        let mut reader = BufferReader::new(buffer);
+        let mut reader = BufferReader::from_vec(buffer);
         match broken_messages::process_raw_bytes(&mut reader, -1) {
             Err(_) => checker.soft_assert(true, "read broken stream length"),
             Ok(_) => checker.soft_assert(false, "read broken stream length"),

test/_harnesses/rust/src/packed.rs

@@ -37,7 +37,7 @@ fn main() {
     else if args.contains_key("read") {
         let filename = args.get("read").unwrap();
         let buffer = fs::read(&filename).unwrap();
-        let mut reader = BufferReader::new(buffer);
+        let mut reader = BufferReader::from_vec(buffer);
         let msg_list = unpack_messages(&mut reader).unwrap();
         checker.soft_assert(msg_list.len() == 10, "packed count");
 

test/_harnesses/rust/src/sized.rs

@@ -42,7 +42,7 @@ fn main() {
     else if args.contains_key("read") {
         let filename = args.get("read").unwrap();
         let buffer = fs::read(&filename).unwrap();
-        let mut reader = BufferReader::new(buffer);
+        let mut reader = BufferReader::from_vec(buffer);
         let input = TextContainer::from_bytes(&mut reader).unwrap();
 
 

test/_harnesses/rust/src/truncated.rs

@@ -28,7 +28,7 @@ fn main() {
     else if args.contains_key("read") {
         let filename = args.get("read").unwrap();
         let buffer = fs::read(&filename).unwrap();
-        let mut reader = BufferReader::new(buffer);
+        let mut reader = BufferReader::from_vec(buffer);
         let read_res = ListMessage::from_bytes(&mut reader);
         match read_res {
             Ok(_) => checker.soft_assert(false, "reading truncated message"),

test/_harnesses/rust/src/uninitialized.rs

@@ -26,7 +26,7 @@ fn main() {
     else if args.contains_key("read") {
         let filename = args.get("read").unwrap();
         let buffer = fs::read(&filename).unwrap();
-        let mut reader = BufferReader::new(buffer);
+        let mut reader = BufferReader::from_vec(buffer);
         let input = TestingMessage::from_bytes(&mut reader).unwrap();
         checker.soft_assert(input.b == example.b, "byte");
         checker.soft_assert(input.tf == example.tf, "bool");