CompactBinaryWriter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "Containers/StringFwd.h"
#include "Containers/StringView.h"
#include "CoreTypes.h"
#include "HAL/PlatformCrt.h"
#include "Memory/MemoryFwd.h"
#include "Memory/MemoryView.h"
#include "Serialization/CompactBinary.h"
 
#include <type_traits>
 
class FCompositeBuffer;
class FSharedBuffer;
 
 
class FArchive;
class FCbAttachment;
class FName;
struct FDateTime;
struct FGuid;
struct FIoHash;
struct FTimespan;
 
class FCbWriter
{
public:
    CORE_API FCbWriter();
    CORE_API ~FCbWriter();
 
    FCbWriter(const FCbWriter&) = delete;
    FCbWriter& operator=(const FCbWriter&) = delete;
 
    CORE_API void Reset();
 
    CORE_API FCbFieldIterator Save() const;
 
    CORE_API FCbFieldViewIterator Save(FMutableMemoryView Buffer) const;
 
    CORE_API void Save(FArchive& Ar) const;
 
    CORE_API uint64 GetSaveSize() const;
 
    CORE_API FCbWriter& SetName(FUtf8StringView Name);
 
    inline void AddField(FUtf8StringView Name, const FCbFieldView& Value) { SetName(Name); AddField(Value); }
    CORE_API void AddField(const FCbFieldView& Value);
    inline void AddField(FUtf8StringView Name, const FCbField& Value) { SetName(Name); AddField(Value); }
    CORE_API void AddField(const FCbField& Value);
 
    inline void BeginObject(FUtf8StringView Name) { SetName(Name); BeginObject(); }
    CORE_API void BeginObject();
    CORE_API void EndObject();
 
    inline void AddObject(FUtf8StringView Name, const FCbObjectView& Value) { SetName(Name); AddObject(Value); }
    CORE_API void AddObject(const FCbObjectView& Value);
    inline void AddObject(FUtf8StringView Name, const FCbObject& Value) { SetName(Name); AddObject(Value); }
    CORE_API void AddObject(const FCbObject& Value);
 
    inline void BeginArray(FUtf8StringView Name) { SetName(Name); BeginArray(); }
    CORE_API void BeginArray();
    CORE_API void EndArray();
 
    inline void AddArray(FUtf8StringView Name, const FCbArrayView& Value) { SetName(Name); AddArray(Value); }
    CORE_API void AddArray(const FCbArrayView& Value);
    inline void AddArray(FUtf8StringView Name, const FCbArray& Value) { SetName(Name); AddArray(Value); }
    CORE_API void AddArray(const FCbArray& Value);
 
    inline void AddNull(FUtf8StringView Name) { SetName(Name); AddNull(); }
    CORE_API void AddNull();
 
    inline void AddBinary(FUtf8StringView Name, const void* Value, uint64 Size) { SetName(Name); AddBinary(Value, Size); }
    CORE_API void AddBinary(const void* Value, uint64 Size);
    inline void AddBinary(FUtf8StringView Name, FMemoryView Value) { SetName(Name); AddBinary(Value); }
    inline void AddBinary(FMemoryView Value) { AddBinary(Value.GetData(), Value.GetSize()); }
    inline void AddBinary(FUtf8StringView Name, const FSharedBuffer& Value) { SetName(Name); AddBinary(Value); }
    CORE_API void AddBinary(const FSharedBuffer& Value);
    inline void AddBinary(FUtf8StringView Name, const FCompositeBuffer& Value) { SetName(Name); AddBinary(Value); }
    CORE_API void AddBinary(const FCompositeBuffer& Value);
 
    inline void AddString(FUtf8StringView Name, FUtf8StringView Value) { SetName(Name); AddString(Value); }
    CORE_API void AddString(FUtf8StringView Value);
    inline void AddString(FUtf8StringView Name, FWideStringView Value) { SetName(Name); AddString(Value); }
    CORE_API void AddString(FWideStringView Value);
 
