mod: cleanup (decoder, dispatcher) impr: deserialization utils. rem: old examples

Author: eigen-value

examples/decoder_example/DummyTransport.h

@@ -25,17 +25,15 @@ void runDecoderTest(const char* label) {
 
   while (!decoder.packet_incoming()) {
     Serial.println("Packet not ready");
-    decoder.advance();
-    decoder.parse_packet();
+    decoder.decode();
     delay(50);
   }
 
   while (decoder.packet_incoming()) {
     size_t removed = decoder.discard_packet();
     Serial.print("Removed bytes: ");
     Serial.println(removed);
-    decoder.advance();
-    decoder.parse_packet();
+    decoder.decode();
   }
 
   Serial.println("-- Done --\n");

examples/decoder_example/decoder_example.ino

@@ -38,7 +38,7 @@ class RPCClient {
         RpcError error;
         // blocking call
         while (!decoder->get_response(msg_id, result, error)){
-            decoder->process();
+            decoder->decode();
             delay(1);
         }
 

examples/decoder_tests/decoder_tests.ino

@@ -80,7 +80,7 @@ class RpcDecoder {
             } else {                        // RPC returned an error
                 if (!unpacker.deserialize(error, nil)) continue;
             }
-            pop_packet(bytes_checked);
+            consume(bytes_checked);
             return true;
         }
         return false;
@@ -162,15 +162,15 @@ class RpcDecoder {
                 if (msg_type == CALL_MSG){
                     send(reinterpret_cast<const uint8_t*>(packer.data()), packer.size());
                 }
-                pop_packet(bytes_checked);
+                consume(bytes_checked);
                 break;
             }
 
         }
 
     }
 
-    void process(){
+    void decode(){
         advance();
         parse_packet();
     }
@@ -215,42 +215,32 @@ class RpcDecoder {
 
     int packet_type() const {return _packet_type;}
 
-    // Get the oldest packet (returns false if no packet available)
-    bool get_next_packet(MsgPack::Unpacker& unpacker, size_t size) {
-        if (!packet_incoming()) return false;
-        unpacker.clear();
-        return unpacker.feed(_raw_buffer, size);
-    }
+    // Get the size of the next packet in the buffer (must be array contained, no other requirements)
+    size_t get_packet_size() {
 
-    // Try to recover buffer error condition
-    void recover() {
-        // ensure parsing was attempted
-        parse_packet();
-        if (buffer_full() && !packet_incoming()){
-            flush_buffer();
-        }
-    }
-
-    // Discard the oldest packet. Returns the number of freed_bytes
-    size_t pop_packet(size_t size) {
+        size_t bytes_checked = 0;
+        size_t container_size;
+        MsgPack::Unpacker unpacker;
 
-        if (size > _bytes_stored) return 0;
+        while (bytes_checked < _bytes_stored){
+            bytes_checked++;
+            unpacker.clear();
+            if (!unpacker.feed(_raw_buffer, bytes_checked)) continue;
 
-        const size_t remaining_bytes = _bytes_stored - size;
+            if (unpackArray(unpacker, container_size)) {
+                return bytes_checked;
+            } else {
+                continue;
+            }
 
-        // Shift remaining data forward (manual memmove for compatibility)
-        for (size_t i = 0; i < remaining_bytes; i++) {
-            _raw_buffer[i] = _raw_buffer[size + i];
         }
 
-        _bytes_stored = remaining_bytes;
-        _packet_type = NO_MSG;
-
-        return size;
+        return 0;
     }
 
+    // Discard the next (array) packet in the buffer, returns the number of bytes consumed.
     size_t discard_packet() {
-        return pop_packet(get_packet_size());
+        return consume(get_packet_size());
     }
 
     inline size_t size() const {return _bytes_stored;}
@@ -263,36 +253,29 @@ class RpcDecoder {
     int _msg_id = 0;
 
     inline bool buffer_full() const { return _bytes_stored == BufferSize; }
+
     inline bool buffer_empty() const { return _bytes_stored == 0;}
-    inline void flush_buffer() {
-        uint8_t discard_buf[CHUNK_SIZE];
-        while (_transport.read(discard_buf, CHUNK_SIZE) > 0);
-        _bytes_stored = 0;
-    }
+
     inline size_t send(const uint8_t* data, const size_t size) {
         return _transport.write(data, size);
     }
 
-    size_t get_packet_size(){
-
-        size_t bytes_checked = 0;
-        size_t container_size;
-        MsgPack::Unpacker unpacker;
+    // Consume the first 'size' bytes of the buffer, shifting remaining data forward
+    size_t consume(size_t size) {
 
-        while (bytes_checked < _bytes_stored){
-            bytes_checked++;
-            unpacker.clear();
-            if (!unpacker.feed(_raw_buffer, bytes_checked)) continue;
+        if (size > _bytes_stored) return 0;
 
-            if (unpackArray(unpacker, container_size)) {
-                return bytes_checked;
-            } else {
-                continue;
-            }
+        const size_t remaining_bytes = _bytes_stored - size;
 
+        // Shift remaining data forward (manual memmove for compatibility)
+        for (size_t i = 0; i < remaining_bytes; i++) {
+            _raw_buffer[i] = _raw_buffer[size + i];
         }
 
-        return 0;
+        _bytes_stored = remaining_bytes;
+        _packet_type = NO_MSG;
+
+        return size;
     }
 
 };