feat: decoder handling measurement and discard of generic RPC messages with test example

Author: eigen-value

examples/decoder_example/decoder_example.ino

@@ -99,10 +99,15 @@ void loop() {
     }
 
     // MIXED INCOMING RESPONSE AND REQUEST
+    Serial.println("-- Discard TEST --");
     blink_before();
     packer.clear();
     packer.serialize(resp_sz, 1, 1, nil, ret_sz, 3.0, 2);
+    Serial.print("1st packet size: ");
+    Serial.println(packer.size());
     packer.serialize(req_sz, 0, 1, "method", par_sz, 1.0, 2.0);
+    Serial.print("full size: ");
+    Serial.println(packer.size());
 
     DummyTransport dummy_transport4(packer.data(), packer.size());
     RpcDecoder<> decoder4(dummy_transport4);
@@ -112,53 +117,19 @@ void loop() {
         Serial.println("Packet not ready");
         decoder4.advance();
         decoder4.parse_packet();
-        decoder4.print_buffer();
         delay(100);
     }
 
-    if (decoder4.packet_incoming()){
-        Serial.print("packet ready. type: ");
-        Serial.println(decoder4.packet_type());
-
-        // as client knows the expected response types/error
-        MsgPack::arr_size_t r_resp_sz(4);
-        MsgPack::object::nil_t nil;
-        int r_type;
-        int r_msg_id;
-        MsgPack::arr_size_t r_ret_sz(2);
-        float r_float;
-        int r_int;
-
-        Serial.print("Total Decoder buf size: ");
-        Serial.println(decoder4.size());
-        for (size_t i=1; i<decoder4.size(); i++){
-
-            if (decoder4.get_next_packet(unpacker, i)){
-
-                if (unpacker.deserialize(r_resp_sz, r_type, r_msg_id)){
-                    // consistency checks
-                    if (unpacker.unpackable(nil)) { // No error case
-                        if (unpacker.deserialize(nil, r_ret_sz, r_float, r_int)){
-                            // do more checks
-                            // fill the response
-                            Serial.print("Full packet decoded size: ");
-                            Serial.println(i);
-                            decoder4.pop_packet(i);
-                            Serial.print("1st Packet popped. Decoder buf size: ");
-                            Serial.println(decoder4.size());
-                            decoder4.print_buffer();
-                            break;  //exit the loop
-                        }
-                    } else {
-                        // unpack the error
-                    }
-                    
-                }
-
-            }
-
-        }
-
+    while (decoder4.packet_incoming()){
+        decoder4.print_buffer();
+        size_t removed = decoder4.discard_packet();
+        Serial.print("Removed bytes: ");
+        Serial.println(removed);
+        decoder4.print_buffer();
+        decoder4.advance();
+        decoder4.parse_packet();
     }
 
+    Serial.println("-- END Discard TEST --");
+
 }

src/decoder.h

@@ -251,10 +251,7 @@ class RpcDecoder {
     }
 
     size_t discard_packet() {
-        // todo recursive packet size measurement
-        // use pop_packet with size
-        // return popped bytes
-        return 0;
+        return pop_packet(get_packet_size());
     }
 
     inline size_t size() const {return _bytes_stored;}
@@ -291,6 +288,109 @@ void print_buffer(){
     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;
+        static MsgPack::Unpacker unpacker;
+
+        while (bytes_checked < _bytes_stored){
+            bytes_checked++;
+            unpacker.clear();
+            if (!unpacker.feed(_raw_buffer, bytes_checked)) continue;
+
+            if (unpackArray(unpacker, container_size)) {
+                return bytes_checked;
+            } else {
+                continue;
+            }
+
+        }
+
+        return 0;
+    }
+
+    bool unpackObject(MsgPack::Unpacker& unpacker){
+
+        if (unpacker.isNil()){
+            static MsgPack::object::nil_t nil;
+            return unpacker.deserialize(nil);
+        }
+        if (unpacker.isBool()){
+            static bool b;
+            return unpacker.deserialize(b);
+        }
+        if (unpacker.isUInt() || unpacker.isInt()){
+            static int integer;
+            return unpacker.deserialize(integer);
+        }
+        if (unpacker.isFloat32()){
+            static float num32;
+            return unpacker.deserialize(num32);
+        }
+        if (unpacker.isFloat64()){
+            static double num64;
+            return unpacker.deserialize(num64);
+        }
+        if (unpacker.isStr()){
+            static MsgPack::str_t string;
+            return unpacker.deserialize(string);
+        }
+        if (unpacker.isBin()){
+            static MsgPack::bin_t<uint8_t> bytes;
+            return unpacker.deserialize(bytes);
+        }
+        if (unpacker.isArray()){
+            static size_t arr_sz;
+            return unpackArray(unpacker, arr_sz);
+        }
+        if (unpacker.isMap()){
+            static size_t map_sz;
+            return unpackMap(unpacker, map_sz);
+        }
+        if (unpacker.isFixExt() || unpacker.isExt()){
+            static MsgPack::object::ext e;
+            return unpacker.deserialize(e);
+        }
+        if (unpacker.isTimestamp()){
+            static MsgPack::object::timespec t;
+            return unpacker.deserialize(t);
+        }
+
+        return false;
+    }
+
+    bool unpackArray(MsgPack::Unpacker& unpacker, size_t& size) {
+
+        static MsgPack::arr_size_t sz;
+        unpacker.deserialize(sz);
+
+        size = 0;
+        for (size_t i=0; i<sz.size(); i++){
+            if (unpackObject(unpacker)){
+                size++;
+            } else {
+                return false;
+            }
+        }
+
+    }
+
+    bool unpackMap(MsgPack::Unpacker& unpacker, size_t& size) {
+        static MsgPack::map_size_t sz;
+        unpacker.deserialize(sz);
+
+        size = 0;
+        for (size_t i=0; i<sz.size(); i++){
+            if (unpackObject(unpacker) && unpackObject(unpacker)){  // must unpack key&value
+                size++;
+            } else {
+                return false;
+            }
+        }
+    }
+
 };
 
 #endif