datastream.h

Go to the documentation of this file.

 
#pragma once
 
 
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <cstring>
#include <promeki/config.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/buffer.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/set.h>
#include <promeki/hashmap.h>
#include <promeki/hashset.h>
#include <promeki/rect.h>
#include <promeki/point.h>
#include <promeki/size2d.h>
#include <promeki/rational.h>
#include <promeki/result.h>
#include <promeki/iodevice.h>
 
PROMEKI_NAMESPACE_BEGIN
 
enum DataTypeID : uint16_t;
 
class Variant;
 
class DataStream {
        public:
                enum ByteOrder {
                        BigEndian,   
                        LittleEndian 
                };
 
                enum Status {
                        Ok,              
                        ReadPastEnd,     
                        ReadCorruptData, 
                        WriteFailed      
                };
 
                static constexpr uint16_t CurrentVersion = 3;
 
                static constexpr size_t HeaderSize = 16;
 
                static constexpr size_t FrameHeaderSize = 8;
 
                static constexpr uint32_t MaxFrameBodySize = 1u << 30; // 1 GiB
 
                static constexpr uint8_t Magic[4] = {0x50, 0x4D, 0x44, 0x53};
 
                static DataStream createWriter(IODevice *device, ByteOrder order = BigEndian);
 
                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; }
 
                const String &errorContext() const { return _errorContext; }
 
                Error toError() const;
 
                void resetStatus();
 
                bool atEnd() const;
 
                IODevice *device() const { return _device; }
 
                // ============================================================
                // Write operators — primitives
                // ============================================================
 
                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 — primitives
                // ============================================================
 
                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);
 
                // ============================================================
                // Result<T>-returning read API
                // ============================================================
 
                template <typename T> Result<T> read() {
                        T val{};
                        *this >> val;
                        if (_status != Ok) return makeError<T>(toError());
                        return makeResult(std::move(val));
                }
 
                // ============================================================
                // Extension API (for implementing custom operator<< / >>)
                // ============================================================
 
                void beginFrame(DataTypeID id, uint16_t version);
 
                void endFrame();
 
                bool readFrame(DataTypeID expected, uint16_t maxVersion = 1,
                               uint16_t *outVersion = nullptr, uint32_t *outSize = nullptr);
 
                bool readFrameHeader(DataTypeID &outTag, uint16_t &outVersion, uint32_t &outSize);
 
                bool peekFrameHeader(DataTypeID &outTag, uint16_t &outVersion, uint32_t &outSize);
 
                void skipFrame();
 
                void setError(Status s, String ctx);
 
                // ============================================================
                // Raw byte access (untagged escape hatch)
                // ============================================================
 
                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();
 
                bool readBytes(void *buf, size_t len);
 
                bool skipFrameBody(uint32_t sz);
 
                bool writeBytes(const void *buf, size_t len);
 
                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;
                }
 
                struct PendingFrame {
                        DataTypeID    tag;     
                        uint16_t      version; 
                        List<uint8_t> body;    
                };
 
                IODevice *           _device = nullptr;
                ByteOrder            _byteOrder = BigEndian;
                uint16_t             _version = 0;
                Status               _status = Ok;
                String               _errorContext;
                List<PendingFrame>   _frameStack;
 
                // One-deep frame-header lookahead.  Populated by
                // @ref peekFrameHeader and drained by the next
                // @ref readFrameHeader so that Variant dispatch can
                // inspect the tag without requiring a seekable device.
                bool                 _peekedHeaderValid = false;
                DataTypeID           _peekedTag;
                uint16_t             _peekedVersion     = 0;
                uint32_t             _peekedSize        = 0;
};
 
// ============================================================================
// Container template operators
// ============================================================================
//
// These let arbitrary List<T>, Map<K,V>, and Set<T> flow through a DataStream
// as long as T (and K, V) already have operator<< / operator>> overloads.
// They write a tag (DataTypeList / DataTypeMap / DataTypeSet) followed by a
// uint32_t count and then the fully-tagged elements.
 
