SerDes.h

//
//  SerDes.h
//
//
//  Created by Dale Glass on 5/6/2022
//  Copyright 2024 Overte e.V.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
 
#pragma once
#include <string>
#include <cstring>
#include <QtCore/QByteArray>
#include <QDebug>
#include <glm/glm.hpp>
 
class DataSerializer {
    public:
 
        class SizeTracker {
            public:
            SizeTracker(DataSerializer &parent) : _parent(parent) {
                _start_pos = _parent.pos();
            }
 
            ~SizeTracker() {
                size_t cur_pos = _parent.pos();
 
                if ( cur_pos >= _start_pos ) {
                    _parent._lastAdvance = cur_pos - _start_pos;
                } else {
                    _parent._lastAdvance = 0;
                }
            }
 
            private:
            DataSerializer &_parent;
            size_t _start_pos = 0;
        };
 
        static const int DEFAULT_SIZE = 1500;
 
        static const char PADDING_CHAR = (char)0xAA;
 
        DataSerializer() {
            _capacity = DEFAULT_SIZE;
            _pos = 0;
            _length = 0;
            _store = new char[_capacity];
        }
 
        DataSerializer(char *externalStore, size_t storeLength) {
            _capacity = storeLength;
            _length = 0;
            _pos = 0;
            _storeIsExternal = true;
            _store = externalStore;
        }
 
        DataSerializer(uint8_t *externalStore, size_t storeLength) : DataSerializer((char*)externalStore, storeLength) {
 
        }
 
        DataSerializer(const DataSerializer &) = delete;
        DataSerializer &operator=(const DataSerializer &) = delete;
 
 
 
        ~DataSerializer() {
            if (!_storeIsExternal) {
                delete[] _store;
            }
        }
 
        void addPadding(size_t bytes) {
            if (!extendBy(bytes, "padding")) {
                return;
            }
 
            // Fill padding with something recognizable. Will keep valgrind happier.
            memset(&_store[_pos], PADDING_CHAR, bytes);
            _pos += bytes;
        }
 
        DataSerializer &operator<<(uint8_t c) {
            return *this << int8_t(c);
        }
 
        DataSerializer &operator<<(int8_t c) {
            if (!extendBy(1, "int8_t")) {
                return *this;
            }
 
            _store[_pos++] = c;
            return *this;
        }
 
 
 
        DataSerializer &operator<<(uint16_t val) {
            return *this << int16_t(val);
        }
 
        DataSerializer &operator<<(int16_t val) {
            if (!extendBy(sizeof(val), "int16_t")) {
                return *this;
            }
 
            memcpy(&_store[_pos], (char*)&val, sizeof(val));
            _pos += sizeof(val);
            return *this;
        }
 
 
 
 
        DataSerializer &operator<<(uint32_t val) {
            return *this << int32_t(val);
        }
 
        DataSerializer &operator<<(int32_t val) {
            if (!extendBy(sizeof(val), "int32_t")) {
                return *this;
            }
 
            memcpy(&_store[_pos], (char*)&val, sizeof(val));
            _pos += sizeof(val);
            return *this;
        }
 
 
        DataSerializer &operator<<(uint64_t val) {
            return *this << int64_t(val);
        }
 
        DataSerializer &operator<<(int64_t val) {
            if (!extendBy(sizeof(val), "int64_t")) {
                return *this;
            }
 
            memcpy(&_store[_pos], (char*)&val, sizeof(val));
            _pos += sizeof(val);
            return *this;
        }
 
 
        DataSerializer &operator<<(float val) {
            if (extendBy(sizeof(val), "float")) {
                memcpy(&_store[_pos], (char*)&val, sizeof(val));
                _pos += sizeof(val);
            }
            return *this;
        }
 
 
 
 
        DataSerializer &operator<<(glm::vec3 val) {
            size_t sz = sizeof(val.x);
            if (extendBy(sz*3, "glm::vec3")) {
                memcpy(&_store[_pos       ], (char*)&val.x, sz);
                memcpy(&_store[_pos + sz  ], (char*)&val.y, sz);
                memcpy(&_store[_pos + sz*2], (char*)&val.z, sz);
 
                _pos += sz*3;
            }
            return *this;
        }
 
 
        DataSerializer &operator<<(glm::vec4 val) {
            size_t sz = sizeof(val.x);
            if (extendBy(sz*4, "glm::vec4")) {
                memcpy(&_store[_pos       ], (char*)&val.x, sz);
                memcpy(&_store[_pos + sz  ], (char*)&val.y, sz);
                memcpy(&_store[_pos + sz*2], (char*)&val.z, sz);
                memcpy(&_store[_pos + sz*3], (char*)&val.w, sz);
 
                _pos += sz*4;
            }
            return *this;
        }
 
 
        DataSerializer &operator<<(glm::ivec2 val) {
            size_t sz = sizeof(val.x);
            if (extendBy(sz*2, "glm::ivec2")) {
                memcpy(&_store[_pos       ], (char*)&val.x, sz);
                memcpy(&_store[_pos + sz  ], (char*)&val.y, sz);
 
                _pos += sz*2;
            }
            return *this;
        }
 
 
 
