#1 - quicr module

modules/io/include/bytebuffer/ByteBuffer.hpp

@@ -0,0 +1,126 @@
+#pragma once
+
+#include <cstring>
+#include <optional>
+#include <span>
+#include <spdlog/spdlog.h>
+#include <vector>
+
+namespace tw::net {
+
+/**
+ * Circular byte buffer.
+ */
+class RingByteBuffer {
+public:
+    RingByteBuffer(std::span<std::byte> target, bool is_for_reading) : buffer(target), writeOffset(is_for_reading ? target.size() : 0) {}
+
+    size_t peek_bytes(void* dst, size_t size, size_t offset = 0) {
+        if(remaining_read() - offset < size) {
+            return 0;
+        }
+
+        size_t cursor = (readOffset + offset) % buffer.size();
+
+        if(cursor + size <= buffer.size()) {
+            std::memcpy(dst, buffer.data() + cursor, size);
+        } else {
+            size_t firstPart = buffer.size() - cursor;
+            std::memcpy(dst, buffer.data() + cursor, firstPart);
+            std::memcpy((std::byte*)dst + firstPart, buffer.data(), size - firstPart);
+        }
+
+        return size;
+    }
+
+    template<typename T>
+    size_t pop_bytes(T* dst) {
+        return pop_bytes(dst, sizeof(T));
+    }
+
+    size_t pop_bytes(void* dst, size_t size) {
+        size_t peeked = peek_bytes(dst, size);
+        if(peeked < size) {
+            return 0;
+        }
+
+        skip(size);
+        return size;
+    }
+
+    size_t pop_bytes(std::span<std::byte> dst) {
+        return pop_bytes(dst.data(), dst.size());
+    }
+
+    template<typename T>
+    size_t write_bytes(const T *data) {
+        return write_bytes((void*)data, sizeof(T));
+    }
+
+    size_t write_bytes(void* data, size_t size) {
+        return write_bytes(std::span<const std::byte>{(std::byte*)data, (std::byte*)data + size});
+    }
+
+    size_t write_bytes(std::span<const std::byte> data) {
+        if(remaining_write() < data.size()) {
+            return 0;
+        }
+
+        if(writeOffset + data.size() <= buffer.size()) {
+            std::memcpy(buffer.data() + writeOffset, data.data(), data.size());
+            writeOffset += data.size();
+        } else {
+            size_t firstPart = buffer.size() - writeOffset;
+            std::memcpy(buffer.data() + writeOffset, data.data(), firstPart);
+            std::memcpy(buffer.data(), data.data() + firstPart, data.size() - firstPart);
+            writeOffset = (writeOffset + data.size()) % buffer.size();
+        }
+
+        return data.size();
+    }
+
+    size_t remaining_write() const {
+        if(writeOffset >= readOffset) {
+            return buffer.size() - writeOffset + readOffset;
+        } else {
+            return readOffset - writeOffset;
+        }
+    }
+
+    size_t remaining_read() const {
+        if(writeOffset >= readOffset) {
+            return writeOffset - readOffset;
+        }
+
+        return buffer.size() - readOffset + writeOffset;
+    }
+
+    void reset() {
+        readOffset = 0;
+        writeOffset = 0;
+    }
+
+    void skip(size_t bytes) {
+        readOffset = (readOffset + std::min(bytes, remaining_read())) % buffer.size();
+        spdlog::info("New read offset: {}", readOffset);
+    }
+
+    void skip_write(size_t bytes) {
+        writeOffset = (writeOffset + std::min(bytes, remaining_write())) % buffer.size();
+    }
+
+    std::span<std::byte> get_next_available_block() {
+        if (writeOffset >= readOffset) {
+            return std::span(buffer.data() + writeOffset, buffer.size() - writeOffset);
+        } else {
+            return std::span(buffer.data() + writeOffset, readOffset - writeOffset);
+        }
+    }
+
+private:
+    std::span<std::byte> buffer;
+    size_t readOffset = 0;
+    size_t writeOffset = 0;
+};
+
+} // namespace tw::net