CompactBinaryPackage.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Compression/CompressedBuffer.h"
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "CoreTypes.h"
#include "IO/IoHash.h"
#include "Memory/CompositeBuffer.h"
#include "Memory/SharedBuffer.h"
#include "Misc/AssertionMacros.h"
#include "Misc/TVariant.h"
#include "Serialization/CompactBinary.h"
#include "Templates/Function.h"
#include "Templates/UnrealTemplate.h"
 
class FArchive;
class FCbWriter;
template <typename FuncType> class TFunctionRef;
 
 
class FCbAttachment
{
    struct FObjectValue
    {
        FCbObject Object;
        FIoHash Hash;
 
        CORE_API FObjectValue(FCbObject&& Object, const FIoHash* Hash);
    };
 
    struct FBinaryValue
    {
        FCompositeBuffer Buffer;
        FIoHash Hash;
 
        template <typename BufferType, decltype(FCompositeBuffer(DeclVal<BufferType>().MakeOwned()))* = nullptr>
        inline explicit FBinaryValue(BufferType&& InBuffer)
            : Buffer(Forward<BufferType>(InBuffer).MakeOwned())
            , Hash(FIoHash::HashBuffer(Buffer))
        {
        }
 
        template <typename BufferType, decltype(FCompositeBuffer(DeclVal<BufferType>().MakeOwned()))* = nullptr>
        inline explicit FBinaryValue(BufferType&& InBuffer, const FIoHash& InHash)
            : Buffer(Forward<BufferType>(InBuffer).MakeOwned())
            , Hash(InHash)
        {
            checkSlow(Hash == FIoHash::HashBuffer(Buffer));
        }
    };
 
    struct FCompressedBinaryValue
    {
        FCompressedBuffer Buffer;
        FIoHash Hash;
 
        template <typename BufferType, decltype(FCompressedBuffer(DeclVal<BufferType>().MakeOwned()))* = nullptr>
        inline explicit FCompressedBinaryValue(BufferType&& InBuffer)
            : Buffer(Forward<BufferType>(InBuffer).MakeOwned())
            , Hash(Buffer.GetRawHash())
        {
        }
 
        template <typename BufferType, decltype(FCompressedBuffer(DeclVal<BufferType>().MakeOwned()))* = nullptr>
        inline explicit FCompressedBinaryValue(BufferType&& InBuffer, const FIoHash& InHash)
            : Buffer(Forward<BufferType>(InBuffer).MakeOwned())
            , Hash(InHash)
        {
        }
    };
 
    template <typename... ArgTypes, decltype(FBinaryValue(DeclVal<ArgTypes>()...))* = nullptr>
    inline FCbAttachment(TInPlaceType<FBinaryValue>, ArgTypes&&... Args)
        : Value(TInPlaceType<FBinaryValue>(), Forward<ArgTypes>(Args)...)
    {
        if (Value.Get<FBinaryValue>().Buffer.IsNull())
        {
            Value.Emplace<TYPE_OF_NULLPTR>();
        }
    }
 
public:
    FCbAttachment() = default;
 
    inline explicit FCbAttachment(const FCbObject& InValue)
        : Value(TInPlaceType<FObjectValue>(), FCbObject(InValue), nullptr) {}
    inline explicit FCbAttachment(FCbObject&& InValue)
        : Value(TInPlaceType<FObjectValue>(), MoveTemp(InValue), nullptr) {}
    inline explicit FCbAttachment(const FCbObject& InValue, const FIoHash& Hash)
        : Value(TInPlaceType<FObjectValue>(), FCbObject(InValue), &Hash) {}
    inline explicit FCbAttachment(FCbObject&& InValue, const FIoHash& Hash)
        : Value(TInPlaceType<FObjectValue>(), MoveTemp(InValue), &Hash) {}
 
    template <typename BufferType, decltype(FBinaryValue(DeclVal<BufferType>().MakeOwned()))* = nullptr>
    inline explicit FCbAttachment(BufferType&& InValue)
        : FCbAttachment(TInPlaceType<FBinaryValue>(), Forward<BufferType>(InValue).MakeOwned()) {}
    template <typename BufferType, decltype(FBinaryValue(DeclVal<BufferType>().MakeOwned()))* = nullptr>
    inline explicit FCbAttachment(BufferType&& InValue, const FIoHash& InHash)
        : FCbAttachment(TInPlaceType<FBinaryValue>(), Forward<BufferType>(InValue).MakeOwned(), InHash) {}
 
