InterchangeBaseNodeContainer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/Platform.h"
#include "Misc/FileHelper.h"
#include "Nodes/InterchangeFactoryBaseNode.h"
#include "Templates/Casts.h"
#include "Templates/Function.h"
#include "Templates/UniquePtr.h"
#include "UObject/Class.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
 
#include "InterchangeBaseNodeContainer.generated.h"
 
class FArchive;
class UClass;
class UInterchangeBaseNode;
class UInterchangeFactoryBaseNode;
struct FFrame;
template <typename T> struct TObjectPtr;
 
 
 UCLASS(BlueprintType, MinimalAPI)
class UInterchangeBaseNodeContainer : public UObject
{
    GENERATED_BODY()
public:
    INTERCHANGECORE_API UInterchangeBaseNodeContainer();
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    void Reset()
    {
        Nodes.Reset();
        ChildrenCache.Reset();
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    void RemoveNode(const FString& NodeUniqueID)
    {
        Nodes.Remove(NodeUniqueID);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API FString AddNode(UInterchangeBaseNode* Node);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API void ReplaceNode(const FString& NodeUniqueID, UInterchangeFactoryBaseNode* NewNode);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API bool IsNodeUidValid(const FString& NodeUniqueID) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API void SetNamespace(const FString& Namespace, UClass* TargetClass);
 
    INTERCHANGECORE_API void IterateNodes(TFunctionRef<void(const FString&, UInterchangeBaseNode*)> IterationLambda) const;
 
    template <typename T>
    void IterateNodesOfType(TFunctionRef<void(const FString&, T*)> IterationLambda) const
    {
        for (const TPair<FString, TObjectPtr<UInterchangeBaseNode>>& NodeKeyValue : Nodes)
        {
            if (T* Node = Cast<T>(NodeKeyValue.Value))
            {
                IterationLambda(NodeKeyValue.Key, Node);
            }
        }
    }
 
    template <typename T>
    void GetNodeUIDsOfType(TArray<FString>& OutNodeUIDs) const
    {
        for (const TPair<FString, TObjectPtr<UInterchangeBaseNode>>& NodeKeyValue : Nodes)
        {
            if (T* Node = Cast<T>(NodeKeyValue.Value))
            {
                OutNodeUIDs.Add(NodeKeyValue.Key);
            }
        }
    }
 
    void IterateNodeChildren(const FString& NodeUniqueID, TFunctionRef<void(const UInterchangeBaseNode*)> IterationLambda) const
    {
 
        if (const UInterchangeBaseNode* Node = GetNode(NodeUniqueID))
        {
            IterationLambda(Node);
            const TArray<FString> ChildrenIds = GetNodeChildrenUids(NodeUniqueID);
            for (int32 ChildIndex = 0; ChildIndex < ChildrenIds.Num(); ++ChildIndex)
            {
                IterateNodeChildren(ChildrenIds[ChildIndex], IterationLambda);
            }
        }
    }
 
    bool BreakableIterateNodeChildren(const FString& NodeUniqueID, TFunctionRef<bool(const UInterchangeBaseNode*)> IterationLambda) const
    {
        if (const UInterchangeBaseNode* Node = GetNode(NodeUniqueID))
        {
            if (IterationLambda(Node))
            {
                return true;
            }
            const TArray<FString> ChildrenIds = GetNodeChildrenUids(NodeUniqueID);
            for (int32 ChildIndex = 0; ChildIndex < ChildrenIds.Num(); ++ChildIndex)
            {
                if (BreakableIterateNodeChildren(ChildrenIds[ChildIndex], IterationLambda))
                {
                    return true;
                }
            }
        }
        return false;
    }
 
    INTERCHANGECORE_API void BreakableIterateNodes(TFunctionRef<bool(const FString&, UInterchangeBaseNode*)> IterationLambda) const;
 
    template <typename T>
    void BreakableIterateNodesOfType(TFunctionRef<bool(const FString&, T*)> IterationLambda) const
    {
        for (const TPair<FString, TObjectPtr<UInterchangeBaseNode>>& NodeKeyValue : Nodes)
        {
            if (T* Node = Cast<T>(NodeKeyValue.Value))
            {
                if (IterationLambda(NodeKeyValue.Key, Node))
                {
                    break;
                }
            }
        }
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API void GetRoots(TArray<FString>& RootNodes) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API void GetNodes(const UClass* ClassNode, TArray<FString>& OutNodes) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API const UInterchangeBaseNode* GetNode(const FString& NodeUniqueID) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API UInterchangeFactoryBaseNode* GetFactoryNode(const FString& NodeUniqueID) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API bool SetNodeParentUid(const FString& NodeUniqueID, const FString& NewParentNodeUid);
 
    /* Remove the node's ParentUid, making it into a top-level node */
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API bool ClearNodeParentUid(const FString& NodeUniqueID);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API bool SetNodeDesiredChildIndex(const FString& NodeUniqueID, const int32& NewNodeDesiredChildIndex);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API int32 GetNodeChildrenCount(const FString& NodeUniqueID) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API TArray<FString> GetNodeChildrenUids(const FString& NodeUniqueID) const;
 
    INTERCHANGECORE_API TArray<FString>* GetCachedNodeChildrenUids(const FString& NodeUniqueID) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API UInterchangeBaseNode* GetNodeChildren(const FString& NodeUniqueID, int32 ChildIndex);
 
    INTERCHANGECORE_API const UInterchangeBaseNode* GetNodeChildren(const FString& NodeUniqueID, int32 ChildIndex) const;
 
    INTERCHANGECORE_API void SerializeNodeContainerData(FArchive& Ar);
 
    /* Serialize the node container into the specified file. */
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API void SaveToFile(const FString& Filename);
 
    /* Serialize the node container from the specified file. */
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API void LoadFromFile(const FString& Filename);
 
    /* Fill the cache of children UIDs to optimize the GetNodeChildrenUids call. */
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    INTERCHANGECORE_API void ComputeChildrenCache();
 
    /* Sets the children cache from an incoming data set. */
    INTERCHANGECORE_API void SetChildrenCache(const TMap<FString, TArray<FString>>& InChildrenCache);
 
    /* Gets the children cache. */
    INTERCHANGECORE_API TMap<FString, TArray<FString>>& GetChildrenCache();
 
    /* Reset the cache of children UIDs. */
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node Container")
    void ResetChildrenCache()
    {
        ChildrenCache.Reset();
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetIsAncestor(const FString& NodeUniqueID, const FString& AncestorUID) const;
 
    INTERCHANGECORE_API void SetupNode(UInterchangeBaseNode* Node, const FString& NodeUID,
        const FString& DisplayLabel, EInterchangeNodeContainerType ContainerType,
        const FString& ParentNodeUID = TEXT(""));
 
    INTERCHANGECORE_API void SetupAndReplaceFactoryNode(UInterchangeFactoryBaseNode* Node, const FString& NodeUID,
        const FString& DisplayLabel, EInterchangeNodeContainerType ContainerType,
        const FString& OldNodeUID,
        const FString& ParentNodeUID = TEXT(""));
 
private:
 
    void InternalReorderChildren(TArray<FString>& Children) const;
 
    UInterchangeBaseNode* GetNodeChildrenInternal(const FString& NodeUniqueID, int32 ChildIndex);
 
    UPROPERTY(VisibleAnywhere, Category = "Interchange | Node Container")
    TMap<FString, TObjectPtr<UInterchangeBaseNode> > Nodes;
 
    mutable TMap<FString, TArray<FString> > ChildrenCache;
};