CBOR.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/Generator.hpp"
#include "CeresEngine/Foundation/Iterator.hpp"
#include "CeresEngine/Foundation/Container/MemoryView.hpp"
#include "CeresEngine/Foundation/Container/Pair.hpp"
#include "CeresEngine/Foundation/Container/Variant.hpp"
#include "CeresEngine/Foundation/IO/Stream.Buffered.hpp"
#include "CeresEngine/Foundation/IO/Stream.Limited.hpp"
#include "CeresEngine/Foundation/IO/Stream.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
#include <cstddef>
#include <utility>
 
namespace CeresEngine {
 
    class CBOR {
    public:
        class Encoder;
        class Decoder;
 
    public:
        struct Array {
            UInt64 size = ~0u;
 
            [[nodiscard]] bool isIndeterminate() const noexcept { return size == ~0u; }
        };
 
        struct Map {
            UInt64 size = ~0u;
 
            [[nodiscard]] bool isIndeterminate() const noexcept { return size == ~0u; }
        };
 
        struct Tag {
            UInt64 id;
        };
 
        struct Binary {
            mutable InputStream stream;
 
            explicit Binary(InputStream stream) : stream(std::move(stream)) {}
 
            explicit Binary(const MemoryView<const Byte>& data) : stream(MemoryDataStream((Byte*)data.data(), data.size())) {}
 
            explicit Binary(InputStream stream, const UInt64 limit) : stream(LimitedInputStream(std::move(stream), limit)) {}
        };
 
        struct Undefined {};
 
        struct Break {};
 
        struct Unknown {
            UInt64 minor;
        };
 
        enum class ValueType : UInt8 {
            UInt64,
 
            Int64,
 
            Float,
 
            Double,
 
            Boolean,
 
            String,
 
            Binary,
 
            Null,
 
            Undefined,
 
            Array,
 
            Map,
 
            Tag,
 
            Break,
 
            Unknown,
        };
 
        class Value : public Variant<UInt64, Int64, float, double, bool, String, Binary, std::nullptr_t, Undefined, Array, Map, Tag, Break, Unknown> {
            using super = Variant<UInt64, Int64, float, double, bool, String, Binary, std::nullptr_t, Undefined, Array, Map, Tag, Break, Unknown>;
 
        public:
            using super::super;
            Value() : super(Unknown{}) {}
 
        public:
            [[nodiscard]] ValueType getType() const noexcept;
 
            [[nodiscard]] String toString() const;
 
        public: // Type Checking
            [[nodiscard]] bool isUInt64() const noexcept { return is<UInt64>(); }
 
            [[nodiscard]] bool isInt64() const noexcept { return is<Int64>(); }
 
            [[nodiscard]] bool isFloat() const noexcept { return is<float>(); }
 
            [[nodiscard]] bool isDouble() const noexcept { return is<double>(); }
 
            [[nodiscard]] bool isBoolean() const noexcept { return is<bool>(); }
 
            [[nodiscard]] bool isString() const noexcept { return is<String>(); }
 
            [[nodiscard]] bool isBinary() const noexcept { return is<Binary>(); }
 
            [[nodiscard]] bool isNull() const noexcept { return is<std::nullptr_t>(); }
 
            [[nodiscard]] bool isUndefined() const noexcept { return is<Undefined>(); }
 
            [[nodiscard]] bool isArray() const noexcept { return is<Array>(); }
 
            [[nodiscard]] bool isMap() const noexcept { return is<Map>(); }
 
            [[nodiscard]] bool isTag() const noexcept { return is<Tag>(); }
 
            [[nodiscard]] bool isBreak() const noexcept { return is<Break>(); }
 
            [[nodiscard]] bool isUnknown() const noexcept { return is<Unknown>(); }
 
        public: // Get type
            [[nodiscard]] UInt64 asUInt64() const noexcept {
                CE_ASSERT(is<UInt64>());
                return as<UInt64>();
            }
 
            [[nodiscard]] Int64 asInt64() const noexcept {
                CE_ASSERT(is<Int64>());
                return as<Int64>();
            }
 
            [[nodiscard]] float asFloat() const noexcept {
                CE_ASSERT(is<float>());
                return as<float>();
            }
 
            [[nodiscard]] double asDouble() const noexcept {
                CE_ASSERT(is<double>());
                return as<double>();
            }
 
            [[nodiscard]] bool asBoolean() const noexcept {
                CE_ASSERT(is<bool>());
                return as<bool>();
            }
 
            [[nodiscard]] const String& asString() const noexcept {
                CE_ASSERT(is<String>());
                return as<String>();
            }
 
            [[nodiscard]] const Binary& asBinary() const& noexcept {
                CE_ASSERT(is<Binary>());
                return as<Binary>();
            }
 
            [[nodiscard]] Binary&& asBinary() && noexcept {
                CE_ASSERT(is<Binary>());
                return std::move(as<Binary>());
            }
 
            [[nodiscard]] StringView asStringView() const noexcept { return asString(); }
 
            [[nodiscard]] const Array& asArray() const noexcept {
                CE_ASSERT(is<Array>());
                return as<Array>();
            }
 
