#1 - quicr module

2026-07-22 17:34:44 +02:00
parent a04f0dc262
commit e6dd954ded
149 changed files with 3997 additions and 2126 deletions
@@ -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
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "bytebuffer/ByteBuffer.hpp"
+#include <type_traits>
+
+namespace tw::net {
+template<typename T, typename Enable = void>
+struct ByteBufferCodec
+{
+    static size_t encoding(RingByteBuffer&, T*, size_t offset)
+    {
+        static_assert(sizeof(T) == 0, "No decoder for this type");
+    }
+};
+
+/**
+ * Default implementation for trivially copyable types
+ */
+template<typename T>
+struct ByteBufferCodec<T, std::enable_if_t<std::is_trivially_copyable_v<T>>>
+{
+    static size_t encoding(RingByteBuffer& buf, T* target, size_t offset)
+    {
+        return buf.peek_bytes(target, sizeof(T), offset);
+    }
+};
+}
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "ByteBuffer.hpp"
+
+namespace tw::net {
+
+template<typename T, typename Enable = void>
+struct ByteBufferCodec
+{
+    static T bytes(RingByteBuffer&, size_t)
+    {
+        static_assert(sizeof(T) == 0, "No decoder for this type");
+    }
+};
+
+/**
+ * Default implementation for trivially copyable types
+ */
+template<typename T>
+struct ByteBufferCodec<T, std::enable_if_t<std::is_trivially_copyable_v<T>>>
+{
+    static std::optional<T> encoding(RingByteBuffer& buf, size_t offset = 0)
+    {
+        T value;
+        size_t r = buf.peek_bytes(&value, sizeof(T), offset);
+        if(r < sizeof(T)) {
+            return {};
+        }
+
+        return value;
+    }
+};
+
+struct ByteBufferDecoder {
+    ByteBufferDecoder(RingByteBuffer& buf) : m_buf(buf) {}
+
+    template<typename T>
+    std::optional<T> pop(size_t offset = 0)
+    {
+        std::optional<T> s = ByteBufferCodec<T>::bytes(m_buf, offset);
+        m_buf.skip(sizeof(T));
+
+        return s;
+    }
+
+    template<typename T>
+    std::optional<T> peek(size_t offset = 0) {
+        return ByteBufferCodec<T>::bytes(m_buf, offset);
+    }
+
+private:
+    RingByteBuffer& m_buf;
+};
+
+}
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "ByteBuffer.hpp"
+#include "bytebuffer/ByteBufferCodec.hpp"
+
+namespace tw::net {
+
+
+struct ByteBufferDecoder {
+    ByteBufferDecoder(RingByteBuffer& buf) : m_buf(buf) {}
+
+    template<typename T>
+    std::optional<T> push(size_t offset = 0)
+    {
+        std::optional<T> s = ByteBufferCodec<T>::bytes(m_buf, offset);
+        m_buf.skip(sizeof(T));
+
+        return s;
+    }
+
+private:
+    RingByteBuffer& m_buf;
+};
+
+}
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <cstring>
+#include <span>
+#include <spdlog/spdlog.h>
+
+namespace tw::net {
+
+/**
+ * Circular byte buffer.
+ */
+class ByteBufferReader {
+public:
+    ByteBufferReader(std::span<std::byte> target) : buffer(target), readOffset(0) {}
+
+    ByteBufferReader(std::span<const std::byte> target) : buffer(target), readOffset(0) {}
+
+    size_t peek_bytes(void* dst, size_t size, size_t offset = 0) {
+        if(remaining() - offset < size) {
+            spdlog::warn("Could not peek entire frame, remaining: {}/{}", remaining() - offset, size);
+            return 0;
+        }
+
+        size_t cursor = readOffset + offset;
+
+        // 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) {
+            spdlog::warn("Could not read entire frame, peeked only: {}/{}", peeked, size);
+            return 0;
+        }
+
+        skip(size);
+        return size;
+    }
+
+    size_t pop_bytes(std::span<std::byte> dst) {
+        return pop_bytes(dst.data(), dst.size());
+    }
+
+    size_t position() const {
+        return readOffset;
+    }
+
+    size_t remaining() const {
+        return buffer.size() - readOffset;
+    }
+
+    void reset() {
+        readOffset = 0;
+    }
+
+    void skip(size_t bytes) {
+        readOffset = (readOffset + std::min(bytes, remaining()));
+    }
+
+private:
+    std::span<const std::byte> buffer;
+    size_t readOffset = 0;
+};
+
+} // namespace tw::net
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "io/Read.hpp"
+#include "ByteBuffer.hpp"
+
+namespace tw::net {
+
+class ByteBufferStreamReader {
+public:
+    static size_t read(Read<std::byte>* from, RingByteBuffer* to) {
+        auto block = to->get_next_available_block();
+        auto r = from->read_into(block);
+        if(!r || *r == 0) {
+            return 0;
+        }
+
+        to->skip_write(*r);
+
+        if(*r == block.size()) {
+            auto next_block = to->get_next_available_block();
+            if(next_block.size() == 0) {
+                return *r;
+            }
+
+            auto r2 = from->read_into(next_block);
+            if(!r2 || *r2 == 0) {
+                return *r;
+            }
+
+            to->skip_write(*r2);
+            return *r + *r2;
+        }
+
+        return *r;
+    }
+};
+
+}
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <cstring>
+#include <span>
+#include <spdlog/spdlog.h>
+
+namespace tw::net {
+
+/**
+ * Circular byte buffer.
+ */
+class ByteBufferWriter {
+public:
+    ByteBufferWriter(std::span<std::byte> target) : buffer(target) {}
+
+    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() < 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();
+    }
+
+    constexpr size_t length() const {
+        return writeOffset;
+    }
+
+    size_t remaining() const {
+        return buffer.size() - writeOffset;
+    }
+
+    void reset() {
+        writeOffset = 0;
+    }
+
+    void skip_write(size_t bytes) {
+        writeOffset = (writeOffset + std::min(bytes, remaining()));
+    }
+
+private:
+    std::span<std::byte> buffer;
+    size_t writeOffset = 0;
+};
+
+} // namespace tw::net