TopLevelAssetPath.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringFwd.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Serialization/Archive.h"
#include "Serialization/StructuredArchive.h"
#include "Serialization/StructuredArchiveNameHelpers.h"
#include "Serialization/StructuredArchiveSlots.h"
#include "Templates/TypeHash.h"
#include "Traits/IsCharType.h"
#include "UObject/NameTypes.h"
#include "UObject/StructOpsTypeTraits.h"
 
#include <type_traits>
 
#include "TopLevelAssetPath.generated.h"
 
class FCbWriter;
struct FPropertyTag;
class FCbWriter;
class FString;
class UObject;
 
/* 
 * A struct that can reference a top level asset such as '/Path/To/Package.AssetName'
 * Stores two FNames internally to avoid
 *  a) storing a concatenated FName that bloats global FName storage
 *  b) storing an empty FString for a subobject path as FSoftObjectPath allows
 * Can also be used to reference the package itself in which case the second name is NAME_None
 * and the object resolves to the string `/Path/To/Package`
*/
USTRUCT(BlueprintType, meta = (HasNativeMake = "/Script/Engine.KismetSystemLibrary.MakeTopLevelAssetPath", HasNativeBreak = "/Script/Engine.KismetSystemLibrary.BreakTopLevelAssetPath"))
struct FTopLevelAssetPath
{
    GENERATED_BODY()
public:
    FTopLevelAssetPath() { }
    FTopLevelAssetPath(TYPE_OF_NULLPTR) { }
 
    FTopLevelAssetPath(FName InPackageName, FName InAssetName)
    {
        TrySetPath(InPackageName, InAssetName);
    }
 
    UE_DEPRECATED(5.0, "FNames containing full asset paths have been replaced by FTopLevelAssetPath/FSoftLevelObjectPath."
        "This function is only for temporary use interfacing with APIs that still produce an FName."
        "Those APIS should be updated to use FTopLevelAssetPath or FSoftLevelObjectPath.")
    explicit FTopLevelAssetPath(FName InPath)
    {
        TrySetPath(InPath.ToString());
    }
 
    explicit FTopLevelAssetPath(const FString& Path) { TrySetPath(FStringView(Path)); }
    template<typename CharType, typename = typename std::enable_if<TIsCharType<CharType>::Value>::type>
    explicit FTopLevelAssetPath(TStringView<CharType> Path) { TrySetPath(Path); }
    template<typename CharType, typename = typename std::enable_if<TIsCharType<CharType>::Value>::type>
    explicit FTopLevelAssetPath(const CharType* Path) { TrySetPath(TStringView<CharType>(Path)); }
 
    explicit FTopLevelAssetPath(const UObject* InObject) { TrySetPath(InObject); }
 
    FTopLevelAssetPath& operator=(const FString& Path) { TrySetPath(FStringView(Path)); return *this; }
    template<typename CharType>
    FTopLevelAssetPath& operator=(TStringView<CharType> Path) { TrySetPath(Path); return *this; }
    template<typename CharType, typename = typename std::enable_if<TIsCharType<CharType>::Value>::type>
    FTopLevelAssetPath& operator=(const CharType* Path) { TrySetPath(TStringView<CharType>(Path)); return *this; }
    FTopLevelAssetPath& operator=(TYPE_OF_NULLPTR) { Reset(); return *this; }
 
    COREUOBJECT_API bool TrySetPath(FName InPackageName, FName InAssetName);
    COREUOBJECT_API bool TrySetPath(const UObject* InObject);
    COREUOBJECT_API bool TrySetPath(FWideStringView Path);
    COREUOBJECT_API bool TrySetPath(FUtf8StringView Path);
    COREUOBJECT_API bool TrySetPath(FAnsiStringView Path);
    template<typename CharType,	typename = typename std::enable_if<TIsCharType<CharType>::Value>::type>
    bool TrySetPath(const CharType* Path) { return TrySetPath(TStringView<CharType>(Path)); }
    bool TrySetPath(const FString& Path) { return TrySetPath(FStringView(Path)); }
 
    COREUOBJECT_API bool RemapPackage(FName OldPackageName, FName NewPackageName);
 
    FName GetPackageName() const { return PackageName; }
 
    FName GetAssetName() const { return AssetName; }
 
    COREUOBJECT_API void AppendString(FWideStringBuilderBase& Builder) const;
    COREUOBJECT_API void AppendString(FUtf8StringBuilderBase& Builder) const;
    COREUOBJECT_API void AppendString(FString& OutString) const;
 
    COREUOBJECT_API FString ToString() const;
    COREUOBJECT_API void ToString(FString& OutString) const;
 