            [[nodiscard]] const Map& asMap() const noexcept {
                CE_ASSERT(is<Map>());
                return as<Map>();
            }
 
            [[nodiscard]] const Tag& asTag() const noexcept {
                CE_ASSERT(is<Tag>());
                return as<Tag>();
            }
 
            [[nodiscard]] const Unknown& asUnknown() const noexcept {
                CE_ASSERT(is<Unknown>());
                return as<Unknown>();
            }
 
            template<typename T> requires std::is_enum_v<T>
            [[nodiscard]] T asEnum() const {
                if(isUInt64()) {
                    return T(asUInt64());
                }
 
                if(isInt64()) {
                    return T(asInt64());
                }
 
                CE_ASSERT_UNDEFINED();
            }
        };
 
    public: // Reader & Writer
        class Decoder final {
        private:
            BufferedInputStream mStream;
 
        public:
            explicit Decoder(InputStream inputStream) : mStream(std::move(inputStream), 4096) {}
 
            explicit Decoder(IInputStream& inputStream) : mStream(&inputStream, 4096) {}
 
        public:
            [[nodiscard]] Value read();
 
            template<typename Callback> void map(const Value& value, Callback&& callback) {
                const Map& map = value.as<Map>();
                if(map.isIndeterminate()) {
                    for(const UInt64 index : range(map.size)) {
                        Value elementKey = read();
                        if(elementKey.isBreak()) {
                            break;
                        }
                        Value elementValue = read();
 
                        callback(*this, value.as<Map>(), index, std::move(elementKey), std::move(elementValue));
                    }
                } else {
                    for(const UInt64 index : range(map.size)) {
                        callback(*this, value.as<Map>(), index, read(), read());
                    }
                }
            }
 
            [[nodiscard]] Generator<Pair<Value, Value>> map(const Map& value);
 
            template<typename Callback> void array(const Value& value, Callback&& callback) {
                const Array& array = value.as<Array>();
                if(array.isIndeterminate()) {
                    for(const UInt64 index : range(std::numeric_limits<UInt64>::max())) {
                        Value element = read();
                        if(element.isBreak()) {
                            break;
                        }
 
                        callback(*this, array, index, std::move(element));
                    }
                } else {
                    for(const UInt64 index : range(array.size)) {
                        callback(*this, array, index, read());
                    }
                }
            }
 
            [[nodiscard]] Generator<Value> array(const Array& value);
 
            template<typename Callback> void tag(const Value& value, Callback&& callback) {
                CE_ASSERT(value.is<Tag>());
                callback(*this, value.as<Tag>(), read());
            }
        };
 
        class Encoder final {
        private:
            BufferedOutputStream mStream;
 
        public:
            explicit Encoder(OutputStream outputStream) : mStream(std::move(outputStream), 4096) {}
 
            explicit Encoder(IOutputStream& outputStream) : mStream(&outputStream, 4096) {}
 
        public:
            void write(UInt64 value);
 
            void write(Int64 value);
 
            void write(float value);
 
            void write(double value);
 
            void write(bool value);
 
            void write(StringView value);
 
            void write(const String& value) { return write(StringView(value)); }
 
            void write(const char* value) { return write(StringView(value)); }
 
            void write(Binary value);
 
            void write(std::nullptr_t value);
 
            void write(Undefined value);
 
            void write(Break value);
 
            void break_() { write(Break()); }
 
            void write(Array value);
 
            void array(const UInt64 size) { write(Array{.size = size}); }
 
            template<typename Func> void array(const UInt64 size, Func&& func) {
                array(size);
                func(*this);
            }
 
            void array() { write(Array{.size = ~0u}); }
 
            template<typename Func> void array(Func&& func) {
                array();
                func(*this);
                break_();
            }
 
            void write(Map value);
 
            void map(const UInt64 size) { write(Map{.size = size}); }
 
            template<typename Func> void map(const UInt64 size, Func&& func) {
                map(size);
                func(*this);
            }
 
            void map() { write(Map{.size = ~0u}); }
 
            template<typename Func> void map(Func&& func) {
                map();
                func(*this);
                break_();
            }
 
            void write(Tag value);
 
            void tag(const UInt64 id) { write(Tag{.id = id}); }
 
            template<typename Func> void tag(const UInt64 id, Func&& func) {
                tag(id);
                func(*this);
            }
 
            void binary(const void* data, size_t length);
 
            void binary(const MemoryView<const Byte>& data) { return binary(data.data(), data.size()); }
 
            void binary(const FunctionView<void(OutputStream&) const>& func);
 
            void binary(UInt64 length, const FunctionView<void(OutputStream&) const>& func);
 
            void write(Value&& value);
 
            [[nodiscard]] bool flush() { return mStream.flush(); }
 
        public:
            template<typename T> requires std::is_enum_v<T>
            void write(T value) {
                using UnderlyingType = std::underlying_type_t<T>;
                constexpr bool isSigned = std::is_signed_v<UnderlyingType>;
                return isSigned ? write((Int64)value) : write((UInt64)value);
            }
        };
    };
 
} // namespace CeresEngine