DependsNode.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Algo/BinarySearch.h"
#include "AssetRegistry/AssetData.h"
#include "AssetRegistry/IAssetRegistry.h"
#include "Containers/BitArray.h"
#include "Misc/AssetRegistryInterface.h"
#include "PropertyCombinationSet.h"
 
struct FDependsNodeReservations;
 
class FDependsNode
{
public:
    typedef TArray<FDependsNode*> FDependsNodeList;
    static constexpr uint32 PackageFlagWidth = 3;
    static constexpr uint32 SearchableNameFlagWidth = 0;
    static constexpr uint32 ManageFlagWidth = 2;
    typedef TPropertyCombinationSet<PackageFlagWidth> FPackageFlagSet;
    static constexpr uint32 PackageFlagSetWidth = FPackageFlagSet::StorageBitCount;
    static constexpr uint32 SearchableNameFlagSetWidth = 0;
    typedef TPropertyCombinationSet<ManageFlagWidth> FManageFlagSet;
    static constexpr uint32 ManageFlagSetWidth = FManageFlagSet::StorageBitCount;
 
public:
    FDependsNode();
    FDependsNode(const FAssetIdentifier& InIdentifier);
 
    void PrintNode() const;
    void PrintDependencies() const;
    void PrintReferencers() const;
    void GetDependencies(TArray<FDependsNode*>& OutDependencies,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
    void GetDependencies(TArray<FAssetIdentifier>& OutDependencies,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
    void GetDependencies(TArray<FAssetDependency>& OutDependencies,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
    void GetReferencers(TArray<FDependsNode*>& OutReferencers,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
    void GetReferencers(TArray<FAssetDependency>& OutReferencers,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
    FName GetPackageName() const;
    const FAssetIdentifier& GetIdentifier() const;
    bool IsScriptPath() const;
    void SetIdentifier(const FAssetIdentifier& InIdentifier);
    void AddDependency(FDependsNode* InDependency,
        UE::AssetRegistry::EDependencyCategory InDependencyType, UE::AssetRegistry::EDependencyProperty InProperties);
    void GetPackageReferencers(TArray<TPair<FAssetIdentifier, FPackageFlagSet>>& OutReferencers);
    void AddPackageDependencySet(FDependsNode* InDependency, const FPackageFlagSet& PropertyCombinationSet);
    void AddReferencer(FDependsNode* InReferencer);
    void RemoveDependency(FDependsNode* InDependency,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All);
    void RemoveReferencer(FDependsNode* InReferencer);
    void RemoveReferencers(const TSet<FDependsNode*>& InReferencers);
    void RefreshReferencers();
    bool ContainsDependency(const FDependsNode* InDependency,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
    void ClearDependencies(UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All);
    void ClearReferencers();
    void RemoveManageReferencesToNode();
    void RemoveLinks(const TUniqueFunction<bool(const FDependsNode*)>& ShouldRemove);
    int32 GetConnectionCount() const;
    SIZE_T GetAllocatedSize(void) const;
 
    typedef TUniqueFunction<void(
        FDependsNode* Dependency,
        UE::AssetRegistry::EDependencyCategory Category,
        UE::AssetRegistry::EDependencyProperty Properties,
        bool bDuplicate
        )> FIterateDependenciesCallback;
    void IterateOverDependencies(const FIterateDependenciesCallback& InCallback,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
    void IterateOverDependencies(const FIterateDependenciesCallback& InCallback,
        const FDependsNode* DependsNode,
        UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All,
        const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const;
 
    template <class T>
    void IterateOverReferencers(const T& InCallback) const;
 
    void Reserve(int32 InNumPackageDependencies, int32 InNumNameDependencies,
        int32 InNumManageDependencies, int32 InNumReferencers);
    void Reserve(const FDependsNodeReservations& InReservations);
    void Reserve(const FDependsNode* Other);
 
    bool GetAllowShrinking() const;
    void SetAllowShrinking(bool bAllowShrinking);
 
    static uint8 PackagePropertiesToByte(UE::AssetRegistry::EDependencyProperty Properties);
    static UE::AssetRegistry::EDependencyProperty ByteToPackageProperties(uint8 Bits);
    static uint8 ManagePropertiesToByte(UE::AssetRegistry::EDependencyProperty Properties);
    static UE::AssetRegistry::EDependencyProperty ByteToManageProperties(uint8 Bits);
 
    struct FSaveScratch
    {
        struct FSortInfo
        {
            int32 SerializeIndex;
            int32 ListIndex;
        };
        TArray<FSortInfo> SortInfos;
        TArray<int32> OutDependencies;
        TBitArray<> OutFlagBits;
    };
    void SerializeSave(FArchive& Ar, const TUniqueFunction<int32(FDependsNode*, bool)>& GetSerializeIndexFromNode,
        FSaveScratch& Scratch, const FAssetRegistrySerializationOptions& Options) const;
    struct FLoadScratch
    {
        TArray<int32> InDependencies;
        TArray<uint32> InFlagBits;
        TArray<FDependsNode*> PointerDependencies;
        TArray<int32> SortIndexes;
    };
    template <bool bLatestVersion>
    void SerializeLoad(FArchive& Ar,
        const TUniqueFunction<FDependsNode* (int32)>& GetNodeFromSerializeIndex,
        FLoadScratch& Scratch, FAssetRegistryVersion::Type Version);
 
    void LegacySerializeLoad_BeforeFlags(FArchive& Ar, FAssetRegistryVersion::Type Version,
        FDependsNode* PreallocatedDependsNodeDataBuffer, int32 NumDependsNodes, bool bSerializeDependencies);
 
    bool IsDependencyListSorted(UE::AssetRegistry::EDependencyCategory Category) const;
    void SetIsDependencyListSorted(UE::AssetRegistry::EDependencyCategory Category, bool bValue);
    bool IsReferencersSorted() const;
    void SetIsReferencersSorted(bool bValue);
    bool IsScriptDependenciesInitialized() const;
    void SetIsScriptDependenciesInitialized(bool bValue);
 
private:
 
    void PrintDependenciesRecursive(const FString& Indent, TSet<const FDependsNode*>& VisitedNodes) const;
    void PrintReferencersRecursive(const FString& Indent, TSet<const FDependsNode*>& VisitedNodes) const;
 
    void ConstructFlags();
 
    template <bool bLatestVersion>
    void SerializeLoad_PackageDependencies(FArchive& Ar,
        const TUniqueFunction<FDependsNode* (int32)>& GetNodeFromSerializeIndex,
        FLoadScratch& Scratch, FAssetRegistryVersion::Type Version);
    template <bool bLatestVersion>
    void SerializeLoad_NameDependencies(FArchive& Ar,
        const TUniqueFunction<FDependsNode* (int32)>& GetNodeFromSerializeIndex,
        FLoadScratch& Scratch, FAssetRegistryVersion::Type Version);
    template <bool bLatestVersion>
    void SerializeLoad_ManageDependencies(FArchive& Ar,
        const TUniqueFunction<FDependsNode* (int32)>& GetNodeFromSerializeIndex,
        FLoadScratch& Scratch, FAssetRegistryVersion::Type Version);
    template <bool bLatestVersion>
    void SerializeLoad_Referencers(FArchive& Ar,
        const TUniqueFunction<FDependsNode* (int32)>& GetNodeFromSerializeIndex,
        FLoadScratch& Scratch, FAssetRegistryVersion::Type Version);
 
    FAssetIdentifier Identifier;
    FDependsNodeList PackageDependencies;
    FDependsNodeList NameDependencies;
    FDependsNodeList ManageDependencies;
    FDependsNodeList Referencers;
    TBitArray<> PackageFlags;
    TBitArray<> ManageFlags;
 
    // Transient flags that are not serialized
    uint32 PackageIsSorted : 1;
    uint32 SearchableNameIsSorted : 1;
    uint32 ManageIsSorted : 1;
    uint32 ReferencersIsSorted : 1;
    uint32 DependenciesInitialized : 1;
    uint32 bScriptPath : 1;
    uint32 bAllowShrinking : 1;
 
    friend FDependsNodeReservations;
};
 
struct FDependsNodeReservations
{
    int32 PackageDependenciesSize = 0;
    int32 NameDependenciesSize = 0;
    int32 ManageDependenciesSize = 0;
    int32 ReferencersSize = 0;
    
    FDependsNodeReservations() = default;
    FDependsNodeReservations(const FDependsNode& Node)
    {
        PackageDependenciesSize = Node.PackageDependencies.Num();
        NameDependenciesSize = Node.NameDependencies.Num();
        ManageDependenciesSize = Node.ManageDependencies.Num();
        ReferencersSize = Node.Referencers.Num();
    }
 
    friend FArchive& operator<<(FArchive& Ar, FDependsNodeReservations& Reservations)
    {
        Ar << Reservations.PackageDependenciesSize << Reservations.NameDependenciesSize << Reservations.ManageDependenciesSize << Reservations.ReferencersSize;
        return Ar;
    }
};
 
// Inline implementations
 
inline FDependsNode::FDependsNode()
{
    ConstructFlags();
}
 
inline FDependsNode::FDependsNode(const FAssetIdentifier& InIdentifier)
{
    ConstructFlags();
    SetIdentifier(InIdentifier);
}
 
inline FName FDependsNode::GetPackageName() const
{
    return Identifier.PackageName;
}
 
inline const FAssetIdentifier& FDependsNode::GetIdentifier() const
{
    return Identifier;
}
 
inline bool FDependsNode::IsScriptPath() const
{
    return bScriptPath != 0;
}
 
inline SIZE_T FDependsNode::GetAllocatedSize(void) const
{
    return PackageDependencies.GetAllocatedSize() + PackageFlags.GetAllocatedSize()
        + NameDependencies.GetAllocatedSize() + ManageDependencies.GetAllocatedSize() + ManageFlags.GetAllocatedSize()
        + Referencers.GetAllocatedSize();
}
 
template <class T>
inline void FDependsNode::IterateOverReferencers(const T& InCallback) const
{
    for (FDependsNode* Referencer : Referencers)
    {
        InCallback(Referencer);
    }
}
 
inline void FDependsNode::Reserve(int32 InNumPackageDependencies, int32 InNumNameDependencies,
    int32 InNumManageDependencies, int32 InNumReferencers)
{
    PackageDependencies.Reserve(InNumPackageDependencies);
    PackageFlags.Reserve(InNumPackageDependencies * PackageFlagSetWidth);
    NameDependencies.Reserve(InNumNameDependencies);
    ManageDependencies.Reserve(InNumManageDependencies);
    ManageFlags.Reserve(InNumManageDependencies * ManageFlagSetWidth);
    Referencers.Reserve(InNumReferencers);
}
 
inline void FDependsNode::Reserve(const FDependsNodeReservations& InReservations)
{
    Reserve(InReservations.PackageDependenciesSize, InReservations.NameDependenciesSize,
        InReservations.ManageDependenciesSize, InReservations.ReferencersSize);
}
 
inline void FDependsNode::Reserve(const FDependsNode* Other)
{
    Reserve(Other->PackageDependencies.Num(), Other->NameDependencies.Num(),
        Other->ManageDependencies.Num(), Other->Referencers.Num());
}
 
inline bool FDependsNode::GetAllowShrinking() const
{
    return bAllowShrinking;
}
 
inline void FDependsNode::SetAllowShrinking(bool InAllowShrinking)
{
    bAllowShrinking = InAllowShrinking;
}
 
inline uint8 FDependsNode::PackagePropertiesToByte(UE::AssetRegistry::EDependencyProperty Properties)
{
    return (0x01 * (static_cast<uint8>(Properties & UE::AssetRegistry::EDependencyProperty::Hard) != 0))
        | (0x02 * (static_cast<uint8>(Properties & UE::AssetRegistry::EDependencyProperty::Game) != 0))
        | (0x04 * (static_cast<uint8>(Properties & UE::AssetRegistry::EDependencyProperty::Build) != 0));
}
 
inline UE::AssetRegistry::EDependencyProperty FDependsNode::ByteToPackageProperties(uint8 Bits)
{
    return static_cast<UE::AssetRegistry::EDependencyProperty>(
        (static_cast<uint32>(UE::AssetRegistry::EDependencyProperty::Hard) * ((Bits & 0x01) != 0))
        | (static_cast<uint32>(UE::AssetRegistry::EDependencyProperty::Game) * ((Bits & 0x02) != 0))
        | (static_cast<uint32>(UE::AssetRegistry::EDependencyProperty::Build) * ((Bits & 0x04) != 0))
        );
}
inline uint8 FDependsNode::ManagePropertiesToByte(UE::AssetRegistry::EDependencyProperty Properties)
{
    return (0x01 * (static_cast<uint8>(Properties & UE::AssetRegistry::EDependencyProperty::Direct) != 0))
        | (0x02 * (static_cast<uint8>(Properties & UE::AssetRegistry::EDependencyProperty::CookRule) != 0));
}
 
inline UE::AssetRegistry::EDependencyProperty FDependsNode::ByteToManageProperties(uint8 Bits)
{
    return static_cast<UE::AssetRegistry::EDependencyProperty>(
        (static_cast<uint32>(UE::AssetRegistry::EDependencyProperty::Direct) * ((Bits & 0x01) != 0))
        | (static_cast<uint32>(UE::AssetRegistry::EDependencyProperty::CookRule) * ((Bits & 0x02) != 0))
        );
}
 
inline void FDependsNode::ConstructFlags()
{
    PackageIsSorted = 1;
    SearchableNameIsSorted = 1;
    ManageIsSorted = 1;
    ReferencersIsSorted = 1;
    DependenciesInitialized = 0;
    bScriptPath = 0;
}