    // Return the full asset path (e.g. '/Path/To/Package.AssetName') as an FName.
    UE_DEPRECATED(5.1, "FNames containing full asset paths have been replaced by FTopLevelAssetPath/FSoftLevelObjectPath."
        "This function is only for temporary use interfacing with APIs that still expect an FName."
        "Those APIS should be updated to use FTopLevelAssetPath or FSoftLevelObjectPath.")
    FName ToFName() const { return *ToString(); }
 
    bool IsValid() const
    {
        return !PackageName.IsNone();
    }
 
    bool IsNull() const
    {
        return PackageName.IsNone();
    }
 
    void Reset()
    {       
        PackageName = AssetName = FName();
    }
    bool operator==(FTopLevelAssetPath const& Other) const
    {
        return PackageName == Other.PackageName && AssetName == Other.AssetName;
    }
 
    bool operator!=(FTopLevelAssetPath const& Other) const
    {
        return !(*this == Other);
    }
 
    friend FArchive& operator<<(FArchive& Ar, FTopLevelAssetPath& Path)
    {
        return Ar << Path.PackageName << Path.AssetName;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, FTopLevelAssetPath& Path)
    {
        FStructuredArchive::FRecord Record = Slot.EnterRecord();
        Record << SA_VALUE(TEXT("PackageName"), Path.PackageName) << SA_VALUE(TEXT("AssetName"), Path.AssetName);
    }
 
    int32 Compare(const FTopLevelAssetPath& Other) const
    {
        if (int32 Diff = PackageName.Compare(Other.PackageName))
        {
            return Diff;
        }
        return AssetName.Compare(Other.AssetName);
    }
 
    int32 CompareFast(const FTopLevelAssetPath& Other) const
    {
        if (int32 Diff = PackageName.CompareIndexes(Other.PackageName))
        {
            return Diff;
        }
        return AssetName.CompareIndexes(Other.AssetName);
    }
 
    [[nodiscard]] friend uint32 GetTypeHash(FTopLevelAssetPath const& This)
    {
        return HashCombineFast(GetTypeHash(This.PackageName), GetTypeHash(This.AssetName));
    }
 
    COREUOBJECT_API bool ExportTextItem(FString& ValueStr, FTopLevelAssetPath const& DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const;
    COREUOBJECT_API bool ImportTextItem( const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText, FArchive* InSerializingArchive = nullptr );
    COREUOBJECT_API bool SerializeFromMismatchedTag(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot);
 
    COREUOBJECT_API void WriteCompactBinary(FCbWriter& Writer) const;
private:
    friend FCbWriter& operator<<(FCbWriter& Writer, const FTopLevelAssetPath& Path)
    {
        Path.WriteCompactBinary(Writer);
        return Writer;
    }
    COREUOBJECT_API friend bool LoadFromCompactBinary(FCbFieldView Field, FTopLevelAssetPath& OutPath);
 
    UPROPERTY(EditAnywhere, SaveGame, BlueprintReadWrite, Category = TopLevelAssetPath, meta = (AllowPrivateAccess = "true"))
    FName PackageName;
    UPROPERTY(EditAnywhere, SaveGame, BlueprintReadWrite, Category = TopLevelAssetPath, meta = (AllowPrivateAccess = "true"))
    FName AssetName;
 
    COREUOBJECT_API friend void SerializeForLog(FCbWriter& Writer, const FTopLevelAssetPath& Value);
};
 
inline FWideStringBuilderBase& operator<<(FWideStringBuilderBase& Builder, const FTopLevelAssetPath& Path)
{
    Path.AppendString(Builder);
    return Builder;
}
 
inline FUtf8StringBuilderBase& operator<<(FUtf8StringBuilderBase& Builder, const FTopLevelAssetPath& Path)
{
    Path.AppendString(Builder);
    return Builder;
}
 
struct FTopLevelAssetPathFastLess
{
    UE_FORCEINLINE_HINT bool operator()(const FTopLevelAssetPath& A, const FTopLevelAssetPath& B) const
    {
        return A.CompareFast(B) < 0;
    }
};
 
struct FTopLevelAssetPathLexicalLess
{
    UE_FORCEINLINE_HINT bool operator()(const FTopLevelAssetPath& A, const FTopLevelAssetPath& B) const
    {
        return A.Compare(B) < 0;
    }
};
 
template<>
struct TStructOpsTypeTraits<FTopLevelAssetPath> : public TStructOpsTypeTraitsBase2<FTopLevelAssetPath>
{
    enum
    {
        WithStructuredSerializeFromMismatchedTag = true,
        WithExportTextItem = true,
        WithImportTextItem = true,
    };
};