        DataSerializer &operator<<(const char *val) {
            size_t len = strlen(val)+1;
            if (extendBy(len, "string")) {
                memcpy(&_store[_pos], val, len);
                _pos += len;
            }
            return *this;
        }
 
        DataSerializer &operator<<(const QString &val) {
            return *this << val.toUtf8().constData();
        }
 
 
 
        char *buffer() const { return _store; }
 
        size_t pos() const { return _pos; }
 
        size_t length() const { return _length; }
 
        size_t capacity() const { return _capacity; }
 
        bool isEmpty() const { return _length == 0; }
 
        bool isOverflow() const { return _overflow; }
 
        void rewind() { _pos = 0; _overflow = false; _lastAdvance = 0; }
 
 
        size_t lastAdvance() const { return _lastAdvance; }
 
        friend QDebug operator<<(QDebug debug, const DataSerializer &ds);
 
    private:
        bool extendBy(size_t bytes, const QString &type_name) {
            //qDebug() << "Extend by" << bytes;
 
            if ( _capacity < _length + bytes) {
                if ( _storeIsExternal ) {
                    qCritical() << "Serializer trying to write past end of output buffer of" << _capacity << "bytes. Error writing" << bytes << "bytes for" << type_name << " from position " << _pos << ", length " << _length;
                    _overflow = true;
                    return false;
                }
 
                changeAllocation(_length + bytes);
            }
 
            _length += bytes;
            _lastAdvance = bytes;
            return true;
        }
 
        // This is split up here to try to make the class as inline-friendly as possible.
        void changeAllocation(size_t new_size);
 
        char *_store;
        bool _storeIsExternal = false;
        bool _overflow = false;
        size_t _capacity = 0;
        size_t _length = 0;
        size_t _pos = 0;
        size_t _lastAdvance = 0;
};
 
class DataDeserializer {
    public:
 
        class SizeTracker {
            public:
            SizeTracker(DataDeserializer &parent) : _parent(parent) {
                _start_pos = _parent.pos();
            }
 
            ~SizeTracker() {
                size_t cur_pos = _parent.pos();
 
                if ( cur_pos >= _start_pos ) {
                    _parent._lastAdvance = cur_pos - _start_pos;
                } else {
                    _parent._lastAdvance = 0;
                }
            }
 
            private:
            DataDeserializer &_parent;
            size_t _start_pos = 0;
        };
 
        DataDeserializer(const char *externalStore, size_t storeLength) {
            _length = storeLength;
            _pos = 0;
            _store = externalStore;
            _lastAdvance = 0;
        }
 
        DataDeserializer(const uint8_t *externalStore, size_t storeLength) : DataDeserializer((const char*)externalStore, storeLength) {
 
        }
 
        DataDeserializer(const DataSerializer &serializer) : DataDeserializer(serializer.buffer(), serializer.length()) {
 
        }
 
        void skipPadding(size_t bytes) {
            if (!canAdvanceBy(bytes, "padding")) {
                return;
            }
 
            _pos += bytes;
            _lastAdvance = bytes;
        }
 
 
        DataDeserializer &operator>>(uint8_t &c) {
            return *this >> reinterpret_cast<int8_t&>(c);
        }
 
        DataDeserializer &operator>>(int8_t &c) {
            if ( canAdvanceBy(1, "int8_t") ) {
                c = _store[_pos++];
                _lastAdvance = sizeof(c);
            }
 
            return *this;
        }
 
 
        DataDeserializer &operator>>(uint16_t &val) {
            return *this >> reinterpret_cast<int16_t&>(val);
        }
 