    inline void AddInteger(FUtf8StringView Name, int32 Value) { SetName(Name); AddInteger(Value); }
    CORE_API void AddInteger(int32 Value);
    inline void AddInteger(FUtf8StringView Name, int64 Value) { SetName(Name); AddInteger(Value); }
    CORE_API void AddInteger(int64 Value);
    inline void AddInteger(FUtf8StringView Name, uint32 Value) { SetName(Name); AddInteger(Value); }
    CORE_API void AddInteger(uint32 Value);
    inline void AddInteger(FUtf8StringView Name, uint64 Value) { SetName(Name); AddInteger(Value); }
    CORE_API void AddInteger(uint64 Value);
 
    inline void AddFloat(FUtf8StringView Name, float Value) { SetName(Name); AddFloat(Value); }
    CORE_API void AddFloat(float Value);
    inline void AddFloat(FUtf8StringView Name, double Value) { SetName(Name); AddFloat(Value); }
    CORE_API void AddFloat(double Value);
 
    inline void AddBool(FUtf8StringView Name, bool bValue) { SetName(Name); AddBool(bValue); }
    CORE_API void AddBool(bool bValue);
 
    inline void AddObjectAttachment(FUtf8StringView Name, const FIoHash& Value) { SetName(Name); AddObjectAttachment(Value); }
    CORE_API void AddObjectAttachment(const FIoHash& Value);
    inline void AddBinaryAttachment(FUtf8StringView Name, const FIoHash& Value) { SetName(Name); AddBinaryAttachment(Value); }
    CORE_API void AddBinaryAttachment(const FIoHash& Value);
    inline void AddAttachment(FUtf8StringView Name, const FCbAttachment& Attachment) { SetName(Name); AddAttachment(Attachment); }
    CORE_API void AddAttachment(const FCbAttachment& Attachment);
 
    inline void AddHash(FUtf8StringView Name, const FIoHash& Value) { SetName(Name); AddHash(Value); }
    CORE_API void AddHash(const FIoHash& Value);
    inline void AddUuid(FUtf8StringView Name, const FGuid& Value) { SetName(Name); AddUuid(Value); }
    CORE_API void AddUuid(const FGuid& Value);
 
    inline void AddDateTimeTicks(FUtf8StringView Name, int64 Ticks) { SetName(Name); AddDateTimeTicks(Ticks); }
    CORE_API void AddDateTimeTicks(int64 Ticks);
 
    CORE_API void AddDateTime(FUtf8StringView Name, FDateTime Value);
    CORE_API void AddDateTime(FDateTime Value);
 
    inline void AddTimeSpanTicks(FUtf8StringView Name, int64 Ticks) { SetName(Name); AddTimeSpanTicks(Ticks); }
    CORE_API void AddTimeSpanTicks(int64 Ticks);
 
    CORE_API void AddTimeSpan(FUtf8StringView Name, FTimespan Value);
    CORE_API void AddTimeSpan(FTimespan Value);
 
    inline void AddObjectId(FUtf8StringView Name, const FCbObjectId& Value) { SetName(Name); AddObjectId(Value); }
    CORE_API void AddObjectId(const FCbObjectId& Value);
 
    inline void AddCustom(FUtf8StringView FieldName, uint64 TypeId, FMemoryView Value) { SetName(FieldName); AddCustom(TypeId, Value); }
    CORE_API void AddCustom(uint64 TypeId, FMemoryView Value);
 
    inline void AddCustom(FUtf8StringView FieldName, FUtf8StringView TypeName, FMemoryView Value) { SetName(FieldName); AddCustom(TypeName, Value); }
    CORE_API void AddCustom(FUtf8StringView TypeName, FMemoryView Value);
 
    enum class EStateFlags : uint8;
 
protected:
    CORE_API explicit FCbWriter(int64 InitialSize);
 
private:
 
    void BeginField();
 
    void EndField(ECbFieldType Type);
 
    CORE_API void SetNameOrAddString(FUtf8StringView NameOrValue);
 
    FUtf8StringView GetActiveName() const;
 
    void MakeFieldsUniform(int64 FieldBeginOffset, int64 FieldEndOffset);
 
