Added base-writer class

luprex/cpp/core/base-writer.hpp

@@ -0,0 +1,169 @@
+/////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: This is a header-only library that is included
+// by the graphics engine as well.  It cannot contain references
+// to anything else in the engine.
+//
+
+
+#include <cstdio>
+#include <cstdint>
+#include <cstdlib>
+#include <string_view>
+
+///////////////////////////////////////////////////////////////
+//
+// BaseWriter
+//
+// This base class provides the following methods:
+//
+//     void write_uint8(uint64_t data)
+//     void write_uint16(uint64_t data)
+//     void write_uint32(uint64_t data)
+//     void write_uint64(uint64_t data)
+//     void write_int8(int64_t data)
+//     void write_int16(int64_t data)
+//     void write_int32(int64_t data)
+//     void write_int64(int64_t data)
+//     void write_char(char c)
+//     void write_float(float data)
+//     void write_double(double data)
+//     void write_bytes(std::string_view bytes)
+//     void write_string(std::string_view bytes)
+//
+// In order to derive from BaseWriter, you must use the CRTP pattern:
+//
+//     class DerivedWriter : public BaseWriter<DerivedWriter>
+//
+// And you must provide two methods in the derived class:
+//
+//     write_bytes(const char *n, size_t size)
+//
+//     raise_truncated()
+//
+///////////////////////////////////////////////////////////////
+
+template<class Derived>
+class BaseWriter {
+protected:
+    template<class T>
+    void write_value_core(T arg) {
+        static_cast<Derived*>(this)->write_bytes((const char *)&arg, sizeof(arg));
+    }
+
+    template<class T, class XT>
+    void write_int_core(XT arg) {
+        T reduced = arg;
+        if (XT(reduced) != arg) static_cast<Derived*>(this)->raise_truncated();
+        write_value_core(reduced);
+    }
+
+public:
+
+    void write_uint8(uint64_t data) { write_int_core<uint8_t, uint64_t>(data); }
+    void write_uint16(uint64_t data) { write_int_core<uint16_t, uint64_t>(data); }
+    void write_uint32(uint64_t data) { write_int_core<uint32_t, uint64_t>(data); }
+    void write_uint64(uint64_t data) { write_int_core<uint64_t, uint64_t>(data); }
+    void write_int8(int64_t data) { write_int_core<int8_t, int64_t>(data); }
+    void write_int16(int64_t data) { write_int_core<int16_t, int64_t>(data); }
+    void write_int32(int64_t data) { write_int_core<int32_t, int64_t>(data); }
+    void write_int64(int64_t data) { write_int_core<int64_t, int64_t>(data); }
+    
+    void write_bool(bool b) { write_uint8(b ? 1:0); }
+    void write_char(char c) { write_value_core(c); }
+    void write_float(float arg) { write_value_core(arg); }
+    void write_double(double arg) { write_value_core(arg); }
+
+    void write_string(std::string_view s) {
+        if (s.size() >= 255) {
+            write_uint8(0xFF);
+            write_uint64(s.size());
+            static_cast<Derived*>(this)->write_bytes(s.data(), s.size());
+        } else {
+            write_uint8(s.size());
+            static_cast<Derived*>(this)->write_bytes(s.data(), s.size());
+        }
+    }
+};
+
+///////////////////////////////////////////////////////////////
+//
+// BaseReader
+//
+// This base class provides the following methods:
+//
+//     uint8_t read_uint8();
+//     uint16_t read_uint16();
+//     uint32_t read_uint32();
+//     uint64_t read_uint64();
+//     int8_t read_int8();
+//     int16_t read_int16();
+//     int32_t read_int32();
+//     int64_t read_int64();
+//     bool read_bool();
+//     char read_char();
+//     float read_float();
+//     double read_double();
+//     string read_string_limit(int64_t size);
+//     string read_string();
+//
+// In order to derive from BaseReader, you must use the CRTP pattern:
+//
+//     class DerivedReader : public BaseReader<DerivedReader>
+//
+// The derived class must provide:
+//
+//     using string = std::string (or similar)
+//
+//     void read_bytes_into(char *n, size_t size)
+//
+//     void raise_string_too_long();
+//
+///////////////////////////////////////////////////////////////
+
+template<class Derived, class String>
+class BaseReader {
+protected:
+
+    template<class T>
+    T read_value_core() {
+        T result;
+        static_cast<Derived*>(this)->read_bytes_into((char *)(&result), sizeof(result));
+        return result;
+    }
+
+public:
+
+    uint8_t read_uint8() { return read_value_core<uint8_t>(); }
+    uint16_t read_uint16() { return read_value_core<uint16_t>(); }
+    uint32_t read_uint32() { return read_value_core<uint32_t>(); }
+    uint64_t read_uint64() { return read_value_core<uint64_t>(); }
+    int8_t read_int8() { return read_value_core<int8_t>(); }
+    int16_t read_int16() { return read_value_core<int16_t>(); }
+    int32_t read_int32() { return read_value_core<int32_t>(); }
+    int64_t read_int64() { return read_value_core<int64_t>(); }
+    
+    bool read_bool() { return read_uint8(); }
+    char read_char() { return read_value_core<char>(); }
+    float read_float() { return read_value_core<float>(); }
+    double read_double() { return read_value_core<double>(); }
+    
+    String read_string_limit(int64_t limit) {
+        uint64_t size = read_uint8();
+        if (size == 255) {
+            size = read_uint64();
+        }
+        if ((limit < 0)||(size > uint64_t(limit))) {
+            static_cast<Derived*>(this)->raise_string_too_long();
+        }
+        String result;
+        result.resize(size);
+        static_cast<Derived*>(this)->read_bytes_into(&result[0], size);
+        return result;
+    }
+
+    String read_string() {
+        return read_string_limit(0xFFFFFFF);
+    }
+};
+