namespace detail {
        inline constexpr uint32_t DataStreamMaxContainerCount = 256u * 1024u * 1024u;
} // namespace detail
 
PROMEKI_NAMESPACE_END
 
// The container / geometry operator templates below need DataTypeID
// values (DataTypeList, DataTypeSize2D, ...) by name, which means they
// need the full enum definition.  Pull in datatype.h here.
//
// enum.h is included AFTER datatype.h so the slicing operator<< / >>
// overloads for @ref TypedEnum subclasses can resolve the underlying
// Enum::promekiDataType inside their body.  Order matters: enum.h
// itself includes datatype.h, but datatype.h is already loaded by the
// time we get here, so the second inclusion is a no-op.
#include <promeki/datatype.h>
#include <promeki/enum.h>
// json.h is pulled in here — after DataStream is complete but before
// the @ref Detail::makeDefaultOps definition below — so the
// @c toJson / @c fromJson Ops slots can be populated from lambdas
// whose bodies reference @ref JsonObject directly.  json.h re-includes
// datastream.h but the pragma-once guard makes the inner include a
// no-op; by this point in this header DataStream is fully declared,
// which is everything json.h's bottom-half operators need.
#include <promeki/json.h>
 
PROMEKI_NAMESPACE_BEGIN
 
// ============================================================================
// Free-function DataStream operator allowlist (geometry templates only)
// ============================================================================
//
// Size2DTemplate<T> and Rational<T> ship with free-function operator<< /
// operator>> templates rather than a member API.  Flagging them here
// lets @ref Detail::makeDefaultOps populate the writeStream / readStream
// slots through the free-function path.  These specializations live in
// the header (rather than in variant.cpp) so they are visible at every
// makeDefaultOps instantiation site — including the call sites in
// datatype.cpp's registerBuiltinDataTypes.
 
namespace Detail {
 
template <typename T> struct HasFreeDataStreamWrite<Size2DTemplate<T>> : std::true_type {};
template <typename T> struct HasFreeDataStreamRead<Size2DTemplate<T>>  : std::true_type {};
template <typename T> struct HasFreeDataStreamWrite<Rational<T>>       : std::true_type {};
template <typename T> struct HasFreeDataStreamRead<Rational<T>>        : std::true_type {};
 
} // namespace Detail
 
// ============================================================================
// Geometry template operators
// ============================================================================
//
// These share a single tag per kind (DataTypeSize2D, DataTypeRect, DataTypePoint,
// DataTypeRational) and rely on the inner values being written/read via their
// own primitive operators, which means the inner values carry their own
// type tags. This lets one Size2DTemplate<T> template cover uint32_t,
// int32_t, float, etc. transparently.
 
template <typename T> DataStream &operator<<(DataStream &stream, const Size2DTemplate<T> &sz) {
        stream.beginFrame(DataTypeSize2D, 1);
        stream << sz.width() << sz.height();
        stream.endFrame();
        return stream;
}
 
template <typename T> DataStream &operator>>(DataStream &stream, Size2DTemplate<T> &sz) {
        if (!stream.readFrame(DataTypeSize2D)) {
                sz = Size2DTemplate<T>();
                return stream;
        }
        T w{}, h{};
        stream >> w >> h;
        if (stream.status() != DataStream::Ok) {
                sz = Size2DTemplate<T>();
                return stream;
        }
        sz = Size2DTemplate<T>(w, h);
        return stream;
}
 
template <typename T> DataStream &operator<<(DataStream &stream, const Rational<T> &r) {
        stream.beginFrame(DataTypeRational, 1);
        stream << r.numerator() << r.denominator();
        stream.endFrame();
        return stream;
}
 
template <typename T> DataStream &operator>>(DataStream &stream, Rational<T> &r) {
        if (!stream.readFrame(DataTypeRational)) {
                r = Rational<T>();
                return stream;
        }
        T num{}, den{1};
        stream >> num >> den;
        if (stream.status() != DataStream::Ok) {
                r = Rational<T>();
                return stream;
        }
        r = Rational<T>(num, den);
        return stream;
}
 
