datastream.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <cstring>
#include <promeki/core/namespace.h>
#include <promeki/core/string.h>
#include <promeki/core/buffer.h>
#include <promeki/core/variant.h>
#include <promeki/core/iodevice.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream {
        public:
                enum ByteOrder {
                        BigEndian,    
                        LittleEndian  
                };
 
                enum Status {
                        Ok,              
                        ReadPastEnd,     
                        ReadCorruptData, 
                        WriteFailed      
                };
 
                enum TypeId : uint8_t {
                        TypeInt8    = 0x01, 
                        TypeUInt8   = 0x02, 
                        TypeInt16   = 0x03, 
                        TypeUInt16  = 0x04, 
                        TypeInt32   = 0x05, 
                        TypeUInt32  = 0x06, 
                        TypeInt64   = 0x07, 
                        TypeUInt64  = 0x08, 
                        TypeFloat   = 0x09, 
                        TypeDouble  = 0x0A, 
                        TypeBool    = 0x0B, 
                        TypeString  = 0x0C, 
                        TypeBuffer  = 0x0D, 
                        TypeVariant = 0x0E  
                };
 
                static constexpr uint16_t CurrentVersion = 1;
 
                static constexpr uint8_t Magic[4] = { 0x50, 0x4D, 0x44, 0x53 };
 
                static DataStream createWriter(IODevice *device);
 
                static DataStream createReader(IODevice *device);
 
                explicit DataStream(IODevice *device);
 
                ~DataStream() = default;
 
                // ============================================================
                // Byte order
                // ============================================================
 
                void setByteOrder(ByteOrder order) { _byteOrder = order; }
 
                ByteOrder byteOrder() const { return _byteOrder; }
 
                // ============================================================
                // Version
                // ============================================================
 
                uint16_t version() const { return _version; }
 
                // ============================================================
                // Status and error handling
                // ============================================================
 
                Status status() const { return _status; }
 
                void resetStatus() { _status = Ok; }
 
                bool atEnd() const;
 
                IODevice *device() const { return _device; }
 
                // ============================================================
                // Write operators
                // ============================================================
 
                DataStream &operator<<(int8_t val);
                DataStream &operator<<(uint8_t val);
                DataStream &operator<<(int16_t val);
                DataStream &operator<<(uint16_t val);
                DataStream &operator<<(int32_t val);
                DataStream &operator<<(uint32_t val);
                DataStream &operator<<(int64_t val);
                DataStream &operator<<(uint64_t val);
                DataStream &operator<<(float val);
                DataStream &operator<<(double val);
                DataStream &operator<<(bool val);
                DataStream &operator<<(const String &val);
                DataStream &operator<<(const Buffer &val);
                DataStream &operator<<(const Variant &val);
 
                // ============================================================
                // Read operators
                // ============================================================
 
                DataStream &operator>>(int8_t &val);
                DataStream &operator>>(uint8_t &val);
                DataStream &operator>>(int16_t &val);
                DataStream &operator>>(uint16_t &val);
                DataStream &operator>>(int32_t &val);
                DataStream &operator>>(uint32_t &val);
                DataStream &operator>>(int64_t &val);
                DataStream &operator>>(uint64_t &val);
                DataStream &operator>>(float &val);
                DataStream &operator>>(double &val);
                DataStream &operator>>(bool &val);
                DataStream &operator>>(String &val);
                DataStream &operator>>(Buffer &val);
                DataStream &operator>>(Variant &val);
 
                // ============================================================
                // Raw byte access
                // ============================================================
 
                ssize_t readRawData(void *buf, size_t len);
 
                ssize_t writeRawData(const void *buf, size_t len);
 
                ssize_t skipRawData(size_t len);
 
        private:
                void writeHeader();
 
                void readHeader();
 
                void writeTag(TypeId id);
 
                bool readTag(TypeId expected);
 
                bool readBytes(void *buf, size_t len);
 
                bool writeBytes(const void *buf, size_t len);
 
                // Untagged value write helpers (used by Variant to avoid double-tagging)
                void writeInt8(int8_t val);
                void writeUInt8(uint8_t val);
                void writeInt16(int16_t val);
                void writeUInt16(uint16_t val);
                void writeInt32(int32_t val);
                void writeUInt32(uint32_t val);
                void writeInt64(int64_t val);
                void writeUInt64(uint64_t val);
                void writeFloat(float val);
                void writeDouble(double val);
                void writeBool(bool val);
                void writeStringData(const String &val);
 
                // Untagged value read helpers
                int8_t   readInt8();
                uint8_t  readUInt8();
                int16_t  readInt16();
                uint16_t readUInt16();
                int32_t  readInt32();
                uint32_t readUInt32();
                int64_t  readInt64();
                uint64_t readUInt64();
                float    readFloat();
                double   readDouble();
                bool     readBoolValue();
                String   readStringData();
 
                template <typename T>
                void swapIfNeeded(T &val) const {
                        if constexpr (sizeof(T) == 1) return;
                        if(_byteOrder == nativeByteOrder()) return;
                        uint8_t *p = reinterpret_cast<uint8_t *>(&val);
                        if constexpr (sizeof(T) == 2) {
                                std::swap(p[0], p[1]);
                        } else if constexpr (sizeof(T) == 4) {
                                std::swap(p[0], p[3]);
                                std::swap(p[1], p[2]);
                        } else if constexpr (sizeof(T) == 8) {
                                std::swap(p[0], p[7]);
                                std::swap(p[1], p[6]);
                                std::swap(p[2], p[5]);
                                std::swap(p[3], p[4]);
                        }
                }
 
                static ByteOrder nativeByteOrder() {
                        static const uint16_t val = 1;
                        return (*reinterpret_cast<const uint8_t *>(&val) == 1)
                                ? LittleEndian : BigEndian;
                }
 
                IODevice        *_device    = nullptr;
                ByteOrder       _byteOrder  = BigEndian;
                uint16_t        _version    = 0;
                Status          _status     = Ok;
};
 
PROMEKI_NAMESPACE_END