        DataDeserializer &operator>>(int16_t &val) {
            if ( canAdvanceBy(sizeof(val), "int16_t") ) {
                memcpy((char*)&val, &_store[_pos], sizeof(val));
                _pos += sizeof(val);
                _lastAdvance = sizeof(val);
            }
 
            return *this;
        }
 
 
        DataDeserializer &operator>>(uint32_t &val) {
            return *this >> reinterpret_cast<int32_t&>(val);
        }
 
        DataDeserializer &operator>>(int32_t &val) {
            if ( canAdvanceBy(sizeof(val), "int32_t") ) {
                memcpy((char*)&val, &_store[_pos], sizeof(val));
                _pos += sizeof(val);
                _lastAdvance = sizeof(val);
            }
            return *this;
        }
 
 
        DataDeserializer &operator>>(uint64_t &val) {
            return *this >> reinterpret_cast<int64_t&>(val);
        }
 
        DataDeserializer &operator>>(int64_t &val) {
            if ( canAdvanceBy(sizeof(val), "int64_t") ) {
                memcpy((char*)&val, &_store[_pos], sizeof(val));
                _pos += sizeof(val);
                _lastAdvance = sizeof(val);
            }
            return *this;
        }
 
 
 
        DataDeserializer &operator>>(float &val) {
            if ( canAdvanceBy(sizeof(val), "float") ) {
                memcpy((char*)&val, &_store[_pos], sizeof(val));
                _pos += sizeof(val);
                _lastAdvance = sizeof(val);
            }
            return *this;
        }
 
 
 
 
 
        DataDeserializer &operator>>(glm::vec3 &val) {
            size_t sz = sizeof(val.x);
 
            if ( canAdvanceBy(sz*3, "glm::vec3") ) {
                memcpy((char*)&val.x, &_store[_pos       ], sz);
                memcpy((char*)&val.y, &_store[_pos + sz  ], sz);
                memcpy((char*)&val.z, &_store[_pos + sz*2], sz);
 
                _pos += sz*3;
                _lastAdvance = sz * 3;
            }
 
            return *this;
        }
 
 
 
        DataDeserializer &operator>>(glm::vec4 &val) {
            size_t sz = sizeof(val.x);
 
            if ( canAdvanceBy(sz*4, "glm::vec4")) {
                memcpy((char*)&val.x, &_store[_pos       ], sz);
                memcpy((char*)&val.y, &_store[_pos + sz  ], sz);
                memcpy((char*)&val.z, &_store[_pos + sz*2], sz);
                memcpy((char*)&val.w, &_store[_pos + sz*3], sz);
 
                _pos += sz*4;
                _lastAdvance = sz*4;
            }
            return *this;
        }
 
 
 
        DataDeserializer &operator>>(glm::ivec2 &val) {
            size_t sz = sizeof(val.x);
 
            if ( canAdvanceBy(sz*2, "glm::ivec2") ) {
                memcpy((char*)&val.x, &_store[_pos       ], sz);
                memcpy((char*)&val.y, &_store[_pos + sz  ], sz);
 
                _pos += sz*2;
                _lastAdvance = sz * 2;
            }
 
            return *this;
        }
 
 
        const char *buffer() const { return _store; }
 
        size_t pos() const { return _pos; }
 
        size_t length() const { return _length; }
 
        bool isEmpty() const { return _length == 0; }
 
        bool isOverflow() const { return _overflow; }
 
        void rewind() { _pos = 0; _overflow = false; _lastAdvance = 0; }
 
        size_t lastAdvance() const { return _lastAdvance; }
 
        friend QDebug operator<<(QDebug debug, const DataDeserializer &ds);
 
    private:
        bool canAdvanceBy(size_t bytes, const QString &type_name) {
            //qDebug() << "Checking advance by" << bytes;
 
            if ( _length < _pos + bytes) {
                qCritical() << "Deserializer trying to read past end of input buffer of" << _length << "bytes, reading" << bytes << "bytes for" << type_name << "from position " << _pos;
                _overflow = true;
                return false;
            }
 
            return true;
        }
 
        const char *_store;
        bool _overflow = false;
        size_t _length = 0;
        size_t _pos = 0;
        size_t _lastAdvance = 0;
};