template <typename T> DataStream &operator<<(DataStream &stream, const Rect<T> &rect) {
        stream.beginFrame(DataTypeRect, 1);
        stream << rect.x() << rect.y() << rect.width() << rect.height();
        stream.endFrame();
        return stream;
}
 
template <typename T> DataStream &operator>>(DataStream &stream, Rect<T> &rect) {
        if (!stream.readFrame(DataTypeRect)) {
                rect = Rect<T>();
                return stream;
        }
        T x{}, y{}, w{}, h{};
        stream >> x >> y >> w >> h;
        if (stream.status() != DataStream::Ok) {
                rect = Rect<T>();
                return stream;
        }
        rect = Rect<T>(x, y, w, h);
        return stream;
}
 
template <typename T, size_t N> DataStream &operator<<(DataStream &stream, const Point<T, N> &point) {
        stream.beginFrame(DataTypePoint, 1);
        stream << static_cast<uint32_t>(N);
        const Array<T, N> &arr = point;
        for (size_t i = 0; i < N; ++i) stream << arr[i];
        stream.endFrame();
        return stream;
}
 
template <typename T, size_t N> DataStream &operator>>(DataStream &stream, Point<T, N> &point) {
        if (!stream.readFrame(DataTypePoint)) {
                point = Point<T, N>();
                return stream;
        }
        uint32_t dims = 0;
        stream >> dims;
        if (stream.status() != DataStream::Ok) {
                point = Point<T, N>();
                return stream;
        }
        if (dims != N) {
                stream.setError(DataStream::ReadCorruptData,
                                String::sprintf("Point dimension mismatch: expected %zu, got %u", N,
                                                static_cast<unsigned>(dims)));
                point = Point<T, N>();
                return stream;
        }
        Array<T, N> arr;
        for (size_t i = 0; i < N; ++i) {
                T val{};
                stream >> val;
                if (stream.status() != DataStream::Ok) {
                        point = Point<T, N>();
                        return stream;
                }
                arr[i] = val;
        }
        point = Point<T, N>(arr);
        return stream;
}
 
template <typename T> DataStream &operator<<(DataStream &stream, const List<T> &list) {
        stream.beginFrame(DataTypeList, 1);
        stream << static_cast<uint32_t>(list.size());
        for (const auto &item : list) stream << item;
        stream.endFrame();
        return stream;
}
 
template <typename T> DataStream &operator>>(DataStream &stream, List<T> &list) {
        list.clear();
        if (!stream.readFrame(DataTypeList)) return stream;
        uint32_t count = 0;
        stream >> count;
        if (stream.status() != DataStream::Ok) return stream;
        if (count > detail::DataStreamMaxContainerCount) {
                stream.setError(DataStream::ReadCorruptData, String("List element count exceeds sanity limit"));
                return stream;
        }
        list.reserve(count);
        for (uint32_t i = 0; i < count; ++i) {
                T item{};
                stream >> item;
                if (stream.status() != DataStream::Ok) return stream;
                list.pushToBack(std::move(item));
        }
        return stream;
}
 
template <typename K, typename V> DataStream &operator<<(DataStream &stream, const Map<K, V> &map) {
        stream.beginFrame(DataTypeMap, 1);
        stream << static_cast<uint32_t>(map.size());
        for (auto it = map.cbegin(); it != map.cend(); ++it) {
                stream << it->first << it->second;
        }
        stream.endFrame();
        return stream;
}
 
template <typename K, typename V> DataStream &operator>>(DataStream &stream, Map<K, V> &map) {
        map.clear();
        if (!stream.readFrame(DataTypeMap)) return stream;
        uint32_t count = 0;
        stream >> count;
        if (stream.status() != DataStream::Ok) return stream;
        if (count > detail::DataStreamMaxContainerCount) {
                stream.setError(DataStream::ReadCorruptData, String("Map entry count exceeds sanity limit"));
                return stream;
        }
        for (uint32_t i = 0; i < count; ++i) {
                K key{};
                V value{};
                stream >> key >> value;
                if (stream.status() != DataStream::Ok) return stream;
                map.insert(std::move(key), std::move(value));
        }
        return stream;
}
 
