CompactBinary.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringFwd.h"
#include "Containers/StringView.h"
#include "CoreTypes.h"
#include "HAL/UnrealMemory.h"
#include "IO/IoHash.h"
#include "Memory/CompositeBuffer.h"
#include "Memory/MemoryFwd.h"
#include "Memory/MemoryView.h"
#include "Memory/SharedBuffer.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "String/BytesToHex.h"
#include "Templates/Function.h"
#include "Templates/RemoveReference.h"
#include "Templates/UnrealTemplate.h"
#include <type_traits>
 
template <typename CharType> class TStringBuilderBase;
 
class FArchive;
class FCbArrayView;
class FCbField;
class FCbFieldIterator;
class FCbFieldView;
class FCbFieldViewIterator;
class FCbObjectId;
class FCbObjectView;
class FCbValue;
class FIoHashBuilder;
struct FDateTime;
struct FGuid;
struct FTimespan;
template <typename FuncType> class TFunctionRef;
 
using FCbBufferAllocator = TFunctionRef<FUniqueBuffer (uint64 Size)>;
 
 
enum class ECbFieldType : uint8
{
    None                             = 0x00,
 
    Null                             = 0x01,
 
    Object                           = 0x02,
    UniformObject                    = 0x03,
 
    Array                            = 0x04,
    UniformArray                     = 0x05,
 
    Binary                           = 0x06,
 
    String                           = 0x07,
 
    IntegerPositive                  = 0x08,
    IntegerNegative                  = 0x09,
 
    Float32                          = 0x0a,
    Float64                          = 0x0b,
 
    BoolFalse                        = 0x0c,
    BoolTrue                         = 0x0d,
 
    ObjectAttachment                 = 0x0e,
    BinaryAttachment                 = 0x0f,
 
    Hash                             = 0x10,
    Uuid                             = 0x11,
 
    DateTime                         = 0x12,
    TimeSpan                         = 0x13,
 
    ObjectId                         = 0x14,
 
    CustomById                       = 0x1e,
    CustomByName                     = 0x1f,
 
    Reserved                         = 0x20,
 
    HasFieldType                     = 0x40,
 
    HasFieldName                     = 0x80,
};
 
