feat: decoder attempt linear buf TBT

Author: eigen-value

examples/decoder_example/decoder_example.ino

@@ -0,0 +1,42 @@
+#include <Arduino_RPClite.h>
+
+void blink_before(){
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(200);
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(200);
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(200);
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(200);
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(200);
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(200);
+}
+
+MsgPack::Packer packer;
+MsgPack::Unpacker unpacker;
+
+void setup() {
+    Serial.begin(9600);
+}
+
+void loop() {
+
+    blink_before();
+    MsgPack::arr_size_t req_sz(4);
+    MsgPack::arr_size_t par_sz(2);
+    packer.serialize(req_sz, 0, 1, "method", par_sz, 1.0, 2.0);
+
+    DummyTransport dummy_transport(packer.data(), packer.size());
+    RpcDecoder<> decoder(dummy_transport);
+
+    while (!decoder.packet_available()){
+        Serial.println("Packet not ready");
+        decoder.advance();
+    }
+
+    Serial.println("packet ready");
+
+}

src/Arduino_RPClite.h

@@ -15,6 +15,7 @@
 #include "server.h"
 #include "wrapper.h"
 #include "dispatcher.h"
+#include "decoder.h"
 
 #include "DummyTransport.h"
 #include "SerialTransport.h"

src/DummyTransport.h

@@ -2,37 +2,55 @@
 // Created by lucio on 4/8/25.
 //
 
-#ifndef DUMMYTRANSPORT_H
-#define DUMMYTRANSPORT_H
+#ifndef DUMMY_TRANSPORT_H
+#define DUMMY_TRANSPORT_H
 #include "transport.h"
 