template <typename T> DataStream &operator<<(DataStream &stream, const Set<T> &set) {
        stream.beginFrame(DataTypeSet, 1);
        stream << static_cast<uint32_t>(set.size());
        for (const auto &item : set) stream << item;
        stream.endFrame();
        return stream;
}
 
template <typename T> DataStream &operator>>(DataStream &stream, Set<T> &set) {
        set.clear();
        if (!stream.readFrame(DataTypeSet)) return stream;
        uint32_t count = 0;
        stream >> count;
        if (stream.status() != DataStream::Ok) return stream;
        if (count > detail::DataStreamMaxContainerCount) {
                stream.setError(DataStream::ReadCorruptData, String("Set element count exceeds sanity limit"));
                return stream;
        }
        for (uint32_t i = 0; i < count; ++i) {
                T item{};
                stream >> item;
                if (stream.status() != DataStream::Ok) return stream;
                set.insert(std::move(item));
        }
        return stream;
}
 
template <typename K, typename V> DataStream &operator<<(DataStream &stream, const HashMap<K, V> &map) {
        stream.beginFrame(DataTypeHashMap, 1);
        stream << static_cast<uint32_t>(map.size());
        for (auto it = map.cbegin(); it != map.cend(); ++it) {
                stream << it->first << it->second;
        }
        stream.endFrame();
        return stream;
}
 
template <typename K, typename V> DataStream &operator>>(DataStream &stream, HashMap<K, V> &map) {
        map.clear();
        if (!stream.readFrame(DataTypeHashMap)) return stream;
        uint32_t count = 0;
        stream >> count;
        if (stream.status() != DataStream::Ok) return stream;
        if (count > detail::DataStreamMaxContainerCount) {
                stream.setError(DataStream::ReadCorruptData, String("HashMap entry count exceeds sanity limit"));
                return stream;
        }
        for (uint32_t i = 0; i < count; ++i) {
                K key{};
                V value{};
                stream >> key >> value;
                if (stream.status() != DataStream::Ok) return stream;
                map.insert(std::move(key), std::move(value));
        }
        return stream;
}
 
template <typename T> DataStream &operator<<(DataStream &stream, const HashSet<T> &set) {
        stream.beginFrame(DataTypeHashSet, 1);
        stream << static_cast<uint32_t>(set.size());
        for (const auto &item : set) stream << item;
        stream.endFrame();
        return stream;
}
 
template <typename T> DataStream &operator>>(DataStream &stream, HashSet<T> &set) {
        set.clear();
        if (!stream.readFrame(DataTypeHashSet)) return stream;
        uint32_t count = 0;
        stream >> count;
        if (stream.status() != DataStream::Ok) return stream;
        if (count > detail::DataStreamMaxContainerCount) {
                stream.setError(DataStream::ReadCorruptData, String("HashSet element count exceeds sanity limit"));
                return stream;
        }
        for (uint32_t i = 0; i < count; ++i) {
                T item{};
                stream >> item;
                if (stream.status() != DataStream::Ok) return stream;
                set.insert(std::move(item));
        }
        return stream;
}
 
// ============================================================================
// DataStream <<, >> for JsonObject / JsonArray
//
// These live here (rather than in @c json.h) so @c json.h can stay
// free of a @c datastream.h dependency — which is what lets the
// @ref Detail::makeDefaultOps populator below reference @ref JsonObject
// directly without forming a circular include.
//
// Wire form (v1): compact JSON text as a tagged, length-prefixed
// String body.  Readers that see a truncated or malformed payload
// flag the stream @c ReadCorruptData.
// ============================================================================
 
inline DataStream &operator<<(DataStream &stream, const JsonObject &obj) {
        stream.beginFrame(DataTypeJsonObject, 1);
        stream << obj.toString(0);
        stream.endFrame();
        return stream;
}
 
