StructuredArchive.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "CoreTypes.h"
#include "Formatters/BinaryArchiveFormatter.h"
#include "Misc/Build.h"
#include "Serialization/Archive.h"
#include "Serialization/StructuredArchiveAdapters.h"
#include "Serialization/StructuredArchiveDefines.h"
#include "Serialization/StructuredArchiveFormatter.h"
#include "Serialization/StructuredArchiveFwd.h"
#include "Serialization/StructuredArchiveNameHelpers.h"
#include "Serialization/StructuredArchiveSlotBase.h"
#include "Serialization/StructuredArchiveSlots.h"
#include "Templates/UniqueObj.h"
 
#if !WITH_TEXT_ARCHIVE_SUPPORT
    #define UE_API FORCEINLINE
#else
    #define UE_API CORE_API
#endif
 
class FStructuredArchive;
 
namespace UE::StructuredArchive::Private
{
    enum class EElementType : unsigned char
    {
        Root,
        Record,
        Array,
        Stream,
        Map,
        AttributedValue,
    };
 
    enum class EEnteringAttributeState
    {
        NotEnteringAttribute,
        EnteringAttribute,
    };
 
    FElementId GetCurrentSlotElementIdImpl(FStructuredArchive& Ar);
    FArchiveFormatterType& GetFormatterImpl(FStructuredArchive& Ar);
    }
 
class FStructuredArchive
{
    friend FStructuredArchiveSlot;
    friend FStructuredArchiveRecord;
    friend FStructuredArchiveArray;
    friend FStructuredArchiveStream;
    friend FStructuredArchiveMap;
 
public:
    using FSlot   = FStructuredArchiveSlot;
    using FRecord = FStructuredArchiveRecord;
    using FArray  = FStructuredArchiveArray;
    using FStream = FStructuredArchiveStream;
    using FMap    = FStructuredArchiveMap;
 
    UE_API explicit FStructuredArchive(FArchiveFormatterType& InFormatter);
    
    UE_API ~FStructuredArchive();
 
    UE_API FStructuredArchiveSlot Open();
 
    UE_API void Close();
 
    UE_FORCEINLINE_HINT FArchive& GetUnderlyingArchive() const
    {
        return Formatter.GetUnderlyingArchive();
    }
 
    UE_FORCEINLINE_HINT const FArchiveState& GetArchiveState() const
    {
        return GetUnderlyingArchive().GetArchiveState();
    }
 
    FStructuredArchive(const FStructuredArchive&) = delete;
    FStructuredArchive& operator=(const FStructuredArchive&) = delete;
 
private:
    friend class FStructuredArchiveChildReader;
    friend UE::StructuredArchive::Private::FElementId UE::StructuredArchive::Private::GetCurrentSlotElementIdImpl(FStructuredArchive& Ar);
    friend FArchiveFormatterType& UE::StructuredArchive::Private::GetFormatterImpl(FStructuredArchive& Ar);
 
    FArchiveFormatterType& Formatter;
 
#if WITH_TEXT_ARCHIVE_SUPPORT
    const bool bRequiresStructuralMetadata;
 
    struct FElement
    {
        UE::StructuredArchive::Private::FElementId Id;
        UE::StructuredArchive::Private::EElementType Type;
 
        FElement(UE::StructuredArchive::Private::FElementId InId, UE::StructuredArchive::Private::EElementType InType)
            : Id(InId)
            , Type(InType)
        {
        }
    };
 
    struct FIdGenerator
    {
        UE::StructuredArchive::Private::FElementId Generate()
        {
            return UE::StructuredArchive::Private::FElementId(NextId++);
        }
 
    private:
        uint32 NextId = 1;
    };
 
    FIdGenerator ElementIdGenerator;
 
    UE::StructuredArchive::Private::FElementId RootElementId;
 
    UE::StructuredArchive::Private::FElementId CurrentSlotElementId;
 
    TArray<FElement, TNonRelocatableInlineAllocator<32>> CurrentScope;
 
#if DO_STRUCTURED_ARCHIVE_CONTAINER_CHECKS
    struct FContainer;
 
    TArray<TUniqueObj<FContainer>> CurrentContainer;
#endif
 
    UE::StructuredArchive::Private::EEnteringAttributeState CurrentEnteringAttributeState = UE::StructuredArchive::Private::EEnteringAttributeState::NotEnteringAttribute;
 
    CORE_API void EnterSlot(UE::StructuredArchive::Private::FSlotPosition Slot, bool bEnteringAttributedValue = false);
 
    CORE_API int32 EnterSlotAsType(UE::StructuredArchive::Private::FSlotPosition Slot, UE::StructuredArchive::Private::EElementType ElementType);
 
    CORE_API void LeaveSlot();
 
    CORE_API void SetScope(UE::StructuredArchive::Private::FSlotPosition Slot);
#endif
};
 
#if !WITH_TEXT_ARCHIVE_SUPPORT
 
    UE_FORCEINLINE_HINT FStructuredArchive::FStructuredArchive(FArchiveFormatterType& InFormatter)
        : Formatter(InFormatter)
    {
    }
 
    UE_FORCEINLINE_HINT FStructuredArchive::~FStructuredArchive()
    {
    }
 
    UE_FORCEINLINE_HINT FStructuredArchiveSlot FStructuredArchive::Open()
    {
        return FStructuredArchiveSlot(FStructuredArchiveSlot::EPrivateToken{}, *this);
    }
 
    UE_FORCEINLINE_HINT void FStructuredArchive::Close()
    {
    }
 
#endif
 
namespace UE::StructuredArchive::Private
{
    UE_FORCEINLINE_HINT FArchive& GetUnderlyingArchiveImpl(FStructuredArchive& StructuredArchive)
    {
        return StructuredArchive.GetUnderlyingArchive();
    }
 
    UE_FORCEINLINE_HINT FArchiveState& GetUnderlyingArchiveStateImpl(FStructuredArchive& StructuredArchive)
    {
        return StructuredArchive.GetUnderlyingArchive().GetArchiveState();
    }
 
#if WITH_TEXT_ARCHIVE_SUPPORT
    UE_FORCEINLINE_HINT FElementId GetCurrentSlotElementIdImpl(FStructuredArchive& StructuredArchive)
    {
        return StructuredArchive.CurrentSlotElementId;
    }
#endif
 
    UE_FORCEINLINE_HINT FArchiveFormatterType& GetFormatterImpl(FStructuredArchive& StructuredArchive)
    {
        return StructuredArchive.Formatter;
    }
}
 
#undef UE_API