ImportExportCollector.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
 
#if WITH_EDITORONLY_DATA
#include "Containers/Map.h"
#include "Containers/RingBuffer.h"
#include "Containers/Set.h"
#include "Serialization/ArchiveUObject.h"
#include "UObject/Package.h"
#include "UObject/NameTypes.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/UObjectGlobals.h"
 
class FImportExportCollector : public FArchiveUObject
{
public:
    COREUOBJECT_API explicit FImportExportCollector(UPackage* InRootPackage);
 
    COREUOBJECT_API void AddExportToIgnore(UObject* Export);
    COREUOBJECT_API void SerializeObjectAndReferencedExports(UObject* RootObject);
    COREUOBJECT_API void Reset();
    TArray<UObject*> GetExports() const;
    const TMap<FSoftObjectPath, ESoftObjectPathCollectType>& GetImports() const;
    const TMap<FName, ESoftObjectPathCollectType>& GetImportedPackages() const;
    void SetCallbackIsEditorOnlyObjectAllowed(TFunction<bool(const UObject*)> InCallback);
 
    COREUOBJECT_API virtual FArchive& operator<<(UObject*& Obj) override;
    COREUOBJECT_API virtual FArchive& operator<<(FSoftObjectPath& Value) override;
 
private:
    void AddImport(const FSoftObjectPath& Path, ESoftObjectPathCollectType CollectType);
    ESoftObjectPathCollectType Union(ESoftObjectPathCollectType A, ESoftObjectPathCollectType B);
    bool CachedIsEditorOnlyObject(const UObject* Object);
 
    enum class EVisitResult
    {
        Uninitialized,
        Excluded,
        Import,
        Export,
    };
    TMap<UObject*, EVisitResult> Visited;
    TRingBuffer<UObject*> ExportsExploreQueue;
    TMap<FSoftObjectPath, ESoftObjectPathCollectType> Imports;
    TMap<FName, ESoftObjectPathCollectType> ImportedPackages;
    TMap<const UObject*, UE::SavePackageUtilities::EEditorOnlyObjectResult> EditorOnlyObjectCache;
    TFunction<bool(const UObject*)> CallbackIsEditorOnlyObjectAllowed;
    UPackage* RootPackage;
    FName RootPackageName;
};
 
// Inline implementations
 
inline TArray<UObject*> FImportExportCollector::GetExports() const
{
    TArray<UObject*> Exports;
    for (const TPair<UObject*, EVisitResult>& Pair : Visited)
    {
        if (Pair.Value == EVisitResult::Export)
        {
            Exports.Add(Pair.Key);
        }
    }
    return Exports;
}
 
inline const TMap<FSoftObjectPath, ESoftObjectPathCollectType>& FImportExportCollector::GetImports() const
{
    return Imports;
}
 
inline const TMap<FName, ESoftObjectPathCollectType>& FImportExportCollector::GetImportedPackages() const
{
    return ImportedPackages;
}
 
inline void FImportExportCollector::SetCallbackIsEditorOnlyObjectAllowed(TFunction<bool(const UObject*)> InCallback)
{
    CallbackIsEditorOnlyObjectAllowed = MoveTemp(InCallback);
}
 
#endif // WITH_EDITORONLY_DATA