inline DataStream &operator>>(DataStream &stream, JsonObject &obj) {
        if (!stream.readFrame(DataTypeJsonObject)) {
                obj = JsonObject();
                return stream;
        }
        String text;
        stream >> text;
        if (stream.status() != DataStream::Ok) {
                obj = JsonObject();
                return stream;
        }
        Error err;
        obj = JsonObject::parse(text, &err);
        if (err.isError()) {
                stream.setError(DataStream::ReadCorruptData, String("JsonObject::parse failed"));
        }
        return stream;
}
 
inline DataStream &operator<<(DataStream &stream, const JsonArray &arr) {
        stream.beginFrame(DataTypeJsonArray, 1);
        stream << arr.toString(0);
        stream.endFrame();
        return stream;
}
 
inline DataStream &operator>>(DataStream &stream, JsonArray &arr) {
        if (!stream.readFrame(DataTypeJsonArray)) {
                arr = JsonArray();
                return stream;
        }
        String text;
        stream >> text;
        if (stream.status() != DataStream::Ok) {
                arr = JsonArray();
                return stream;
        }
        Error err;
        arr = JsonArray::parse(text, &err);
        if (err.isError()) {
                stream.setError(DataStream::ReadCorruptData, String("JsonArray::parse failed"));
        }
        return stream;
}
 
namespace Detail {
template <> struct HasFreeDataStreamWrite<JsonObject> : std::true_type {};
template <> struct HasFreeDataStreamRead<JsonObject>  : std::true_type {};
template <> struct HasFreeDataStreamWrite<JsonArray>  : std::true_type {};
template <> struct HasFreeDataStreamRead<JsonArray>   : std::true_type {};
} // namespace Detail
 
// ============================================================================
// Concept detection + ops-table population that requires DataStream
// to be complete.
//
// These live here (rather than in @c datatype.h) because @c datatype.h
// is included by many types that themselves get pulled in transitively
// from this file (Buffer, MemSpace, StringList, ...).  Cycling through
// @c datatype.h → @c datastream.h would re-enter mid-flight and break
// dependent types' declarations.
// ============================================================================
 