    struct FState
    {
        EStateFlags Flags{};
        ECbFieldType UniformType{};
        int64 Offset{};
        uint64 Count{};
    };
 
private:
    // This is a prototype-quality format for the writer. Using an array of bytes is inefficient,
    // and will lead to many unnecessary copies and moves of the data to resize the array, insert
    // object and array sizes, and remove field types for uniform objects and uniform arrays. The
    // optimized format will be a list of power-of-two blocks and an optional first block that is
    // provided externally, such as on the stack. That format will store the offsets that require
    // object or array sizes to be inserted and field types to be removed, and will perform those
    // operations only when saving to a buffer.
    TArray64<uint8> Data;
    TArray<FState> States;
 
public:
    inline FCbWriter& operator<<(FUtf8StringView NameOrValue)
    {
        SetNameOrAddString(NameOrValue);
        return *this;
    }
 
    inline FCbWriter& operator<<(const ANSICHAR* NameOrValue)
    {
        return *this << FAnsiStringView(NameOrValue);
    }
 
    inline FCbWriter& operator<<(const UTF8CHAR* NameOrValue)
    {
        return *this << FUtf8StringView(NameOrValue);
    }
 
    inline FCbWriter& operator<<(const FCbFieldView& Value)
    {
        AddField(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(const FCbField& Value)
    {
        AddField(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(const FCbObjectView& Value)
    {
        AddObject(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(const FCbObject& Value)
    {
        AddObject(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(const FCbArrayView& Value)
    {
        AddArray(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(const FCbArray& Value)
    {
        AddArray(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(TYPE_OF_NULLPTR)
    {
        AddNull();
        return *this;
    }
 
    inline FCbWriter& operator<<(FWideStringView Value)
    {
        AddString(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(const WIDECHAR* Value)
    {
        AddString(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(int32 Value)
    {
        AddInteger(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(int64 Value)
    {
        AddInteger(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(uint32 Value)
    {
        AddInteger(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(uint64 Value)
    {
        AddInteger(Value);
        return *this;
    }
 
#if PLATFORM_LINUX || PLATFORM_APPLE
    // On Unix-like platforms, size_t is an unsigned long, whereas UE defines uint64 as unsigned long long,
    // making the two types immiscible for template resolution. However, SSIZE_T is currently defined as
    // int64 (see FGenericPlatformTypes) and so no special overload is required for that type.
    inline FCbWriter& operator<<(SIZE_T Value)
    {
        AddInteger(static_cast<uint64>(Value));
        return *this;
    }
#endif
 
    inline FCbWriter& operator<<(float Value)
    {
        AddFloat(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(double Value)
    {
        AddFloat(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(bool Value)
    {
        AddBool(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(const FCbAttachment& Attachment)
    {
        AddAttachment(Attachment);
        return *this;
    }
 
    inline FCbWriter& operator<<(const FIoHash& Value)
    {
        AddHash(Value);
        return *this;
    }
 
    inline FCbWriter& operator<<(const FGuid& Value)
    {
        AddUuid(Value);
        return *this;
    }
 
    CORE_API FCbWriter& operator<<(FDateTime Value);
    CORE_API FCbWriter& operator<<(FTimespan Value);
 
    inline FCbWriter& operator<<(const FCbObjectId& Value)
    {
        AddObjectId(Value);
        return *this;
    }
 
    CORE_API FCbWriter& operator<<(const FString& Value);
    CORE_API FCbWriter& operator<<(const FAnsiString& Value);
    CORE_API FCbWriter& operator<<(const FUtf8String& Value);
    CORE_API FCbWriter& operator<<(FName Value);
 
    template <typename T, typename Allocator,
        std::void_t<decltype(std::declval<FCbWriter&>() << std::declval<const T&>())>* = nullptr>
    inline FCbWriter& operator<<(const TArray<T, Allocator>& Value)
    {
        BeginArray();
        for (const T& Element : Value)
        {
            *this << Element;
        }
        EndArray();
        return *this;
    }
};
 
 
template <uint32 InlineBufferSize>
class TCbWriter : public FCbWriter
{
public:
    inline TCbWriter()
        : FCbWriter(InlineBufferSize)
    {
    }
 
    TCbWriter(const TCbWriter&) = delete;
    TCbWriter& operator=(const TCbWriter&) = delete;
 
private:
    // Reserve the inline buffer now even though we are unable to use it. This will avoid causing
    // new stack overflows when this functionality is properly implemented in the future.
    uint8 Buffer[InlineBufferSize];
};