ENUM_CLASS_FLAGS(ECbFieldType);
 
 
class FCbFieldType
{
    static constexpr ECbFieldType SerializedTypeMask    = ECbFieldType(0b1001'1111);
    static constexpr ECbFieldType TypeMask              = ECbFieldType(0b0001'1111);
 
    static constexpr ECbFieldType ObjectMask            = ECbFieldType(0b0001'1110);
    static constexpr ECbFieldType ObjectBase            = ECbFieldType(0b0000'0010);
 
    static constexpr ECbFieldType ArrayMask             = ECbFieldType(0b0001'1110);
    static constexpr ECbFieldType ArrayBase             = ECbFieldType(0b0000'0100);
 
    static constexpr ECbFieldType IntegerMask           = ECbFieldType(0b0001'1110);
    static constexpr ECbFieldType IntegerBase           = ECbFieldType(0b0000'1000);
 
    static constexpr ECbFieldType FloatMask             = ECbFieldType(0b0001'1100);
    static constexpr ECbFieldType FloatBase             = ECbFieldType(0b0000'1000);
 
    static constexpr ECbFieldType BoolMask              = ECbFieldType(0b0001'1110);
    static constexpr ECbFieldType BoolBase              = ECbFieldType(0b0000'1100);
 
    static constexpr ECbFieldType AttachmentMask        = ECbFieldType(0b0001'1110);
    static constexpr ECbFieldType AttachmentBase        = ECbFieldType(0b0000'1110);
 
    static void StaticAssertTypeConstants();
 
public:
    static constexpr inline ECbFieldType GetType(ECbFieldType Type)             { return Type & TypeMask; }
    static constexpr inline ECbFieldType GetSerializedType(ECbFieldType Type)   { return Type & SerializedTypeMask; }
 
    static constexpr inline bool HasFieldType(ECbFieldType Type) { return EnumHasAnyFlags(Type, ECbFieldType::HasFieldType); }
    static constexpr inline bool HasFieldName(ECbFieldType Type) { return EnumHasAnyFlags(Type, ECbFieldType::HasFieldName); }
 
    static constexpr inline bool IsNone(ECbFieldType Type)       { return GetType(Type) == ECbFieldType::None; }
    static constexpr inline bool IsNull(ECbFieldType Type)       { return GetType(Type) == ECbFieldType::Null; }
 
    static constexpr inline bool IsObject(ECbFieldType Type)     { return (Type & ObjectMask) == ObjectBase; }
    static constexpr inline bool IsArray(ECbFieldType Type)      { return (Type & ArrayMask) == ArrayBase; }
 
    static constexpr inline bool IsBinary(ECbFieldType Type)     { return GetType(Type) == ECbFieldType::Binary; }
    static constexpr inline bool IsString(ECbFieldType Type)     { return GetType(Type) == ECbFieldType::String; }
 
    static constexpr inline bool IsInteger(ECbFieldType Type)    { return (Type & IntegerMask) == IntegerBase; }
    static constexpr inline bool IsFloat(ECbFieldType Type)      { return (Type & FloatMask) == FloatBase; }
    static constexpr inline bool IsBool(ECbFieldType Type)       { return (Type & BoolMask) == BoolBase; }
 
    static constexpr inline bool IsObjectAttachment(ECbFieldType Type) { return GetType(Type) == ECbFieldType::ObjectAttachment; }
    static constexpr inline bool IsBinaryAttachment(ECbFieldType Type) { return GetType(Type) == ECbFieldType::BinaryAttachment; }
    static constexpr inline bool IsAttachment(ECbFieldType Type)       { return (Type & AttachmentMask) == AttachmentBase; }
 
    static constexpr inline bool IsHash(ECbFieldType Type)       { return GetType(Type) == ECbFieldType::Hash || IsAttachment(Type); }
    static constexpr inline bool IsUuid(ECbFieldType Type)       { return GetType(Type) == ECbFieldType::Uuid; }
 
    static constexpr inline bool IsDateTime(ECbFieldType Type)   { return GetType(Type) == ECbFieldType::DateTime; }
    static constexpr inline bool IsTimeSpan(ECbFieldType Type)   { return GetType(Type) == ECbFieldType::TimeSpan; }
 
    static constexpr inline bool IsObjectId(ECbFieldType Type)   { return GetType(Type) == ECbFieldType::ObjectId; }
 
    static constexpr inline bool IsCustomById(ECbFieldType Type)   { return GetType(Type) == ECbFieldType::CustomById; }
    static constexpr inline bool IsCustomByName(ECbFieldType Type) { return GetType(Type) == ECbFieldType::CustomByName; }
 
    static constexpr inline bool HasFields(ECbFieldType Type)
    {
        return GetType(Type) >= ECbFieldType::Object && GetType(Type) <= ECbFieldType::UniformArray;
    }
 
    static constexpr inline bool HasUniformFields(ECbFieldType Type)
    {
        return GetType(Type) == ECbFieldType::UniformObject || GetType(Type) == ECbFieldType::UniformArray;
    }
 
    static constexpr inline bool MayContainAttachments(ECbFieldType Type)
    {
        // The use of !! will suppress V792 from static analysis. Using //-V792 did not work.
        return !!IsObject(Type) | !!IsArray(Type) | !!IsAttachment(Type);
    }
};
 
 
using FCbFieldVisitor = TFunctionRef<void (FCbFieldView)>;
 
 
class FCbIteratorSentinel
{
};
 
template <typename FieldType>
class TCbFieldIterator : public FieldType
{
public:
    constexpr TCbFieldIterator() = default;
 
    CORE_API TCbFieldIterator& operator++();
 
    inline TCbFieldIterator operator++(int)
    {
        TCbFieldIterator It(*this);
        ++*this;
        return It;
    }
 
    constexpr inline FieldType& operator*() { return *this; }
    constexpr inline FieldType* operator->() { return this; }
 
    inline void Reset() { *this = TCbFieldIterator(); }
 
    CORE_API uint64 GetRangeSize() const;
 
    CORE_API FIoHash GetRangeHash() const;
    CORE_API void AppendRangeHash(FIoHashBuilder& Builder) const;
 
    using FieldType::Equals;
 
    template <typename OtherFieldType>
    constexpr inline bool Equals(const TCbFieldIterator<OtherFieldType>& Other) const
    {
        return FieldType::GetValueData() == Other.OtherFieldType::GetValueData() && FieldsEnd == Other.FieldsEnd;
    }
 
    template <typename OtherFieldType>
    constexpr inline bool operator==(const TCbFieldIterator<OtherFieldType>& Other) const
    {
        return Equals(Other);
    }
 
    template <typename OtherFieldType>
    constexpr inline bool operator!=(const TCbFieldIterator<OtherFieldType>& Other) const
    {
        return !Equals(Other);
    }
 
    constexpr inline bool operator==(const FCbIteratorSentinel&) const { return !FieldType::HasValue(); }
    constexpr inline bool operator!=(const FCbIteratorSentinel&) const { return FieldType::HasValue(); }
 
    CORE_API void CopyRangeTo(FMutableMemoryView Buffer) const;
 
    CORE_API void CopyRangeTo(FArchive& Ar) const;
 
    CORE_API void IterateRangeAttachments(FCbFieldVisitor Visitor) const;
 
    inline bool TryGetRangeView(FMemoryView& OutView) const
    {
        FMemoryView View;
        if (FieldType::TryGetView(View))
        {
            OutView = MakeMemoryView(View.GetData(), FieldsEnd);
            return true;
        }
        return false;
    }
 
    constexpr inline TCbFieldIterator begin() const { return *this; }
    constexpr inline FCbIteratorSentinel end() const { return FCbIteratorSentinel(); }
 
protected:
    constexpr inline explicit TCbFieldIterator(FieldType InField)
        : FieldType(MoveTemp(InField))
        , FieldsEnd(FieldType::GetValueEnd())
    {
    }
 
    constexpr inline TCbFieldIterator(FieldType&& InField, const void* InFieldsEnd)
        : FieldType(MoveTemp(InField))
        , FieldsEnd(InFieldsEnd)
    {
    }
 
    template <typename OtherFieldType>
    static inline const void* GetFieldsEnd(const TCbFieldIterator<OtherFieldType>& It)
    {
        return It.FieldsEnd;
    }
 
private:
    template <typename OtherType>
    friend class TCbFieldIterator;
 
    const void* FieldsEnd = nullptr;
};
 
 
enum class ECbFieldError : uint8
{
    None,
    TypeError,
    RangeError,
};
 
 
class FCbObjectId
{
public:
    using ByteArray = uint8[12];
 
    FCbObjectId() = default;
 
    inline explicit FCbObjectId(const ByteArray& ObjectId);
 
    CORE_API explicit FCbObjectId(FMemoryView ObjectId);
 
    inline const ByteArray& GetBytes() const { return Bytes; }
    inline operator const ByteArray&() const { return Bytes; }
 
    constexpr inline FMemoryView GetView() const { return MakeMemoryView(Bytes); }
 
    [[nodiscard]] CORE_API static FCbObjectId NewObjectId();
 
    inline bool operator==(const FCbObjectId& B) const
    {
        return FMemory::Memcmp(this, &B, sizeof(FCbObjectId)) == 0;
    }
 
    inline bool operator!=(const FCbObjectId& B) const
    {
        return FMemory::Memcmp(this, &B, sizeof(FCbObjectId)) != 0;
    }
 
    inline bool operator<(const FCbObjectId& B) const
    {
        return FMemory::Memcmp(this, &B, sizeof(FCbObjectId)) <= 0;
    }
 
    friend inline uint32 GetTypeHash(const FCbObjectId& Id)
    {
        return *reinterpret_cast<const uint32*>(&Id);
    }
 
    template <typename CharType>
    friend inline TStringBuilderBase<CharType>& operator<<(TStringBuilderBase<CharType>& Builder, const FCbObjectId& Id)
    {
        UE::String::BytesToHexLower(Id.GetBytes(), Builder);
        return Builder;
    }
 
private:
    alignas(uint32) ByteArray Bytes{};
};
 
inline FCbObjectId::FCbObjectId(const ByteArray& ObjectId)
{
    FMemory::Memcpy(Bytes, ObjectId, sizeof(ByteArray));
}
 
FGuid           ToGuid(const FCbObjectId& Id);
FCbObjectId     FromGuid(const FGuid& Id);
 
 
struct FCbCustomById
{
    uint64 Id = 0;
    FMemoryView Data;
};
 
struct FCbCustomByName
{
    FUtf8StringView Name;
    FMemoryView Data;
};
 
 
namespace UE::CompactBinary::Private
{
 
struct FIntegerParams
{
    uint32 IsSigned : 1;
    uint32 MagnitudeBits : 31;
};
 
template <typename IntType>
static constexpr inline FIntegerParams MakeIntegerParams()
{
    FIntegerParams Params;
    Params.IsSigned = IntType(-1) < IntType(0);
    Params.MagnitudeBits = 8 * sizeof(IntType) - Params.IsSigned;
    return Params;
}
 
} // UE::CompactBinary::Private
 
 
class FCbFieldView
{
public:
    constexpr FCbFieldView() = default;
 
    CORE_API explicit FCbFieldView(const void* Data, ECbFieldType Type = ECbFieldType::HasFieldType);
 
    inline explicit FCbFieldView(const FCbValue& Value);
 
    [[nodiscard]] constexpr inline FCbFieldView RemoveName() const
    {
        FCbFieldView Field;
        Field.TypeWithFlags = TypeWithFlags & ~(ECbFieldType::HasFieldType | ECbFieldType::HasFieldName);
        Field.Value = Value;
        return Field;
    }
 
    [[nodiscard]] constexpr inline FUtf8StringView GetName() const
    {
        return FUtf8StringView(static_cast<const UTF8CHAR*>(Value) - NameLen, NameLen);
    }
 
    [[nodiscard]] inline FCbValue GetValue() const;
 
    [[nodiscard]] CORE_API FCbObjectView AsObjectView();
 
    [[nodiscard]] CORE_API FCbArrayView AsArrayView();
 
    [[nodiscard]] CORE_API FMemoryView AsBinaryView(FMemoryView Default = FMemoryView());
 
    [[nodiscard]] CORE_API FUtf8StringView AsString(FUtf8StringView Default = FUtf8StringView());
 
    [[nodiscard]] inline int8 AsInt8(int8 Default = 0) { return AsInteger<int8>(Default); }
    [[nodiscard]] inline int16 AsInt16(int16 Default = 0) { return AsInteger<int16>(Default); }
    [[nodiscard]] inline int32 AsInt32(int32 Default = 0) { return AsInteger<int32>(Default); }
    [[nodiscard]] inline int64 AsInt64(int64 Default = 0) { return AsInteger<int64>(Default); }
    [[nodiscard]] inline uint8 AsUInt8(uint8 Default = 0) { return AsInteger<uint8>(Default); }
    [[nodiscard]] inline uint16 AsUInt16(uint16 Default = 0) { return AsInteger<uint16>(Default); }
    [[nodiscard]] inline uint32 AsUInt32(uint32 Default = 0) { return AsInteger<uint32>(Default); }
    [[nodiscard]] inline uint64 AsUInt64(uint64 Default = 0) { return AsInteger<uint64>(Default); }
 
    [[nodiscard]] CORE_API float AsFloat(float Default = 0.0f);
    [[nodiscard]] CORE_API double AsDouble(double Default = 0.0);
 
    [[nodiscard]] CORE_API bool AsBool(bool bDefault = false);
 
    [[nodiscard]] CORE_API FIoHash AsObjectAttachment(const FIoHash& Default = FIoHash());
    [[nodiscard]] CORE_API FIoHash AsBinaryAttachment(const FIoHash& Default = FIoHash());
    [[nodiscard]] CORE_API FIoHash AsAttachment(const FIoHash& Default = FIoHash());
 
    [[nodiscard]] CORE_API FIoHash AsHash(const FIoHash& Default = FIoHash());
 
    [[nodiscard]] CORE_API FGuid AsUuid();
    [[nodiscard]] CORE_API FGuid AsUuid(const FGuid& Default);
 
    [[nodiscard]] CORE_API int64 AsDateTimeTicks(int64 Default = 0);
 
    [[nodiscard]] CORE_API FDateTime AsDateTime();
    [[nodiscard]] CORE_API FDateTime AsDateTime(FDateTime Default);
 
    [[nodiscard]] CORE_API int64 AsTimeSpanTicks(int64 Default = 0);
 
    [[nodiscard]] CORE_API FTimespan AsTimeSpan();
    [[nodiscard]] CORE_API FTimespan AsTimeSpan(FTimespan Default);
 
    [[nodiscard]] CORE_API FCbObjectId AsObjectId(const FCbObjectId& Default = FCbObjectId());
 
    [[nodiscard]] CORE_API FCbCustomById AsCustomById(FCbCustomById Default = FCbCustomById());
    [[nodiscard]] CORE_API FCbCustomByName AsCustomByName(FCbCustomByName Default = FCbCustomByName());
 
    [[nodiscard]] CORE_API FMemoryView AsCustom(uint64 Id, FMemoryView Default = FMemoryView());
    [[nodiscard]] CORE_API FMemoryView AsCustom(FUtf8StringView Name, FMemoryView Default = FMemoryView());
 
    constexpr inline bool HasName() const           { return FCbFieldType::HasFieldName(TypeWithFlags); }
 
    constexpr inline bool IsNull() const            { return FCbFieldType::IsNull(TypeWithFlags); }
 
    constexpr inline bool IsObject() const          { return FCbFieldType::IsObject(TypeWithFlags); }
    constexpr inline bool IsArray() const           { return FCbFieldType::IsArray(TypeWithFlags); }
 
    constexpr inline bool IsBinary() const          { return FCbFieldType::IsBinary(TypeWithFlags); }
    constexpr inline bool IsString() const          { return FCbFieldType::IsString(TypeWithFlags); }
 
    constexpr inline bool IsInteger() const         { return FCbFieldType::IsInteger(TypeWithFlags); }
    constexpr inline bool IsFloat() const           { return FCbFieldType::IsFloat(TypeWithFlags); }
    constexpr inline bool IsBool() const            { return FCbFieldType::IsBool(TypeWithFlags); }
 
    constexpr inline bool IsObjectAttachment() const { return FCbFieldType::IsObjectAttachment(TypeWithFlags); }
    constexpr inline bool IsBinaryAttachment() const { return FCbFieldType::IsBinaryAttachment(TypeWithFlags); }
    constexpr inline bool IsAttachment() const       { return FCbFieldType::IsAttachment(TypeWithFlags); }
 
    constexpr inline bool IsHash() const            { return FCbFieldType::IsHash(TypeWithFlags); }
    constexpr inline bool IsUuid() const            { return FCbFieldType::IsUuid(TypeWithFlags); }
 
    constexpr inline bool IsDateTime() const        { return FCbFieldType::IsDateTime(TypeWithFlags); }
    constexpr inline bool IsTimeSpan() const        { return FCbFieldType::IsTimeSpan(TypeWithFlags); }
 
    constexpr inline bool IsObjectId() const        { return FCbFieldType::IsObjectId(TypeWithFlags); }
 
    constexpr inline bool IsCustomById() const      { return FCbFieldType::IsCustomById(TypeWithFlags); }
    constexpr inline bool IsCustomByName() const    { return FCbFieldType::IsCustomByName(TypeWithFlags); }
 
    constexpr inline explicit operator bool() const { return HasValue(); }
 
    constexpr inline bool HasValue() const          { return !FCbFieldType::IsNone(TypeWithFlags); };
 
    constexpr inline bool HasError() const          { return Error != ECbFieldError::None; }
 
    [[nodiscard]] constexpr inline ECbFieldError GetError() const { return Error; }
 
    [[nodiscard]] CORE_API uint64 GetSize() const;
 
    [[nodiscard]] CORE_API FIoHash GetHash() const;
    CORE_API void AppendHash(FIoHashBuilder& Builder) const;
 
    CORE_API bool Equals(const FCbFieldView& Other) const;
 
    CORE_API void CopyTo(FMutableMemoryView Buffer) const;
 
    CORE_API void CopyTo(FArchive& Ar) const;
 
    CORE_API void IterateAttachments(FCbFieldVisitor Visitor) const;
 
    inline bool TryGetView(FMemoryView& OutView) const
    {
        if (FCbFieldType::HasFieldType(TypeWithFlags))
        {
            OutView = GetView();
            return true;
        }
        return false;
    }
 
    [[nodiscard]] CORE_API FCbFieldView operator[](FUtf8StringView Name) const;
 
    [[nodiscard]] CORE_API FCbFieldViewIterator CreateViewIterator() const;
 
    inline FCbFieldViewIterator begin() const;
    constexpr inline FCbIteratorSentinel end() const { return FCbIteratorSentinel(); }
 
protected:
    CORE_API FMemoryView GetView() const;
 
    CORE_API FMemoryView GetViewNoType() const;
 
    inline FMemoryView GetValueView() const { return MakeMemoryView(Value, GetValueSize()); }
 
    constexpr inline ECbFieldType GetType() const { return FCbFieldType::GetType(TypeWithFlags); }
 
    constexpr inline ECbFieldType GetTypeWithFlags() const { return TypeWithFlags; }
 
    constexpr inline const void* GetValueData() const { return Value; }
 
    inline const void* GetValueEnd() const { return static_cast<const uint8*>(Value) + GetValueSize(); }
 
    CORE_API uint64 GetValueSize() const;
 
    inline void Assign(const void* InData, const ECbFieldType InType)
    {
        static_assert(std::is_trivially_destructible_v<FCbFieldView>,
            "This optimization requires FCbFieldView to be trivially destructible!");
        new(this) FCbFieldView(InData, InType);
    }
 
private:
    template <typename IntType>
    inline IntType AsInteger(IntType Default)
    {
        return IntType(AsInteger(uint64(Default), UE::CompactBinary::Private::MakeIntegerParams<IntType>()));
    }
 
    CORE_API uint64 AsInteger(uint64 Default, UE::CompactBinary::Private::FIntegerParams Params);
 
private:
    ECbFieldType TypeWithFlags = ECbFieldType::None;
    ECbFieldError Error = ECbFieldError::None;
    uint32 NameLen = 0;
    const void* Value = nullptr;
};
 
class FCbFieldViewIterator : public TCbFieldIterator<FCbFieldView>
{
public:
    [[nodiscard]] static inline FCbFieldViewIterator MakeSingle(const FCbFieldView& Field)
    {
        return FCbFieldViewIterator(Field);
    }
 
    [[nodiscard]] static inline FCbFieldViewIterator MakeRange(FMemoryView View, ECbFieldType Type = ECbFieldType::HasFieldType)
    {
        return !View.IsEmpty() ? FCbFieldViewIterator(FCbFieldView(View.GetData(), Type), View.GetDataEnd()) : FCbFieldViewIterator();
    }
 
    constexpr FCbFieldViewIterator() = default;
 
    template <typename OtherFieldType>
    inline FCbFieldViewIterator(const TCbFieldIterator<OtherFieldType>& It)
        : TCbFieldIterator(ImplicitConv<FCbFieldView>(It), GetFieldsEnd(It))
    {
    }
 
private:
    using TCbFieldIterator::TCbFieldIterator;
};
 
inline FCbFieldViewIterator FCbFieldView::begin() const
{
    return CreateViewIterator();
}
 
 
class FCbArrayView : protected FCbFieldView
{
public:
    using FCbFieldView::FCbFieldView;
 
    CORE_API FCbArrayView();
 
    CORE_API uint64 Num() const;
 
    [[nodiscard]] inline FCbFieldView AsFieldView() const { return RemoveName(); }
 
    [[nodiscard]] static inline FCbArrayView FromFieldNoCheck(const FCbFieldView& Field) { return FCbArrayView(Field); }
 
    inline explicit operator bool() const { return Num() > 0; }
 
    CORE_API uint64 GetSize() const;
 
    CORE_API FIoHash GetHash() const;
    CORE_API void AppendHash(FIoHashBuilder& Builder) const;
 
    CORE_API bool Equals(const FCbArrayView& Other) const;
 
    CORE_API void CopyTo(FMutableMemoryView Buffer) const;
 
    CORE_API void CopyTo(FArchive& Ar) const;
 
    inline void IterateAttachments(FCbFieldVisitor Visitor) const { CreateViewIterator().IterateRangeAttachments(Visitor); }
 
    inline bool TryGetView(FMemoryView& OutView) const
    {
        return !FCbFieldView::HasName() && FCbFieldView::TryGetView(OutView);
    }
 
    using FCbFieldView::CreateViewIterator;
    using FCbFieldView::begin;
    using FCbFieldView::end;
 
private:
    inline explicit FCbArrayView(const FCbFieldView& Field) : FCbFieldView(Field) {}
};
 
 
class FCbObjectView : protected FCbFieldView
{
public:
    using FCbFieldView::FCbFieldView;
 
    CORE_API FCbObjectView();
 
    [[nodiscard]] CORE_API FCbFieldView FindView(FUtf8StringView Name) const;
 
    [[nodiscard]] CORE_API FCbFieldView FindViewIgnoreCase(FUtf8StringView Name) const;
 
    [[nodiscard]] inline FCbFieldView operator[](FUtf8StringView Name) const { return FindView(Name); }
 
    [[nodiscard]] inline FCbFieldView AsFieldView() const { return RemoveName(); }
 
    [[nodiscard]] static inline FCbObjectView FromFieldNoCheck(const FCbFieldView& Field) { return FCbObjectView(Field); }
 
    CORE_API explicit operator bool() const;
 
    CORE_API uint64 GetSize() const;
 
    CORE_API FIoHash GetHash() const;
    CORE_API void AppendHash(FIoHashBuilder& Builder) const;
 
    CORE_API bool Equals(const FCbObjectView& Other) const;
 
    CORE_API void CopyTo(FMutableMemoryView Buffer) const;
 
    CORE_API void CopyTo(FArchive& Ar) const;
 
    inline void IterateAttachments(FCbFieldVisitor Visitor) const { CreateViewIterator().IterateRangeAttachments(Visitor); }
 
    inline bool TryGetView(FMemoryView& OutView) const
    {
        return !FCbFieldView::HasName() && FCbFieldView::TryGetView(OutView);
    }
 
    using FCbFieldView::CreateViewIterator;
    using FCbFieldView::begin;
    using FCbFieldView::end;
 
private:
    inline explicit FCbObjectView(const FCbFieldView& Field) : FCbFieldView(Field) {}
};
 
 
template <typename ViewType>
class TCbBuffer : public ViewType
{
public:
    TCbBuffer() = default;
 
    inline explicit TCbBuffer(FSharedBuffer ValueBuffer, ECbFieldType Type = ECbFieldType::HasFieldType)
    {
        if (ValueBuffer)
        {
            ViewType::operator=(ViewType(ValueBuffer.GetData(), Type));
            check(ValueBuffer.GetView().Contains(ViewType::GetView()));
            Buffer = MoveTemp(ValueBuffer);
        }
    }
 
    inline TCbBuffer(const ViewType& Value, FSharedBuffer OuterBuffer)
        : ViewType(Value)
    {
        if (OuterBuffer)
        {
            check(OuterBuffer.GetView().Contains(ViewType::GetView()));
            Buffer = MoveTemp(OuterBuffer);
        }
    }
 
    template <typename OtherViewType>
    inline TCbBuffer(const ViewType& Value, TCbBuffer<OtherViewType> OuterBuffer)
        : TCbBuffer(Value, MoveTemp(OuterBuffer.Buffer))
    {
    }
 
    inline void Reset() { *this = TCbBuffer(); }
 
    inline bool IsOwned() const { return Buffer && Buffer.IsOwned(); }
 
    inline void MakeOwned()
    {
        if (!IsOwned())
        {
            FUniqueBuffer MutableBuffer = FUniqueBuffer::Alloc(ViewType::GetSize());
            ViewType::CopyTo(MutableBuffer);
            ViewType::operator=(ViewType(MutableBuffer.GetData()));
            Buffer = MutableBuffer.MoveToShared();
        }
    }
 
    [[nodiscard]] inline const ViewType& AsView() const { return *this; }
 
    [[nodiscard]] inline const FSharedBuffer& GetOuterBuffer() const & { return Buffer; }
    [[nodiscard]] inline FSharedBuffer GetOuterBuffer() && { return MoveTemp(Buffer); }
 
    [[nodiscard]] inline FCbField operator[](FUtf8StringView Name) const;
 
    [[nodiscard]] inline FCbFieldIterator CreateIterator() const;
 
    inline FCbFieldIterator begin() const;
    constexpr inline FCbIteratorSentinel end() const { return FCbIteratorSentinel(); }
 
private:
    template <typename OtherType>
    friend class TCbBuffer;
 
    FSharedBuffer Buffer;
};
 
 
template <typename Type, typename ViewType>
class TCbBufferFactory
{
public:
    [[nodiscard]] static inline Type Clone(const void* const Data)
    {
        return Clone(ViewType(Data));
    }
 
    [[nodiscard]] static inline Type Clone(const ViewType& Value)
    {
        Type Owned = MakeView(Value);
        Owned.MakeOwned();
        return Owned;
    }
 
    [[nodiscard]] static inline Type MakeView(const void* const Data, FSharedBuffer OuterBuffer = FSharedBuffer())
    {
        return MakeView(ViewType(Data), MoveTemp(OuterBuffer));
    }
 
    [[nodiscard]] static inline Type MakeView(const ViewType& Value, FSharedBuffer OuterBuffer = FSharedBuffer())
    {
        return Type(Value, MoveTemp(OuterBuffer));
    }
};
 
 
class FCbArray;
class FCbObject;
 
 
class FCbField : public TCbBuffer<FCbFieldView>, public TCbBufferFactory<FCbField, FCbFieldView>
{
public:
    using TCbBuffer::TCbBuffer;
 
    [[nodiscard]] inline FCbObject AsObject() &;
    [[nodiscard]] inline FCbObject AsObject() &&;
 
    [[nodiscard]] inline FCbArray AsArray()&;
    [[nodiscard]] inline FCbArray AsArray() &&;
 
    [[nodiscard]] inline FSharedBuffer AsBinary(const FSharedBuffer& Default = FSharedBuffer())&;
    [[nodiscard]] inline FSharedBuffer AsBinary(const FSharedBuffer& Default = FSharedBuffer()) &&;
 
    [[nodiscard]] CORE_API FCompositeBuffer GetBuffer() const;
};
 
template <typename ViewType>
inline FCbField TCbBuffer<ViewType>::operator[](FUtf8StringView Name) const
{
    if (FCbFieldView Field = ViewType::operator[](Name))
    {
        return FCbField::MakeView(Field, GetOuterBuffer());
    }
    return FCbField();
}
 
class FCbFieldIterator : public TCbFieldIterator<FCbField>
{
public:
    [[nodiscard]] CORE_API static FCbFieldIterator CloneRange(const FCbFieldViewIterator& It);
 
    [[nodiscard]] static inline FCbFieldIterator CloneRange(const FCbFieldIterator& It)
    {
        return CloneRange(FCbFieldViewIterator(It));
    }
 
    [[nodiscard]] static inline FCbFieldIterator MakeSingle(FCbField Field)
    {
        return FCbFieldIterator(MoveTemp(Field));
    }
 
    [[nodiscard]] static inline FCbFieldIterator MakeRange(FSharedBuffer Buffer, ECbFieldType Type = ECbFieldType::HasFieldType)
    {
        if (Buffer.GetSize())
        {
            const void* const DataEnd = Buffer.GetView().GetDataEnd();
            return FCbFieldIterator(FCbField(MoveTemp(Buffer), Type), DataEnd);
        }
        return FCbFieldIterator();
    }
 
    [[nodiscard]] static inline FCbFieldIterator MakeRangeView(const FCbFieldViewIterator& It, FSharedBuffer OuterBuffer = FSharedBuffer())
    {
        return FCbFieldIterator(FCbField(It, MoveTemp(OuterBuffer)), GetFieldsEnd(It));
    }
 
    constexpr FCbFieldIterator() = default;
 
    inline void MakeRangeOwned()
    {
        if (!IsOwned())
        {
            *this = CloneRange(*this);
        }
    }
 
    void MakeOwned() = delete;
 
private:
    using TCbFieldIterator::TCbFieldIterator;
};
 
template <typename ViewType>
inline FCbFieldIterator TCbBuffer<ViewType>::CreateIterator() const
{
    if (FCbFieldViewIterator It = ViewType::CreateViewIterator())
    {
        return FCbFieldIterator::MakeRangeView(It, GetOuterBuffer());
    }
    return FCbFieldIterator();
}
 
template <typename ViewType>
inline FCbFieldIterator TCbBuffer<ViewType>::begin() const
{
    return CreateIterator();
}
 
 
class FCbArray : public TCbBuffer<FCbArrayView>, public TCbBufferFactory<FCbArray, FCbArrayView>
{
public:
    using TCbBuffer::TCbBuffer;
 
    [[nodiscard]] inline FCbField AsField() const & { return FCbField(FCbArrayView::AsFieldView(), *this); }
    [[nodiscard]] inline FCbField AsField() && { return FCbField(FCbArrayView::AsFieldView(), MoveTemp(*this)); }
 
    [[nodiscard]] CORE_API FCompositeBuffer GetBuffer() const;
};
 
 
class FCbObject : public TCbBuffer<FCbObjectView>, public TCbBufferFactory<FCbObject, FCbObjectView>
{
public:
    using TCbBuffer::TCbBuffer;
 
    [[nodiscard]] inline FCbField Find(FUtf8StringView Name) const
    {
        if (::FCbFieldView Field = FindView(Name))
        {
            return FCbField(Field, *this);
        }
        return FCbField();
    }
 
    [[nodiscard]] inline FCbField FindIgnoreCase(FUtf8StringView Name) const
    {
        if (::FCbFieldView Field = FindViewIgnoreCase(Name))
        {
            return FCbField(Field, *this);
        }
        return FCbField();
    }
 
    [[nodiscard]] inline FCbField operator[](FUtf8StringView Name) const { return Find(Name); }
 
    [[nodiscard]] inline FCbField AsField() const & { return FCbField(FCbObjectView::AsFieldView(), *this); }
    [[nodiscard]] inline FCbField AsField() && { return FCbField(FCbObjectView::AsFieldView(), MoveTemp(*this)); }
 
    [[nodiscard]] CORE_API FCompositeBuffer GetBuffer() const;
};
 
 
inline FCbObject FCbField::AsObject() &
{
    const FCbObjectView View = AsObjectView();
    return !HasError() ? FCbObject(View, *this) : FCbObject();
}
 
inline FCbObject FCbField::AsObject() &&
{
    const FCbObjectView View = AsObjectView();
    return !HasError() ? FCbObject(View, MoveTemp(*this)) : FCbObject();
}
 
inline FCbArray FCbField::AsArray() &
{
    const FCbArrayView View = AsArrayView();
    return !HasError() ? FCbArray(View, *this) : FCbArray();
}
 
inline FCbArray FCbField::AsArray() &&
{
    const FCbArrayView View = AsArrayView();
    return !HasError() ? FCbArray(View, MoveTemp(*this)) : FCbArray();
}
 
inline FSharedBuffer FCbField::AsBinary(const FSharedBuffer& Default) &
{
    const FMemoryView View = AsBinaryView();
    return !HasError() ? FSharedBuffer::MakeView(View, GetOuterBuffer()) : Default;
}
 
inline FSharedBuffer FCbField::AsBinary(const FSharedBuffer& Default) &&
{
    const FMemoryView View = AsBinaryView();
    return !HasError() ? FSharedBuffer::MakeView(View, MoveTemp(*this).GetOuterBuffer()) : Default;
}
 
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_5
#include "Templates/IsTriviallyDestructible.h"
#endif