namespace Detail {
 
template <typename T>
concept HasMemberWriteToStream = requires(const T &t, DataStream &s) {
        { t.writeToStream(s) } -> std::convertible_to<Error>;
};
 
template <typename T>
concept HasMemberReadFromStream = requires(DataStream &s) {
        { T::template readFromStream<1>(s) } -> std::convertible_to<Result<T>>;
};
 
template <typename T>
struct ExactDataStreamWrite<T, std::void_t<decltype(static_cast<DataStream &(DataStream::*)(const T &)>(
                                          &DataStream::operator<<))>> : std::true_type {};
 
template <typename T>
struct ExactDataStreamWrite<T, std::void_t<decltype(static_cast<DataStream &(DataStream::*)(T)>(
                                          &DataStream::operator<<))>> : std::true_type {};
 
template <typename T>
struct ExactDataStreamRead<T, std::void_t<decltype(static_cast<DataStream &(DataStream::*)(T &)>(
                                          &DataStream::operator>>))>> : std::true_type {};
 
template <typename T>
DataType::Ops makeDefaultOps() {
        DataType::Ops ops;
        if constexpr (std::is_default_constructible_v<T>) {
                ops.defaultConstruct = [](void *p) {
                        ::new (p) T();
                        return;
                };
        }
        ops.copyConstruct = [](void *dst, const void *src) {
                ::new (dst) T(*static_cast<const T *>(src));
                return;
        };
        ops.moveConstruct = [](void *dst, void *src) {
                ::new (dst) T(std::move(*static_cast<T *>(src)));
                return;
        };
        ops.destroy = [](void *p) {
                static_cast<T *>(p)->~T();
                return;
        };
        if constexpr (HasEqualityOp<T>) {
                ops.equal = [](const void *a, const void *b) -> bool {
                        return *static_cast<const T *>(a) == *static_cast<const T *>(b);
                };
        }
        if constexpr (HasMemberToString<T>) {
                ops.toString = [](const void *p, Error *err) -> String {
                        if (err != nullptr) *err = Error::Ok;
                        return static_cast<const T *>(p)->toString();
                };
        }
        if constexpr (HasResultFromString<T>) {
                ops.fromString = [](const String &s, void *out, Error *err) -> bool {
                        auto r = T::fromString(s);
                        if (r.second().isError()) {
                                if (err != nullptr) *err = r.second();
                                return false;
                        }
                        *static_cast<T *>(out) = r.first();
                        if (err != nullptr) *err = Error::Ok;
                        return true;
                };
        }
        if constexpr (HasMemberValueInt<T>) {
                // FrameNumber / FrameCount / Enum — value() returns an
                // integral so the Variant <-> integer path can fall
                // straight through without a type-specific branch.
                ops.toInt = [](const void *p, Error *err) -> int64_t {
                        if (err != nullptr) *err = Error::Ok;
                        return static_cast<int64_t>(static_cast<const T *>(p)->value());
                };
        } else if constexpr (HasMemberIdInt<T>) {
                // TypeRegistry wrappers (ColorModel, MemSpace,
                // PixelFormat, ...) — id() is the canonical integer
                // form of the wrapper.
                ops.toInt = [](const void *p, Error *err) -> int64_t {
                        if (err != nullptr) *err = Error::Ok;
                        return static_cast<int64_t>(static_cast<const T *>(p)->id());
                };
        }
        if constexpr (HasIdCtor<T>) {
                ops.fromInt = [](int64_t v, void *out, Error *err) -> bool {
                        if (err != nullptr) *err = Error::Ok;
                        *static_cast<T *>(out) = T(static_cast<typename T::ID>(v));
                        return true;
                };
        } else if constexpr (HasInt64Ctor<T>) {
                ops.fromInt = [](int64_t v, void *out, Error *err) -> bool {
                        if (err != nullptr) *err = Error::Ok;
                        *static_cast<T *>(out) = T(v);
                        return true;
                };
        }
        if constexpr (HasMemberToDouble<T>) {
                ops.toFloat = [](const void *p, Error *err) -> double {
                        if (err != nullptr) *err = Error::Ok;
                        return static_cast<const T *>(p)->toDouble();
                };
        }
        if constexpr (HasResultFromDouble<T>) {
                ops.fromFloat = [](double v, void *out, Error *err) -> bool {
                        auto r = T::fromDouble(v);
                        if (r.second().isError()) {
                                if (err != nullptr) *err = r.second();
                                return false;
                        }
                        *static_cast<T *>(out) = r.first();
                        if (err != nullptr) *err = Error::Ok;
                        return true;
                };
        }
        if constexpr (HasMemberToJson<T>) {
                ops.toJson = +[](const void *p, Error *err) -> JsonObject {
                        if (err != nullptr) *err = Error::Ok;
                        return static_cast<const T *>(p)->toJson();
                };
        }
        if constexpr (HasResultFromJson<T>) {
                ops.fromJson = +[](const JsonObject &j, void *out, Error *err) -> bool {
                        auto r = T::fromJson(j);
                        if (r.second().isError()) {
                                if (err != nullptr) *err = r.second();
                                return false;
                        }
                        *static_cast<T *>(out) = r.first();
                        if (err != nullptr) *err = Error::Ok;
                        return true;
                };
        }
        if constexpr (HasMemberWriteToStream<T> && HasPromekiDataType<T>) {
                // PROMEKI_DATATYPE member-API path: wrap writeToStream
                // in a frame using the macro's pinned id + version.
                ops.writeStream = [](DataStream &s, const void *p) {
                        const T &val = *static_cast<const T *>(p);
                        s.beginFrame(T::promekiDataType::id, T::promekiDataType::version);
                        Error err = val.writeToStream(s);
                        s.endFrame();
                        if (err.isError()) {
                                if (s.status() == DataStream::Ok) {
                                        s.setError(DataStream::WriteFailed,
                                                   String("writeToStream returned ") + err.name());
                                }
                        }
                        return;
                };
        } else if constexpr (HasDataStreamWriteV<T>) {
                // Free-function / member-on-DataStream operator<<: the
                // operator already handles its own framing.
                ops.writeStream = [](DataStream &s, const void *p) {
                        s << *static_cast<const T *>(p);
                        return;
                };
        }
        if constexpr (HasMemberReadFromStream<T> && HasPromekiDataType<T>) {
                // PROMEKI_DATATYPE member-API read path: validate frame
                // header, then dispatch to the matching readFromStream<V>
                // via the macro-generated dispatch table.
                ops.readStream = [](DataStream &s, void *p) {
                        uint16_t ver = 0;
                        if (!s.readFrame(T::promekiDataType::id, T::promekiDataType::version, &ver,
                                         nullptr)) {
                                *static_cast<T *>(p) = T();
                                return;
                        }
                        Result<T> r = T::promekiDataType::dispatchRead(s, ver);
                        if (r.second().isError()) {
                                if (s.status() == DataStream::Ok) {
                                        s.setError(DataStream::ReadCorruptData,
                                                   String("readFromStream returned ") + r.second().name());
                                }
                                *static_cast<T *>(p) = T();
                                return;
                        }
                        *static_cast<T *>(p) = std::move(r.first());
                        return;
                };
        } else if constexpr (HasDataStreamReadV<T>) {
                ops.readStream = [](DataStream &s, void *p) {
                        s >> *static_cast<T *>(p);
                        return;
                };
        }
        return ops;
}
 
} // namespace Detail
 
