PrimaryAssetId.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "HAL/Platform.h"
#include "Misc/StringBuilder.h"
#include "Serialization/Archive.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/TypeHash.h"
#include "UObject/NameTypes.h"
#include "UObject/StructOpsTypeTraits.h"
#include "UObject/UnrealNames.h"
 
#include "PrimaryAssetId.generated.h"
 
class FCbWriter;
class FOutputDevice;
class UObject;
 
USTRUCT(BlueprintType)
struct FPrimaryAssetType
{
    GENERATED_BODY()
 
    
    FPrimaryAssetType() = default;
    FPrimaryAssetType(FName InName) : Name(InName) {}
    FPrimaryAssetType(EName InName) : Name(FName(InName)) {}
    FPrimaryAssetType(const WIDECHAR* InName) : Name(FName(InName)) {}
    FPrimaryAssetType(const ANSICHAR* InName) : Name(FName(InName)) {}
 
    FPrimaryAssetType(const FPrimaryAssetType&) = default;
    FPrimaryAssetType(FPrimaryAssetType&&) = default;
    FPrimaryAssetType& operator=(const FPrimaryAssetType&) = default;
    FPrimaryAssetType& operator=(FPrimaryAssetType&&) = default;
 
    operator FName&() { return Name; }
    operator const FName&() const { return Name; }
 
    FName GetName() const
    {
        return Name;
    }
 
    bool operator==(const FPrimaryAssetType& Other) const
    {
        return Name == Other.Name;
    }
 
    bool operator!=(const FPrimaryAssetType& Other) const
    {
        return Name != Other.Name;
    }
 
    bool IsValid() const
    {
        return Name != NAME_None;
    }
 
    FString ToString() const
    {
        return Name.ToString();
    }
 
    void AppendString(FStringBuilderBase& Builder) const
    {
        Name.AppendString(Builder);
    }
 
    bool ExportTextItem(FString& ValueStr, FPrimaryAssetType const& DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const;
    bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText);
    bool SerializeFromMismatchedTag(struct FPropertyTag const& Tag, FStructuredArchive::FSlot Slot);
 
    friend inline uint32 GetTypeHash(const FPrimaryAssetType& Key)
    {
        return GetTypeHash(Key.Name);
    }
 
    bool LexicalLess(const FPrimaryAssetType& Other) const
    {
        return Name.LexicalLess(Other.Name);
    }
 
    bool FastLess(const FPrimaryAssetType& Other) const
    {
        return Name.FastLess(Other.Name);
    }
 
private:
    UPROPERTY(EditAnywhere, SaveGame, BlueprintReadWrite, Category = PrimaryAssetType, meta=(AllowPrivateAccess))
    FName Name;
};
 
template<>
struct TStructOpsTypeTraits<FPrimaryAssetType> : public TStructOpsTypeTraitsBase2<FPrimaryAssetType>
{
    enum
    {
        WithZeroConstructor = true,
        WithCopy = true,
        WithIdenticalViaEquality = true,
        WithExportTextItem = true,
        WithImportTextItem = true,
        WithStructuredSerializeFromMismatchedTag = true,
    };
};
 
USTRUCT(BlueprintType)
struct FPrimaryAssetId
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, SaveGame, BlueprintReadWrite, Category = PrimaryAssetId)
    FPrimaryAssetType PrimaryAssetType;
    UPROPERTY(EditAnywhere, SaveGame, BlueprintReadWrite, Category = PrimaryAssetId)
    FName PrimaryAssetName;
 
    static COREUOBJECT_API const FName PrimaryAssetTypeTag;
    static COREUOBJECT_API const FName PrimaryAssetNameTag;
    static COREUOBJECT_API const FName PrimaryAssetDisplayNameTag;
 
    FPrimaryAssetId() = default;
    FPrimaryAssetId(FPrimaryAssetType InAssetType, FName InAssetName)
        : PrimaryAssetType(InAssetType), PrimaryAssetName(InAssetName)
    {}
 
    static COREUOBJECT_API FPrimaryAssetId ParseTypeAndName(const TCHAR* TypeAndName, uint32 Len);
    static COREUOBJECT_API FPrimaryAssetId ParseTypeAndName(FName TypeAndName);
    static FPrimaryAssetId ParseTypeAndName(const FString& TypeAndName)
    {
        return ParseTypeAndName(*TypeAndName, static_cast<uint32>(TypeAndName.Len()));
    }
 
    explicit FPrimaryAssetId(const FString& TypeAndName)
        : FPrimaryAssetId(ParseTypeAndName(TypeAndName))
    {}
 
    FPrimaryAssetId(const FPrimaryAssetId&) = default;
    FPrimaryAssetId(FPrimaryAssetId&&) = default;
    FPrimaryAssetId& operator=(const FPrimaryAssetId&) = default;
    FPrimaryAssetId& operator=(FPrimaryAssetId&&) = default;
 
    bool IsValid() const
    {
        return PrimaryAssetType != NAME_None && PrimaryAssetName != NAME_None;
    }
 
    FString ToString() const
    {
        TStringBuilder<256> Builder;
        AppendString(Builder);
        return FString::ConstructFromPtrSize(Builder.GetData(), Builder.Len());
    }
 
    void AppendString(FStringBuilderBase& Builder) const
    {
        if (IsValid())
        {
            PrimaryAssetType.AppendString(Builder);
            Builder << TEXT(":");
            PrimaryAssetName.AppendString(Builder);
        }
    }
 
    static FPrimaryAssetId FromString(const FString& String)
    {
        return FPrimaryAssetId(String);
    }
 
    bool operator==(const FPrimaryAssetId& Other) const
    {
        return PrimaryAssetType == Other.PrimaryAssetType && PrimaryAssetName == Other.PrimaryAssetName;
    }
 
    bool operator!=(const FPrimaryAssetId& Other) const
    {
        return PrimaryAssetType != Other.PrimaryAssetType || PrimaryAssetName != Other.PrimaryAssetName;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, FPrimaryAssetId& Other)
    {
        Ar << Other.PrimaryAssetType;
        Ar << Other.PrimaryAssetName;
        return Ar;
    }
 
    bool ExportTextItem(FString& ValueStr, FPrimaryAssetId const& DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const;
    bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText);
    bool SerializeFromMismatchedTag(struct FPropertyTag const& Tag, FStructuredArchive::FSlot Slot);
 
    friend inline uint32 GetTypeHash(const FPrimaryAssetId& Key)
    {
        uint32 Hash = 0;
 
        Hash = HashCombine(Hash, GetTypeHash(Key.PrimaryAssetType));
        Hash = HashCombine(Hash, GetTypeHash(Key.PrimaryAssetName));
        return Hash;
    }
 
private:
     COREUOBJECT_API void SerializeForLog(FCbWriter& Writer, const FPrimaryAssetId& Value);
};
 
template<>
struct TStructOpsTypeTraits<FPrimaryAssetId> : public TStructOpsTypeTraitsBase2<FPrimaryAssetId>
{
    enum
    {
        WithZeroConstructor = true,
        WithCopy = true,
        WithIdenticalViaEquality = true,
        WithExportTextItem = true,
        WithImportTextItem = true,
        WithStructuredSerializeFromMismatchedTag = true,
    };
};
 
COREUOBJECT_API FStringBuilderBase& operator<<(FStringBuilderBase& Builder, const FPrimaryAssetId& Id);