CookDependency.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if WITH_EDITOR
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "HAL/PreprocessorHelpers.h"
#include "Hash/Blake3.h"
#include "Logging/LogVerbosity.h"
#include "Serialization/CompactBinary.h"
#include "Templates/Function.h"
#include "Templates/UniquePtr.h"
#include "UObject/NameTypes.h"
 
class FCbFieldView;
class FCbWriter;
class UObject;
namespace UE::ConfigAccessTracking { enum class ELoadType : uint8; }
namespace UE::ConfigAccessTracking { struct FConfigAccessData; }
namespace UE::Cook { class FConsoleVariableData; }
namespace UE::Cook { struct FCookDependencyContext; }
struct FARFilter;
#endif
 
#if WITH_EDITOR
 
namespace UE::Cook
{
enum class ECookDependency : uint8
{
    None                    = 0,
    File                    = 1,
    Function                = 2,
    TransitiveBuild         = 3,
    Package                 = 4,
    ConsoleVariable         = 5,
    Config                  = 6,
    SettingsObject          = 7,
    NativeClass             = 8,
    AssetRegistryQuery      = 9,
    RedirectionTarget       = 10,
 
    Count,
};
COREUOBJECT_API const TCHAR* LexToString(ECookDependency CookDependency);
 
namespace ResultProjection
{
extern COREUOBJECT_API FName All;
/*
 * FName passed into FCookDependency::ResultProjection or UE_COOK_RESULTPROJECTION_SCOPED to indicate the bytes
 * within the target package, and the native class used by objects referenced from it, can contribute to the
 * source package's cook. This is more limited than the transitive dependency indicated by BuildProjectionAll
 * because it does not include e.g. other packages that the target package depends on for its cook.
 * This ResultProjection is applied automatically for all hard imports saved into the source cooked package;
 * the SavePackage code applies it because generic LinkerLoad code can cause those imports to be included
 * or excluded from the package based on values of e.g. NeedsLoadForClient.
 */
extern COREUOBJECT_API FName PackageAndClass;
/*
 * FName passed into UE_COOK_RESULTPROJECTION_SCOPED to indicate that dereferences of TObjectPtr within the scope
 * should not be automatically added as dependencies of any kind. The calling code for those scopes either
 * knows that the resolves are spurious or is declaring the proper ResultProjection dependency manually.
 */
extern COREUOBJECT_API FName None;
 
}   
 
namespace BuildResult
{
 
extern COREUOBJECT_API FName NAME_Save;
 
extern COREUOBJECT_API FName NAME_Load;
 
}
 
class FCookDependency
{
public:
    COREUOBJECT_API static FCookDependency File(FStringView InFileName);
    COREUOBJECT_API static FCookDependency Function(FName InFunctionName, FCbFieldIterator&& InArgs);
 
    COREUOBJECT_API static FCookDependency TransitiveBuild(FName PackageName);
    UE_DEPRECATED(5.6, "Add a TransitiveBuild and a Runtime dependency separately.")
    COREUOBJECT_API static FCookDependency TransitiveBuildAndRuntime(FName PackageName);
 
    COREUOBJECT_API static FCookDependency Package(FName PackageName);
 
    COREUOBJECT_API static FCookDependency ConsoleVariable(const FStringView& VariableName);
    COREUOBJECT_API static FCookDependency ConsoleVariable(const FStringView& VariableName, const ITargetPlatform* TargetPlatform, bool bFallbackToNonPlatform);
 
    COREUOBJECT_API static FCookDependency Config(UE::ConfigAccessTracking::FConfigAccessData AccessData);
    COREUOBJECT_API static FCookDependency Config(UE::ConfigAccessTracking::ELoadType LoadType, FName Platform,
        FName FileName, FName SectionName, FName ValueName);
    COREUOBJECT_API static FCookDependency Config(FName FileName, FName SectionName, FName ValueName);
 
    COREUOBJECT_API static FCookDependency SettingsObject(const UObject* InObject);
 
    COREUOBJECT_API static FCookDependency NativeClass(const UClass* InClass);
    COREUOBJECT_API static FCookDependency NativeClass(FStringView ClassPath);
 
    COREUOBJECT_API static FCookDependency RedirectionTarget(FName PackageName);
 
    COREUOBJECT_API static FCookDependency AssetRegistryQuery(FARFilter Filter);
 
    COREUOBJECT_API FCookDependency();
 
    COREUOBJECT_API ~FCookDependency();
    COREUOBJECT_API FCookDependency(const FCookDependency& Other);
    COREUOBJECT_API FCookDependency(FCookDependency&& Other);
    COREUOBJECT_API FCookDependency& operator=(const FCookDependency& Other);
    COREUOBJECT_API FCookDependency& operator=(FCookDependency&& Other);
    
    ECookDependency GetType() const;
 
    COREUOBJECT_API FString GetDebugIdentifier() const;
 
    FStringView GetFileName() const;
 
    FName GetFunctionName() const;
    FCbFieldViewIterator GetFunctionArgs() const;
 
    FName GetPackageName() const;
    UE_DEPRECATED(5.6, "This function is only needed for TransitiveBuildAndRuntime dependencies, which are deprecated.")
    bool IsAlsoAddRuntimeDependency() const;
 
    COREUOBJECT_API UE::ConfigAccessTracking::FConfigAccessData GetConfigAccessData() const;
    COREUOBJECT_API FString GetConfigPath() const;
 
    const UObject* GetSettingsObject() const;
 
    FStringView GetClassPath() const;
 
    const FARFilter* GetARFilter() const;
 
    const uint8* GetRawValue() const;
    const FBlake3Hash& GetHashValue() const;
 
    bool operator<(const FCookDependency& Other) const;
    bool operator==(const FCookDependency& Other) const;
    bool operator!=(const FCookDependency& Other) const;
 
    COREUOBJECT_API void UpdateHash(FCookDependencyContext& Context, FBlake3Hash* OutCurrentValue = nullptr) const;
 
    COREUOBJECT_API void SetValue(const FBlake3Hash& Hash);
    void SetValue(const FIoHash& Hash);
    void SetValue(const FUtf8String& String);
 
    COREUOBJECT_API static FBlake3Hash ConvertToHash(const FIoHash& Hash);
    COREUOBJECT_API static FBlake3Hash ConvertToHash(const FUtf8String& String);
 
    static const uint8 ValueSizeInBytes = 32;
 
private:
    explicit FCookDependency(ECookDependency InType);
    void Construct();
    void Destruct();
    COREUOBJECT_API void Save(FCbWriter& Writer) const;
    COREUOBJECT_API bool Load(FCbFieldView Value);
    static COREUOBJECT_API bool ConfigAccessDataLessThan(const UE::ConfigAccessTracking::FConfigAccessData& A,
        const UE::ConfigAccessTracking::FConfigAccessData& B);
    static COREUOBJECT_API bool ConfigAccessDataEqual(const UE::ConfigAccessTracking::FConfigAccessData& A,
        const UE::ConfigAccessTracking::FConfigAccessData& B);
    static COREUOBJECT_API bool ARFilterLessThan(const FARFilter& A, const FARFilter& B);
    static COREUOBJECT_API bool ARFilterEqual(const FARFilter& A, const FARFilter& B);
 
    COREUOBJECT_API static bool ConsoleVariableDataLessThan(const FConsoleVariableData& A, const FConsoleVariableData& B);
    COREUOBJECT_API static bool ConsoleVariableDataEqual(const FConsoleVariableData& A, const FConsoleVariableData& B);
 
    friend FCbWriter& operator<<(FCbWriter& Writer, const FCookDependency& CookDependency)
    {
        CookDependency.Save(Writer);
        return Writer;
    }
    friend bool LoadFromCompactBinary(FCbFieldView Value, FCookDependency& CookDependency)
    {
        return CookDependency.Load(Value);
    }
 
private:
    ECookDependency Type;
    struct FFunctionData
    {
        FName Name;
        FCbFieldIterator Args;
    };
    struct FTransitiveBuildData
    {
        FName PackageName;
        bool bAlsoAddRuntimeDependency = false;
    };
    union
    {
        FString StringData;
        FFunctionData FunctionData;
        FTransitiveBuildData TransitiveBuildData;
        FName NameData;
        const UObject* ObjectPtr;
        TUniquePtr<UE::ConfigAccessTracking::FConfigAccessData> ConfigAccessData;
        TUniquePtr<FARFilter> ARFilter;
        TUniquePtr<FConsoleVariableData> ConsoleVariableData;
    };
 
    union
    {
        uint8 RawValue[ValueSizeInBytes];
        FBlake3Hash HashedValue;
    };
};
 
using FCookDependencyFunction = void (*)(FCbFieldViewIterator Args, FCookDependencyContext& Context);
 
} // namespace UE::Cook
 
namespace UE::Cook::Dependency::Private
{
 
struct FCookDependencyFunctionRegistration
{
    template<int N>
    FCookDependencyFunctionRegistration(const TCHAR(&InName)[N], FCookDependencyFunction InFunction)
        : Name(InName), Function(InFunction), Next(nullptr)
    {
        static_assert(N > 0, "Name must be provided");
        check(InName[0] != '\0');
        Construct();
    }
    COREUOBJECT_API ~FCookDependencyFunctionRegistration();
    COREUOBJECT_API void Construct();
    FName GetFName();
 
    FLazyName Name;
    FCookDependencyFunction Function;
    FCookDependencyFunctionRegistration* Next;
};
 
} // namespace UE::Cook::Dependency::Private
 
#define UE_COOK_DEPENDENCY_FUNCTION(Name, Function) \
    UE::Cook::Dependency::Private::FCookDependencyFunctionRegistration \
    PREPROCESSOR_JOIN(FCookDependencyFunctionRegistration_,Name)(TEXT(#Name), Function)
#define UE_COOK_DEPENDENCY_FUNCTION_CALL(Name) \
    PREPROCESSOR_JOIN(FCookDependencyFunctionRegistration_,Name).GetFName()
 
#else // WITH_EDITOR
 
#define UE_COOK_RESULTPROJECTION_SCOPED(ProjectionName)
#define UE_COOK_DEPENDENCY_FUNCTION(Name, Function)
#define UE_COOK_DEPENDENCY_FUNCTION_CALL(Name) NAME_None
 
#endif // !WITH_EDITOR
 
#if WITH_EDITOR
namespace UE::Cook
{
inline ECookDependency FCookDependency::GetType() const
{
    return Type;
}
 
inline FStringView FCookDependency::GetFileName() const
{
    return Type == ECookDependency::File ? StringData : FStringView();
}
 
inline FName FCookDependency::GetFunctionName() const
{
    return Type == ECookDependency::Function ? FunctionData.Name : NAME_None;
}
 
inline FCbFieldViewIterator FCookDependency::GetFunctionArgs() const
{
    return Type == ECookDependency::Function ? FunctionData.Args : FCbFieldViewIterator();
}
 
inline FName FCookDependency::GetPackageName() const
{
    PRAGMA_DISABLE_SWITCH_UNHANDLED_ENUM_CASE_WARNINGS;
    switch (GetType())
    {
    case ECookDependency::TransitiveBuild:
        return TransitiveBuildData.PackageName;
    case ECookDependency::Package:
        return NameData;
    case ECookDependency::RedirectionTarget:
        return NameData;
    default:
        return NAME_None;
    };
    PRAGMA_RESTORE_SWITCH_UNHANDLED_ENUM_CASE_WARNINGS;
}
 
inline bool FCookDependency::IsAlsoAddRuntimeDependency() const
{
    PRAGMA_DISABLE_DEPRECATION_WARNINGS;
    return Type == ECookDependency::TransitiveBuild ? TransitiveBuildData.bAlsoAddRuntimeDependency : false;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS;
}
 
inline const UObject* FCookDependency::GetSettingsObject() const
{
    return Type == ECookDependency::SettingsObject ? ObjectPtr : nullptr;
}
 
inline FStringView FCookDependency::GetClassPath() const
{
    return Type == ECookDependency::NativeClass ? StringData : FStringView();
}
 
inline const FARFilter* FCookDependency::GetARFilter() const
{
    return Type == ECookDependency::AssetRegistryQuery ? ARFilter.Get() : nullptr;
}
 
inline const uint8* FCookDependency::GetRawValue() const
{
    return RawValue;
}
 
inline const FBlake3Hash& FCookDependency::GetHashValue() const
{
    return HashedValue;
}
 
inline bool FCookDependency::operator<(const FCookDependency& Other) const
{
    if (static_cast<uint8>(Type) != static_cast<uint8>(Other.Type))
    {
        return static_cast<uint8>(Type) < static_cast<uint8>(Other.Type);
    }
 
    switch (Type)
    {
    case ECookDependency::None:
        return false;
    case ECookDependency::File:
    case ECookDependency::NativeClass:
        return StringData.Compare(Other.StringData, ESearchCase::IgnoreCase) < 0;
 
    case ECookDependency::ConsoleVariable:
    {
        if (ConsoleVariableData.IsValid() != Other.ConsoleVariableData.IsValid())
        {
            return !ConsoleVariableData.IsValid();
        }
 
        if (ConsoleVariableData.IsValid())
        {
            return ConsoleVariableDataLessThan(*ConsoleVariableData, *Other.ConsoleVariableData);
        }
 
        return false; // Both pointers are invalid
    }
 
    case ECookDependency::Function:
    {
        int32 Compare = FunctionData.Name.Compare(Other.FunctionData.Name);
        if (Compare != 0)
        {
            return Compare < 0;
        }
        FMemoryView ViewA;
        FMemoryView ViewB;
        bool bHasViewA = FunctionData.Args.TryGetRangeView(ViewA);
        bool bHasViewB = Other.FunctionData.Args.TryGetRangeView(ViewB);
        if ((!bHasViewA) | (!bHasViewB))
        {
            return bHasViewB; // If both false, return false. If only one, return true only if A is the false.
        }
        return ViewA.CompareBytes(ViewB) < 0;
    }
    case ECookDependency::TransitiveBuild:
    {
        // FName.Compare is lexical and case-insensitive, which is what we want
        int32 Compare = TransitiveBuildData.PackageName.Compare(Other.TransitiveBuildData.PackageName);
        if (Compare != 0)
        {
            return Compare < 0;
        }
        return false;
    }
    case ECookDependency::Package:
        return NameData.Compare(Other.NameData) < 0;
    case ECookDependency::Config:
        if (ConfigAccessData.IsValid() != Other.ConfigAccessData.IsValid())
        {
            return !ConfigAccessData.IsValid();
        }
        if (!ConfigAccessData.IsValid())
        {
            return false; // equal
        }
        return ConfigAccessDataLessThan(*ConfigAccessData, *Other.ConfigAccessData);
    case ECookDependency::SettingsObject:
        // SettingsObjects are not persistable, so we do not use a persistent sort key; just the object ptr.
        return ObjectPtr < Other.ObjectPtr;
    case ECookDependency::AssetRegistryQuery:
        if (ARFilter.IsValid() != Other.ARFilter.IsValid())
        {
            return !ARFilter.IsValid();
        }
        if (!ARFilter.IsValid())
        {
            return false; // equal
        }
        return ARFilterLessThan(*ARFilter, *Other.ARFilter);
    case ECookDependency::RedirectionTarget:
        return NameData.Compare(Other.NameData) < 0;
    case ECookDependency::Count:
    default:
        checkNoEntry();
        return false;
    }
}
 
inline bool FCookDependency::operator==(const FCookDependency& Other) const
{
    if (static_cast<uint8>(Type) != static_cast<uint8>(Other.Type))
    {
        return false;
    }
 
    switch (Type)
    {
    case ECookDependency::None:
        return true;
    case ECookDependency::File:
    case ECookDependency::NativeClass:
        return StringData.Compare(Other.StringData, ESearchCase::IgnoreCase) == 0;
 
    case ECookDependency::ConsoleVariable:
    {
        if (ConsoleVariableData.IsValid() != Other.ConsoleVariableData.IsValid())
        {
            return false;
        }
 
        if (!ConsoleVariableData.IsValid())
        {
            return true;
        }
 
        return ConsoleVariableDataEqual(*ConsoleVariableData, *Other.ConsoleVariableData);
    }
 
    case ECookDependency::Function:
    {
        if (FunctionData.Name.Compare(Other.FunctionData.Name) != 0)
        {
            return false;
        }
        FMemoryView ViewA;
        FMemoryView ViewB;
        bool bHasViewA = FunctionData.Args.TryGetRangeView(ViewA);
        bool bHasViewB = Other.FunctionData.Args.TryGetRangeView(ViewB);
        if (bHasViewA != bHasViewB)
        {
            return false;
        }
        return ViewA.CompareBytes(ViewB) == 0;
    }
    case ECookDependency::TransitiveBuild:
    {
        // FName.Compare is lexical and case-insensitive, which is what we want
        int32 Compare = TransitiveBuildData.PackageName.Compare(Other.TransitiveBuildData.PackageName);
        if (Compare != 0)
        {
            return false;
        }
        return true;
    }
    case ECookDependency::Package:
        return NameData.Compare(Other.NameData) == 0;
    case ECookDependency::Config:
        if (ConfigAccessData.IsValid() != Other.ConfigAccessData.IsValid())
        {
            return false;
        }
        if (!ConfigAccessData.IsValid())
        {
            return true;
        }
        return ConfigAccessDataEqual(*ConfigAccessData, *Other.ConfigAccessData);
    case ECookDependency::SettingsObject:
        // SettingsObjects are not persistable, so we do not use a persistent sort key; just the object ptr.
        return ObjectPtr == Other.ObjectPtr;
    case ECookDependency::AssetRegistryQuery:
    {
        if (ARFilter.IsValid() != Other.ARFilter.IsValid())
        {
            return false;
        }
        if (!ARFilter.IsValid())
        {
            return true;
        }
 
        return ARFilterEqual(*ARFilter, *Other.ARFilter);
    }
    case ECookDependency::RedirectionTarget:
        return NameData.Compare(Other.NameData) == 0;
    case ECookDependency::Count:
    default:
        checkNoEntry();
        return false;
    }
}
 
inline bool FCookDependency::operator!=(const FCookDependency& Other) const
{
    return !(*this == Other);
}
 
inline void FCookDependency::SetValue(const FIoHash& Hash)
{
    SetValue(ConvertToHash(Hash));
}
 
inline void FCookDependency::SetValue(const FUtf8String& String)
{
    SetValue(ConvertToHash(String));
}
 
} // namespace UE::Cook
 
namespace UE::Cook::Dependency::Private
{
 
inline FName FCookDependencyFunctionRegistration::GetFName()
{
    return Name.Resolve();
}
 
} // namespace UE::Cook::Dependency::Private
 
#endif