    inline explicit FCbAttachment(const FCompressedBuffer& InValue)
        : Value(TInPlaceType<FCompressedBinaryValue>(), InValue)
    {
        if (Value.Get<FCompressedBinaryValue>().Buffer.IsNull())
        {
            Value.Emplace<TYPE_OF_NULLPTR>();
        }
    }
 
    UE_INTERNAL inline explicit FCbAttachment(const FCompressedBuffer& InValue, const FIoHash& Hash)
        : Value(TInPlaceType<FCompressedBinaryValue>(), InValue, Hash)
    {
        if (Value.Get<FCompressedBinaryValue>().Buffer.IsNull())
        {
            Value.Emplace<TYPE_OF_NULLPTR>();
        }
    }
 
    inline explicit FCbAttachment(FCompressedBuffer&& InValue)
        : Value(TInPlaceType<FCompressedBinaryValue>(), InValue)
    {
        if (Value.Get<FCompressedBinaryValue>().Buffer.IsNull())
        {
            Value.Emplace<TYPE_OF_NULLPTR>();
        }
    }
 
    UE_INTERNAL inline explicit FCbAttachment(FCompressedBuffer&& InValue, const FIoHash& Hash)
        : Value(TInPlaceType<FCompressedBinaryValue>(), InValue, Hash)
    {
        if (Value.Get<FCompressedBinaryValue>().Buffer.IsNull())
        {
            Value.Emplace<TYPE_OF_NULLPTR>();
        }
    }
 
    inline void Reset() { *this = FCbAttachment(); }
 
    inline FCbObject AsObject() const;
 
    inline FSharedBuffer AsBinary() const;
 
    inline const FCompositeBuffer& AsCompositeBinary() const;
 
    inline const FCompressedBuffer& AsCompressedBinary() const;
 
    inline explicit operator bool() const { return !IsNull(); }
 
    inline bool IsNull() const { return Value.IsType<TYPE_OF_NULLPTR>(); }
 
    inline bool IsObject() const { return Value.IsType<FObjectValue>(); }
 
    inline bool IsBinary() const { return Value.IsType<FBinaryValue>(); }
 
    inline bool IsCompressedBinary() const { return Value.IsType<FCompressedBinaryValue>(); }
 
    CORE_API FIoHash GetHash() const;
 
    inline bool operator==(const FCbAttachment& Attachment) const { return GetHash() == Attachment.GetHash(); }
    inline bool operator!=(const FCbAttachment& Attachment) const { return GetHash() != Attachment.GetHash(); }
    inline bool operator<(const FCbAttachment& Attachment) const { return GetHash() < Attachment.GetHash(); }
 
    CORE_API bool TryLoad(FCbFieldIterator& Fields);
 
    CORE_API bool TryLoad(FArchive& Ar, FCbBufferAllocator Allocator = FUniqueBuffer::Alloc);
 
    CORE_API void Save(FCbWriter& Writer) const;
 
    CORE_API void Save(FArchive& Ar) const;
 
private:
    TVariant<TYPE_OF_NULLPTR, FObjectValue, FBinaryValue, FCompressedBinaryValue> Value;
};
 
inline uint32 GetTypeHash(const FCbAttachment& Attachment)
{
    return GetTypeHash(Attachment.GetHash());
}
 
 
class FCbPackage
{
public:
    using FAttachmentResolver = TFunctionRef<FSharedBuffer (const FIoHash& Hash)>;
 
    FCbPackage() = default;
 
    inline explicit FCbPackage(FCbObject InObject)
    {
        SetObject(MoveTemp(InObject));
    }
 
    inline explicit FCbPackage(FCbObject InObject, FAttachmentResolver InResolver)
    {
        SetObject(MoveTemp(InObject), InResolver);
    }
 
    inline explicit FCbPackage(FCbObject InObject, const FIoHash& InObjectHash)
    {
        SetObject(MoveTemp(InObject), InObjectHash);
    }
 