// Forward-declare Enum so the constraint below can refer to it without
// forcing <promeki/enum.h> to load up here.  TypedEnum subclasses get
// their own overload (further down) which slices through their Enum
// base; the macro-driven generic template must NOT match those or
// overload resolution between the two becomes ambiguous.
class Enum;
 
namespace Detail {
 
template <typename T>
concept IsTypedEnumSubclass = std::is_base_of_v<Enum, T> && !std::is_same_v<T, Enum>;
 
} // namespace Detail
 
template <typename T>
        requires Detail::HasPromekiDataType<T> && Detail::HasMemberWriteToStream<T> &&
                 (!Detail::IsTypedEnumSubclass<T>)
inline DataStream &operator<<(DataStream &stream, const T &val) {
        stream.beginFrame(T::promekiDataType::id, T::promekiDataType::version);
        Error err = val.writeToStream(stream);
        stream.endFrame();
        if (err.isError() && stream.status() == DataStream::Ok) {
                stream.setError(DataStream::WriteFailed,
                                String("writeToStream returned ") + err.name());
        }
        return stream;
}
 
template <typename T>
        requires Detail::HasPromekiDataType<T> && Detail::HasMemberReadFromStream<T> &&
                 (!Detail::IsTypedEnumSubclass<T>)
inline DataStream &operator>>(DataStream &stream, T &val) {
        uint16_t ver = 0;
        if (!stream.readFrame(T::promekiDataType::id, T::promekiDataType::version, &ver, nullptr)) {
                val = T();
                return stream;
        }
        Result<T> r = T::promekiDataType::dispatchRead(stream, ver);
        if (r.second().isError()) {
                if (stream.status() == DataStream::Ok) {
                        stream.setError(DataStream::ReadCorruptData,
                                        String("readFromStream returned ") + r.second().name());
                }
                val = T();
                return stream;
        }
        val = std::move(r.first());
        return stream;
}
 
// ============================================================================
// Slicing overloads for TypedEnum<Self> subclasses
//
// TypedEnum<X> derives publicly from Enum.  When user code does
// `stream >> someTypedEnumValue`, the generic operator>> above is
// disqualified by the IsTypedEnumSubclass clause; these forward
// through the Enum base, exactly mirroring the slicing read the
// hand-rolled @c operator>>(Enum&) provided in the legacy design.
// ============================================================================
 
template <typename T>
        requires Detail::IsTypedEnumSubclass<T>
inline DataStream &operator<<(DataStream &stream, const T &val) {
        const Enum &base = val;
        return stream << base;
}
 
template <typename T>
        requires Detail::IsTypedEnumSubclass<T>
inline DataStream &operator>>(DataStream &stream, T &val) {
        Enum &base = val;
        return stream >> base;
}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE