PackageResourceManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Map.h"
#include "Containers/StringFwd.h"
#include "Containers/StringView.h"
#include "Delegates/Delegate.h"
#include "Features/IModularFeature.h"
#include "HAL/CriticalSection.h"
#include "HAL/Platform.h"
#include "HAL/PlatformFile.h"
#include "Logging/LogMacros.h"
#include "Misc/PackageName.h"
#include "Misc/PackagePath.h"
#include "Misc/PackageSegment.h"
#include "Modules/ModuleInterface.h"
#include "Serialization/Archive.h"
#include "Serialization/BulkDataCookedIndex.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
#include "Templates/UniquePtr.h"
 
class FArchive;
class FName;
class FPreloadableArchive;
class IAsyncReadFileHandle;
class IAsyncReadRequest;
class IMappedFileHandle;
class IPackageResourceManager;
class UPackage;
struct FFileStatData;
 
DECLARE_LOG_CATEGORY_EXTERN(LogPackageResourceManager, Log, All);
DECLARE_DELEGATE_RetVal(IPackageResourceManager*, FSetPackageResourceManager);
DECLARE_MULTICAST_DELEGATE(FOnClearPackageResourceManager);
 
enum class EPackageFormat : uint8
{
    Binary, // Standard UnrealFormat, every field marshalled to bytes with Serialize(void*,int)
    Text, // Text format, use FJsonArchiveInputFormatter
};
COREUOBJECT_API EPackageFormat ExtensionToPackageFormat(EPackageExtension Extension);
 
struct FOpenPackageResult
{
    TUniquePtr<FArchive> Archive;
    EPackageFormat Format = EPackageFormat::Binary;
    bool bNeedsEngineVersionChecks = true;
 
    void CopyMetaData(const FOpenPackageResult& Other)
    {
        Format = Other.Format;
        bNeedsEngineVersionChecks = Other.bNeedsEngineVersionChecks;
    }
};
 
struct FOpenAsyncPackageResult
{
    TUniquePtr<IAsyncReadFileHandle> Handle;
    EPackageFormat Format = EPackageFormat::Binary;
    bool bNeedsEngineVersionChecks = true;
 
    FOpenAsyncPackageResult() = default;
    FOpenAsyncPackageResult(const FOpenAsyncPackageResult&) = delete;
    FOpenAsyncPackageResult(FOpenAsyncPackageResult&&) = default;
    FOpenAsyncPackageResult& operator=(const FOpenAsyncPackageResult&) = delete;
    FOpenAsyncPackageResult& operator=(FOpenAsyncPackageResult&&) = default;
 
    COREUOBJECT_API FOpenAsyncPackageResult(TUniquePtr<IAsyncReadFileHandle>&& InHandle, EPackageFormat InFormat, bool bInNeedsEngineVersionChecks = true);
    COREUOBJECT_API ~FOpenAsyncPackageResult();
 
    void CopyMetaData(const FOpenPackageResult& Other)
    {
        Format = Other.Format;
        bNeedsEngineVersionChecks = Other.bNeedsEngineVersionChecks;
    }
};
 
enum class EPackageExternalResource
{
    WorkspaceDomainFile,
};
 
class IPackageResourceManager
{
public:
    // Public API
 
    COREUOBJECT_API static IPackageResourceManager& Get();
    virtual ~IPackageResourceManager() = default;
 
    virtual bool SupportsLocalOnlyPaths() = 0;
 
    virtual bool SupportsPackageOnlyPaths() = 0;
 
    COREUOBJECT_API bool DoesPackageExist(const FPackagePath& PackagePath, FPackagePath* OutUpdatedPath = nullptr);
 
    COREUOBJECT_API int64 FileSize(const FPackagePath& PackagePath, FPackagePath* OutUpdatedPath = nullptr);
 
    COREUOBJECT_API FOpenPackageResult OpenReadPackage(const FPackagePath& PackagePath, FPackagePath* OutUpdatedPath = nullptr);
 
    COREUOBJECT_API FOpenAsyncPackageResult OpenAsyncReadPackage(const FPackagePath& PackagePath);
 
    COREUOBJECT_API IMappedFileHandle* OpenMappedHandleToPackage(const FPackagePath& PackagePath, FPackagePath* OutUpdatedPath = nullptr);
 
    virtual bool TryMatchCaseOnDisk(const FPackagePath& PackagePath, FPackagePath* OutNormalizedPath = nullptr) = 0;
 
    virtual TUniquePtr<FArchive> OpenReadExternalResource(EPackageExternalResource ResourceType, FStringView Identifier) = 0;
 
    virtual FOpenAsyncPackageResult OpenAsyncReadExternalResource(
        EPackageExternalResource ResourceType, FStringView Identifier) = 0;
 
    virtual bool DoesExternalResourceExist(EPackageExternalResource ResourceType, FStringView Identifier) = 0;
 
    COREUOBJECT_API void FindPackagesRecursive(TArray<FPackagePath>& OutPackages, FStringView PackageMount,
        FStringView FileMount, FStringView RootRelPath, FStringView BasenameWildcard);
 
    typedef TFunctionRef<bool(const FPackagePath& PackagePath)> FPackagePathVisitor;
    typedef TFunctionRef<bool(const FPackagePath& PackagePath, const FFileStatData& StatData)> FPackagePathStatVisitor;
 
    COREUOBJECT_API void IteratePackagesInPath(FStringView PackageMount, FStringView FileMount, FStringView RootRelPath,
        FPackagePathVisitor Callback);
    
    COREUOBJECT_API void IteratePackagesInLocalOnlyDirectory(FStringView RootDir, FPackagePathVisitor Callback);
 
    COREUOBJECT_API void IteratePackagesStatInPath(FStringView PackageMount, FStringView FileMount, FStringView RootRelPath,
        FPackagePathStatVisitor Callback);
 
    COREUOBJECT_API void IteratePackagesStatInLocalOnlyDirectory(FStringView RootDir, FPackagePathStatVisitor Callback);
 
    COREUOBJECT_API static void Initialize();
 
    COREUOBJECT_API static void Shutdown();
 
    COREUOBJECT_API static FSetPackageResourceManager& GetSetPackageResourceManagerDelegate();
    COREUOBJECT_API static FOnClearPackageResourceManager& GetOnClearPackageResourceManagerDelegate();
 
public:
    // Internal API used by low-level PackageResourceManager users
    UE_DEPRECATED(5.5, "Use the overload that takes a FBulkDataCookedIndex")
    bool DoesPackageExist(const FPackagePath& PackagePath, EPackageSegment PackageSegment,
        FPackagePath* OutUpdatedPath = nullptr)
    {
        return DoesPackageExist(PackagePath, FBulkDataCookedIndex::Default, PackageSegment, OutUpdatedPath);
    }
 
    virtual bool DoesPackageExist(const FPackagePath& PackagePath, FBulkDataCookedIndex CookedIndex,
        EPackageSegment PackageSegment, FPackagePath* OutUpdatedPath = nullptr) = 0;
 
    UE_DEPRECATED(5.5, "Use the overload that takes a FBulkDataCookedIndex")
    int64 FileSize(const FPackagePath& PackagePath, EPackageSegment PackageSegment,
        FPackagePath* OutUpdatedPath = nullptr)
    {
        return FileSize(PackagePath, FBulkDataCookedIndex::Default, PackageSegment, OutUpdatedPath);
    }
 
    virtual int64 FileSize(const FPackagePath& PackagePath, FBulkDataCookedIndex CookedIndex,
        EPackageSegment PackageSegment, FPackagePath* OutUpdatedPath = nullptr) = 0;
 
    UE_DEPRECATED(5.5, "Use the overload that takes a FBulkDataCookedIndex")
    FOpenPackageResult OpenReadPackage(const FPackagePath& PackagePath, EPackageSegment PackageSegment,
        FPackagePath* OutUpdatedPath = nullptr)
    {
        return OpenReadPackage(PackagePath, FBulkDataCookedIndex::Default, PackageSegment, OutUpdatedPath);
    }
 
    virtual FOpenPackageResult OpenReadPackage(const FPackagePath& PackagePath, FBulkDataCookedIndex CookedIndex,
        EPackageSegment PackageSegment, FPackagePath* OutUpdatedPath = nullptr) = 0;
 
    UE_DEPRECATED(5.5, "Use the overload that takes a FBulkDataCookedIndex")
    FOpenAsyncPackageResult OpenAsyncReadPackage(const FPackagePath& PackagePath, EPackageSegment PackageSegment)
    {
        return OpenAsyncReadPackage(PackagePath, FBulkDataCookedIndex::Default, PackageSegment);
    }
 
    virtual FOpenAsyncPackageResult OpenAsyncReadPackage(const FPackagePath& PackagePath, FBulkDataCookedIndex CookedIndex, EPackageSegment PackageSegment) = 0;
 
    /* OpenMappedHandleToPackage that takes a PackageSegment */
    virtual IMappedFileHandle* OpenMappedHandleToPackage(const FPackagePath& PackagePath, EPackageSegment PackageSegment,
        FPackagePath* OutUpdatedPath = nullptr) = 0;
 
    virtual void FindPackagesRecursive(TArray<TPair<FPackagePath, EPackageSegment>>& OutPackages, FStringView PackageMount,
        FStringView FileMount, FStringView RootRelPath, FStringView BasenameWildcard) = 0;
 
    typedef TFunctionRef<bool(const FPackagePath& PackagePath, EPackageSegment PackageSegment)> FPackageSegmentVisitor;
    typedef TFunctionRef<bool(const FPackagePath& PackagePath, EPackageSegment PackageSegment, const FFileStatData& StatData)> FPackageSegmentStatVisitor;
 
    virtual void IteratePackagesInPath(FStringView PackageMount, FStringView FileMount, FStringView RootRelPath,
        FPackageSegmentVisitor Callback) = 0;
 
    virtual void IteratePackagesInLocalOnlyDirectory(FStringView RootDir, FPackageSegmentVisitor Callback) = 0;
 
    virtual void IteratePackagesStatInPath(FStringView PackageMount, FStringView FileMount, FStringView RootRelPath,
        FPackageSegmentStatVisitor Callback) = 0;
 
    virtual void IteratePackagesStatInLocalOnlyDirectory(FStringView RootDir, FPackageSegmentStatVisitor Callback) = 0;
 
 
    // Preloading Package Archives
#if WITH_EDITOR
    COREUOBJECT_API static bool TryRegisterPreloadableArchive(const FPackagePath& PackagePath,
        const TSharedPtr<FPreloadableArchive>& PreloadableArchive, const FOpenPackageResult& PackageFormat);
 
    COREUOBJECT_API static bool TryTakePreloadableArchive(const FPackagePath& PackagePath, FOpenPackageResult& OutResult);
    
    COREUOBJECT_API static bool UnRegisterPreloadableArchive(const FPackagePath& PackagePath);
 
private:
    static TMap<FName, TPair<TSharedPtr<FPreloadableArchive>, FOpenPackageResult>> PreloadedPaths;
    static FCriticalSection PreloadedPathsLock;
#endif
};
 
#if WITH_EDITOR
enum class EEditorDomainEnabled : uint8
{
    Disabled,
    Utilities,
    PackageResourceManager,
};
COREUOBJECT_API EEditorDomainEnabled IsEditorDomainEnabled();
#endif