    inline explicit FCbPackage(FCbObject InObject, const FIoHash& InObjectHash, FAttachmentResolver InResolver)
    {
        SetObject(MoveTemp(InObject), InObjectHash, InResolver);
    }
 
    inline void Reset() { *this = FCbPackage(); }
 
    inline explicit operator bool() const { return !IsNull(); }
 
    inline bool IsNull() const { return !Object && Attachments.IsEmpty(); }
 
    inline const FCbObject& GetObject() const { return Object; }
 
    inline const FIoHash& GetObjectHash() const { return ObjectHash; }
 
    inline void SetObject(FCbObject InObject)
    {
        SetObject(MoveTemp(InObject), nullptr, nullptr);
    }
 
    inline void SetObject(FCbObject InObject, FAttachmentResolver InResolver)
    {
        SetObject(MoveTemp(InObject), nullptr, &InResolver);
    }
 
    inline void SetObject(FCbObject InObject, const FIoHash& InObjectHash)
    {
        SetObject(MoveTemp(InObject), &InObjectHash, nullptr);
    }
 
    inline void SetObject(FCbObject InObject, const FIoHash& InObjectHash, FAttachmentResolver InResolver)
    {
        SetObject(MoveTemp(InObject), &InObjectHash, &InResolver);
    }
 
    inline TConstArrayView<FCbAttachment> GetAttachments() const { return Attachments; }
 
    CORE_API const FCbAttachment* FindAttachment(const FIoHash& Hash) const;
 
    inline const FCbAttachment* FindAttachment(const FCbAttachment& Attachment) const
    {
        return FindAttachment(Attachment.GetHash());
    }
 
    inline void AddAttachment(const FCbAttachment& Attachment)
    {
        AddAttachment(Attachment, nullptr);
    }
 
    inline void AddAttachment(const FCbAttachment& Attachment, FAttachmentResolver Resolver)
    {
        AddAttachment(Attachment, &Resolver);
    }
 
    CORE_API int32 RemoveAttachment(const FIoHash& Hash);
    inline int32 RemoveAttachment(const FCbAttachment& Attachment) { return RemoveAttachment(Attachment.GetHash()); }
 
    CORE_API bool Equals(const FCbPackage& Package) const;
    inline bool operator==(const FCbPackage& Package) const { return Equals(Package); }
    inline bool operator!=(const FCbPackage& Package) const { return !Equals(Package); }
 
    CORE_API bool TryLoad(FCbFieldIterator& Fields);
 
    CORE_API bool TryLoad(FArchive& Ar, FCbBufferAllocator Allocator = FUniqueBuffer::Alloc);
 
    CORE_API void Save(FCbWriter& Writer) const;
 
    CORE_API void Save(FArchive& Ar) const;
 
private:
    CORE_API void SetObject(FCbObject Object, const FIoHash* Hash, FAttachmentResolver* Resolver);
    CORE_API void AddAttachment(const FCbAttachment& Attachment, FAttachmentResolver* Resolver);
 
    void GatherAttachments(const FCbObject& Object, FAttachmentResolver Resolver);
 
    TArray<FCbAttachment> Attachments;
    FCbObject Object;
    FIoHash ObjectHash;
};
 
 
FCbObject FCbAttachment::AsObject() const
{
    if (const FObjectValue* ObjectValue = Value.TryGet<FObjectValue>())
    {
        return ObjectValue->Object;
    }
    return FCbObject();
}
 
FSharedBuffer FCbAttachment::AsBinary() const
{
    if (const FBinaryValue* BinaryValue = Value.TryGet<FBinaryValue>())
    {
        return BinaryValue->Buffer.ToShared();
    }
    return FSharedBuffer();
}
 
const FCompositeBuffer& FCbAttachment::AsCompositeBinary() const
{
    if (const FBinaryValue* BinaryValue = Value.TryGet<FBinaryValue>())
    {
        return BinaryValue->Buffer;
    }
    return FCompositeBuffer::Null;
}
 
const FCompressedBuffer& FCbAttachment::AsCompressedBinary() const
{
    if (const FCompressedBinaryValue* CompressedBuffer = Value.TryGet<FCompressedBinaryValue>())
    {
        return CompressedBuffer->Buffer;
    }
    return FCompressedBuffer::Null;
}