Add byte reader

Author: dshil

components/ocs_core/CMakeLists.txt

@@ -16,6 +16,7 @@ idf_component_register(
     "file_stream_reader.cpp"
     "stream_transceiver.cpp"
     "byte_writer.cpp"
+    "byte_reader.cpp"
 
     REQUIRES
     "json"

components/ocs_core/byte_reader.cpp

@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Tendry Lab
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <algorithm>
+#include <cstring>
+
+#include "ocs_core/byte_reader.h"
+
+namespace ocs {
+namespace core {
+
+ByteReader::ByteReader(const uint8_t* data, size_t size)
+    : data_(data)
+    , size_(size) {
+}
+
+size_t ByteReader::get_len() const {
+    return size_ - offset_;
+}
+
+size_t ByteReader::get_cap() const {
+    return size_;
+}
+
+const uint8_t* ByteReader::get_data() const {
+    return data_ + offset_;
+}
+
+size_t ByteReader::read(uint8_t* data, size_t size) {
+    const size_t ret = std::min(size, get_len());
+
+    if (ret) {
+        memcpy(data, get_data(), ret);
+        offset_ += ret;
+    }
+
+    return ret;
+}
+
+} // namespace core
+} // namespace ocs

components/ocs_core/byte_reader.h

@@ -0,0 +1,70 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Tendry Lab
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+#include "ocs_core/noncopyable.h"
+
+namespace ocs {
+namespace core {
+
+class ByteReader : private core::NonCopyable<> {
+public:
+    //! Initialize.
+    //!
+    //! @remarks
+    //!  - @p data should be valid until ByteReader exists.
+    ByteReader(const uint8_t* data, size_t size);
+
+    //! Return number of bytes left.
+    size_t get_len() const;
+
+    //! Return size of the underlying array of bytes.
+    size_t get_cap() const;
+
+    //! Return pointer to the underlying data.
+    //!
+    //! @remarks
+    //!  Offset is taken into account.
+    const uint8_t* get_data() const;
+
+    //! Read @p size bytes to @p data buffer.
+    //!
+    //! @returns
+    //!  Number of read bytes or 0 if no bytes left.
+    size_t read(uint8_t* data, size_t size);
+
+    //! Read any integral value.
+    template <typename T> bool read(T& t) {
+        static_assert(std::is_integral<T>::value, "require integer type");
+
+        if (get_len() < sizeof(t)) {
+            return false;
+        }
+
+        t = 0;
+
+        for (size_t n = offset_; n < offset_ + sizeof(t); ++n) {
+            t = (t << 8) | data_[n];
+        }
+
+        offset_ += sizeof(t);
+
+        return true;
+    }
+
+private:
+    const uint8_t* data_ { nullptr };
+    const size_t size_ { 0 };
+
+    size_t offset_ { 0 };
+};
+
+} // namespace core
+} // namespace ocs

components/ocs_core/test/CMakeLists.txt

@@ -7,6 +7,7 @@ idf_component_register(
     "test_rate_limiter.cpp"
     "test_stream_transceiver.cpp"
     "test_byte_writer.cpp"
+    "test_byte_reader.cpp"
 
     REQUIRES
     "unity"

components/ocs_core/test/test_byte_reader.cpp

@@ -0,0 +1,102 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Tendry Lab
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <cstring>
+
+#include "unity.h"
+
+#include "ocs_core/byte_reader.h"
+
+namespace ocs {
+namespace core {
+
+TEST_CASE("Byte reader: read array: whole at once", "[ocs_core], [byte_reader]") {
+    uint8_t write_buf[42];
+    memset(write_buf, 5, sizeof(write_buf));
+
+    ByteReader reader(write_buf, sizeof(write_buf));
+    TEST_ASSERT_EQUAL(sizeof(write_buf), reader.get_len());
+
+    uint8_t read_buf[sizeof(write_buf)];
+    memset(read_buf, 0, sizeof(read_buf));
+
+    TEST_ASSERT_EQUAL(sizeof(write_buf), reader.read(read_buf, sizeof(read_buf)));
+    TEST_ASSERT_TRUE(memcmp(write_buf, read_buf, sizeof(write_buf)) == 0);
+}
+
+TEST_CASE("Byte reader: read byte", "[ocs_core], [byte_reader]") {
+    uint8_t write_buf[42];
+    memset(write_buf, 5, sizeof(write_buf));
+
+    ByteReader reader(write_buf, sizeof(write_buf));
+    TEST_ASSERT_EQUAL(sizeof(write_buf), reader.get_len());
+
+    for (size_t n = 0; n < sizeof(write_buf); ++n) {
+        uint8_t byte = 0;
+        TEST_ASSERT_TRUE(reader.read(byte));
+        TEST_ASSERT_EQUAL(5, byte);
+    }
+
+    uint8_t byte = 0;
+    TEST_ASSERT_FALSE(reader.read(byte));
+}
+
+TEST_CASE("Byte reader: read by offset: whole at once", "[ocs_core], [byte_reader]") {
+    uint8_t write_buf[42];
+    memset(write_buf, 5, sizeof(write_buf));
+
+    ByteReader reader(write_buf, sizeof(write_buf));
+    TEST_ASSERT_EQUAL(sizeof(write_buf), reader.get_len());
+    TEST_ASSERT_EQUAL_PTR(write_buf, reader.get_data());
+
+    uint8_t byte = 0;
+    TEST_ASSERT_TRUE(reader.read(byte));
+    TEST_ASSERT_EQUAL(5, byte);
+    TEST_ASSERT_EQUAL(sizeof(write_buf) - 1, reader.get_len());
+
+    ByteReader off_reader(reader.get_data(), reader.get_len());
+    TEST_ASSERT_EQUAL_PTR(write_buf + 1, off_reader.get_data());
+    TEST_ASSERT_EQUAL(sizeof(write_buf) - 1, reader.get_len());
+    TEST_ASSERT_TRUE(memcmp(write_buf + 1, off_reader.get_data(), off_reader.get_len())
+                     == 0);
+}
+
+TEST_CASE("Byte reader: read by offset: read less", "[ocs_core], [byte_reader]") {
+    uint8_t write_buf[42];
+    memset(write_buf, 5, sizeof(write_buf));
+
+    ByteReader reader(write_buf, sizeof(write_buf));
+    TEST_ASSERT_EQUAL(sizeof(write_buf), reader.get_len());
+
+    uint8_t byte = 0;
+    TEST_ASSERT_TRUE(reader.read(byte));
+    TEST_ASSERT_EQUAL(5, byte);
+
+    TEST_ASSERT_TRUE(reader.read(byte));
+    TEST_ASSERT_EQUAL(5, byte);
+
+    TEST_ASSERT_EQUAL(sizeof(write_buf) - 2, reader.get_len());
+
+    uint8_t read_buf[sizeof(write_buf)];
+    memset(read_buf, 0, sizeof(read_buf));
+
+    TEST_ASSERT_EQUAL(sizeof(read_buf) - 2, reader.read(read_buf, sizeof(read_buf)));
+    TEST_ASSERT_TRUE(memcmp(write_buf + 2, read_buf, sizeof(read_buf) - 2) == 0);
+
+    TEST_ASSERT_FALSE(reader.read(byte));
+
+    ByteReader off_reader(read_buf + sizeof(read_buf) - 2, 2);
+
+    TEST_ASSERT_TRUE(off_reader.read(byte));
+    TEST_ASSERT_EQUAL(0, byte);
+
+    TEST_ASSERT_TRUE(off_reader.read(byte));
+    TEST_ASSERT_EQUAL(0, byte);
+
+    TEST_ASSERT_FALSE(off_reader.read(byte));
+}
+
+} // namespace core
+} // namespace ocs