-class DummyTransport : public ITransport {
-    std::vector<uint8_t> inbuf, outbuf;
-
-public:
-    size_t write(const uint8_t* data, size_t size) override {
-        outbuf.insert(outbuf.end(), data, data + size);
-        return size;
-    }
-
-    size_t read(uint8_t* buffer, size_t size) override {
-        if (inbuf.size() < size) return 0;
-        std::copy(inbuf.begin(), inbuf.begin() + size, buffer);
-        inbuf.erase(inbuf.begin(), inbuf.begin() + size);
-        return size;
-    }
-
-    size_t read_byte(uint8_t& r) override {
-        uint8_t b[1];
-        if (read(b, 1) != 1){
-            return 0;
-        };
-        r = b[0];
-        return 1;
-    }
-
-    void push_data(const std::vector<uint8_t>& data) { inbuf.insert(inbuf.end(), data.begin(), data.end()); }
-    const std::vector<uint8_t>& get_output() const { return outbuf; }
+class DummyTransport: public ITransport {
+
+    const uint8_t* _dummy_buf;
+    size_t _dummy_buf_size = 0;
+
+    public:
+
+        DummyTransport(const uint8_t* buf, size_t size): _dummy_buf(buf), _dummy_buf_size(size){}
+
+        void begin(){}
+
+        bool available() override {
+            return _dummy_buf_size > 0;
+        }
+
+        size_t write(const uint8_t* data, size_t size) override {
+            // Mock write
+            return size;
+        }
+
+        size_t read(uint8_t* buffer, size_t size) override {
+            if (_dummy_buf_size == 0) return 0;
+
+            size_t r_size = 0;
+            for (size_t i = 0; i < _dummy_buf_size; i++){
+                buffer[r_size] = _dummy_buf[i];
+                delay(1);
+                r_size++;
+                if (r_size == size) break;
+            }
+
+            _dummy_buf_size = _dummy_buf_size - r_size;
+            return r_size;
+
+        }
+
+        size_t read_byte(uint8_t& r) override {
+            uint8_t b[1];
+            if (read(b, 1) != 1){
+                return 0;
+            };
+            r = b[0];
+            return 1;
+        }
+
 };
 
-#endif //DUMMYTRANSPORT_H
+#endif  //SERIALTRANSPORT_H

src/SerialTransport.h

@@ -16,6 +16,10 @@ class SerialTransport: public ITransport {
 
         void begin(){}
 
+        bool available() override {
+            return _stream->available();
+        }
+
         size_t write(const uint8_t* data, size_t size) override {
 
             for (size_t i=0; i<size; i++){

src/decoder.h

@@ -0,0 +1,120 @@
+#ifndef RPCLITE_DECODER_H
+#define RPCLITE_DECODER_H
+#include "transport.h"
+#include "MsgPack.h"
+
+
+#define CALL_MSG        0
+#define RESP_MSG        1
+#define NOTIFY_MSG      2
+
+#define MAX_BUFFER_SIZE 1024
+#define CHUNK_SIZE      32
+
+template<size_t BufferSize = MAX_BUFFER_SIZE>
+class RpcDecoder {
+
+public:
+    RpcDecoder(ITransport& transport) : _transport(transport) {}
+
+
+    void process(){
+        if (advance()) return parse_packet();
+    }
+
+    // Fill the raw buffer to its capacity
+    bool advance() {
+
+        uint8_t temp_buf[CHUNK_SIZE];
+    
+        if (_transport.available() && !buffer_full()){
+            int bytes_read = _transport.read(temp_buf, CHUNK_SIZE);
+            if (bytes_read <= 0) return false;
+    
+            for (int i = 0; i < bytes_read; ++i) {
+                _raw_buffer[_bytes_stored] = temp_buf[i];
+                _bytes_stored++;
+                while (buffer_full()){
+                    delay(1);
+                }
+            }
+        }
+        return true;
+    }
+
+    // Tries to parse the first packet only
+    void parse_packet(){
+
+        // Nop in case 1st packet is ready... waiting to deliver
+        if (_packet_ready){return;}
+
+        size_t bytes_checked = 0;
+
+        MsgPack::Unpacker unpacker;
+        while (bytes_checked < _bytes_stored) {
+            if (unpacker.feed(_raw_buffer, bytes_checked)) {
+                _packet_ready = true;
+                _packet_size = bytes_checked + 1;
+                return;
+            } else {
+                bytes_checked++;
+            }
+        }
+
+    }
+
+    // Check if a packet is available
+    bool packet_available() const { return _packet_ready; }
+
+    // Get the oldest packet (returns false if no packet available)
+    bool get_next_packet(MsgPack::Unpacker& unpacker) {
+        if (!_packet_ready) return false;
+        return unpacker.feed(_raw_buffer, _packet_size);
+    }
+
+    // Try to recover buffer error condition
+    void recover() {
+        // ensure parsing was attempted
+        parse_packet();
+        if (buffer_full() && !_packet_ready){
+            flush_buffer();
+        }
+    }
+
+    // Discard the oldest packet. Returns the number of freed_bytes
+    size_t pop_packet() {
+
+        if (!_packet_ready) return false;
+
+        const size_t remaining_bytes = _bytes_stored - _packet_size;
+
+        // Shift remaining data forward (manual memmove for compatibility)
+        for (size_t i = 0; i < remaining_bytes; i++) {
+            _raw_buffer[i] = _raw_buffer[_packet_size + i];
+        }
+
+        _bytes_stored = remaining_bytes;
+        _packet_ready = false;
+        _packet_size = 0; // Reset packet state
+        
+        return _packet_size;
+    }
+
+private:
+    ITransport& _transport;
+    uint8_t _raw_buffer[BufferSize];
+    size_t _bytes_stored = 0;
+
+    bool _packet_ready = false;
+    size_t _packet_size = 0;
+
+    inline bool buffer_full() const { return _bytes_stored == BufferSize; }
+    inline bool buffer_empy() const { return _bytes_stored == 0;}
+    inline void flush_buffer() {
+        uint8_t* discard_buf;
+        while (_transport.read(discard_buf, CHUNK_SIZE) > 0);
+        _bytes_stored = 0;
+    }
+};
+
+#endif

src/transport.h

@@ -14,6 +14,7 @@ class ITransport {
     virtual size_t write(const uint8_t* data, size_t size) = 0;
     virtual size_t read(uint8_t* buffer, size_t size) = 0;
     virtual size_t read_byte(uint8_t& r) = 0;
+    virtual bool available() = 0;
     //virtual ~ITransport() = default;
 };