DataTable.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "CoreMinimal.h"
#endif //UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/Class.h"
#include "UObject/UnrealType.h"
#include "UObject/PropertyPortFlags.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "DataTableUtils.h"
#include "DataTable.generated.h"
 
class Error;
class UDataTable;
struct FDataTableEditorUtils;
class UGameplayTagTableManager;
class FDataTableImporterCSV;
class FDataTableImporterJSON;
template <class CharType> struct TPrettyJsonPrintPolicy;
 
// forward declare JSON writer
template <class CharType>
struct TPrettyJsonPrintPolicy;
template <class CharType, class PrintPolicy>
class TJsonWriter;
 
 
USTRUCT(BlueprintInternalUseOnly)
struct FTableRowBase
{
    GENERATED_USTRUCT_BODY()
 
    FTableRowBase() { }
    virtual ~FTableRowBase() { }
 
    virtual void OnPostDataImport(const UDataTable* InDataTable, const FName InRowName, TArray<FString>& OutCollectedImportProblems) {}
 
    virtual void OnDataTableChanged(const UDataTable* InDataTable, const FName InRowName) {}
 
#if WITH_EDITOR
    virtual EDataValidationResult IsDataValid(FDataValidationContext& Context) const { return EDataValidationResult::NotValidated; }
#endif // WITH_EDITOR
};
 
 
UCLASS(MinimalAPI, BlueprintType, AutoExpandCategories = "DataTable,ImportOptions", Meta = (LoadBehavior = "LazyOnDemand"))
class UDataTable
    : public UObject
{
    GENERATED_UCLASS_BODY()
 
    DECLARE_MULTICAST_DELEGATE(FOnDataTableChanged);
    DECLARE_MULTICAST_DELEGATE(FOnDataTableImport);
    
    friend FDataTableEditorUtils;
    friend UGameplayTagTableManager;
    friend FDataTableImporterCSV;
    friend FDataTableImporterJSON;
 
    UPROPERTY(VisibleAnywhere, Category=DataTable, meta=(DisplayThumbnail="false"))
    TObjectPtr<UScriptStruct>           RowStruct;
 
protected:
    TMap<FName, uint8*>     RowMap;
 
    // TODO: remove this, it is temporarily here to allow DataTableEditorUtils to compile until I get around to updating functions like RemoveRow and RenameRow
    virtual TMap<FName, uint8*>& GetNonConstRowMap() { return RowMap; }
 
    ENGINE_API virtual void AddRowInternal(FName RowName, uint8* RowDataPtr);
 
    ENGINE_API virtual void RemoveRowInternal(FName RowName);
public:
 
    virtual const TMap<FName, uint8*>& GetRowMap() const { return RowMap; }
    virtual const TMap<FName, uint8*>& GetRowMap() { return RowMap; }
 
    const UScriptStruct* GetRowStruct() const { return RowStruct; }
 
    virtual bool AllowDuplicateRowsOnImport() const { return false; }
 
    UPROPERTY(EditAnywhere, Category=DataTable)
    uint8 bStripFromClientBuilds : 1;
 
    UPROPERTY(EditAnywhere, Category=ImportOptions)
    uint8 bIgnoreExtraFields : 1;
 
    UPROPERTY(EditAnywhere, Category = ImportOptions)
    uint8 bIgnoreMissingFields : 1;
 
    UPROPERTY(EditAnywhere, Category = ImportOptions)
    uint8 bPreserveExistingValues : 1;
 
    UPROPERTY(EditAnywhere, Category=ImportOptions)
    FString ImportKeyField;
    
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual EDataValidationResult IsDataValid(FDataValidationContext& Context) const override;
protected:
    ENGINE_API virtual void ThreadedPostLoadAssetRegistryTagsOverride(FPostLoadAssetRegistryTagsContext& Context) const override;
public:
#endif // WITH_EDITOR
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void FinishDestroy() override;
    ENGINE_API virtual void Serialize(FStructuredArchiveRecord Record) override;
    ENGINE_API static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    ENGINE_API virtual void GetPreloadDependencies(TArray<UObject*>& OutDeps) override;
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    virtual bool NeedsLoadForClient() const override { return bStripFromClientBuilds ? false : Super::NeedsLoadForClient(); }
    virtual bool NeedsLoadForEditorGame() const override { return bStripFromClientBuilds ? false : Super::NeedsLoadForEditorGame(); }
#if WITH_EDITORONLY_DATA
    ENGINE_API FTopLevelAssetPath GetRowStructPathName() const;
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    ENGINE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void PostLoad() override;
    //~ End UObject Interface
 
    UPROPERTY(VisibleAnywhere, Instanced, Category=ImportSource)
    TObjectPtr<class UAssetImportData> AssetImportData;
 
    UPROPERTY()
    FString ImportPath_DEPRECATED;
 
    UPROPERTY()
    FName RowStructName_DEPRECATED;
 
    UPROPERTY()
    FTopLevelAssetPath RowStructPathName;
 
protected:
    UPROPERTY(Transient)
    TArray<uint8> RowsSerializedWithTags;
 
    UPROPERTY(Transient)
    TSet<TObjectPtr<UObject>> TemporarilyReferencedObjects;
#endif  // WITH_EDITORONLY_DATA
 
private:
    FOnDataTableChanged OnDataTableChangedDelegate;
 
public:
    FOnDataTableChanged& OnDataTableChanged() { return OnDataTableChangedDelegate; }
 
    ENGINE_API void HandleDataTableChanged(FName ChangedRowName = NAME_None);
    
    template <class T>
    void GetAllRows(const TCHAR* ContextString, OUT TArray<T*>& OutRowArray) const
    {
        if (CommonTypeCheck(T::StaticStruct(), TEXT("UDataTable::GetAllRows"), ContextString))
        {
            OutRowArray.Reserve(OutRowArray.Num() + GetRowMap().Num());
            for (TMap<FName, uint8*>::TConstIterator RowMapIter(GetRowMap().CreateConstIterator()); RowMapIter; ++RowMapIter)
            {
                OutRowArray.Add(reinterpret_cast<T*>(RowMapIter.Value()));
            }
        }   
    }
 
    template <class T>
    void GetAllRows(const FString& ContextString, OUT TArray<T*>& OutRowArray) const
    {
        GetAllRows<T>(*ContextString, OutRowArray);
    }
 
    template <class T>
    T* FindRow(FName RowName, const TCHAR* ContextString, bool bWarnIfRowMissing = true) const
    {
        return reinterpret_cast<T*>(FindRowInternal(T::StaticStruct(), RowName, ContextString, bWarnIfRowMissing));
    }
 
    template <class T>
    T* FindRow(FName RowName, const FString& ContextString, bool bWarnIfRowMissing = true) const
    {
        return FindRow<T>(RowName, *ContextString, bWarnIfRowMissing);
    }
 
    template <class T>
    void ForeachRow(const TCHAR* ContextString, TFunctionRef<void (const FName& Key, const T& Value)> Predicate) const
    {
        if (CommonTypeCheck(T::StaticStruct(), TEXT("UDataTable::ForeachRow"), ContextString))
        {
            for (TMap<FName, uint8*>::TConstIterator RowMapIter(GetRowMap().CreateConstIterator()); RowMapIter; ++RowMapIter)
            {
                T* Entry = reinterpret_cast<T*>(RowMapIter.Value());
                Predicate(RowMapIter.Key(), *Entry);
            }
        }
    }
 
    template <class T>
    void ForeachRow(const FString& ContextString, TFunctionRef<void (const FName& Key, const T& Value)> Predicate) const
    {
        ForeachRow<T>(*ContextString, Predicate);
    }
 
    ENGINE_API FProperty* FindTableProperty(const FName& PropertyName) const;
 
    uint8* FindRowUnchecked(FName RowName) const
    {
        if(RowStruct == nullptr)
        {
            return nullptr;
        }
 
        // If is RowName is none, it won't find anything in the map
        uint8* const* RowDataPtr = GetRowMap().Find(RowName);
 
        if(RowDataPtr == nullptr)
        {
            return nullptr;
        }
 
        return *RowDataPtr;
    }
 
    ENGINE_API virtual void EmptyTable();
 
    ENGINE_API TArray<FName> GetRowNames() const;
 
    ENGINE_API virtual void RemoveRow(FName RowName);
 
    ENGINE_API virtual void AddRow(FName RowName, const FTableRowBase& RowData);
    ENGINE_API virtual void AddRow(FName RowName, const uint8* RowData, const UScriptStruct* RowType);
 
#if WITH_EDITOR
    ENGINE_API virtual void CleanBeforeStructChange();
    ENGINE_API virtual void RestoreAfterStructChange();
 
    ENGINE_API FString GetTableAsString(const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const;
 
    ENGINE_API FString GetTableAsCSV(const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const;
 
    ENGINE_API FString GetTableAsJSON(const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const;
 
    template<typename CharType = TCHAR>
    bool WriteTableAsJSON(const TSharedRef< TJsonWriter<CharType, TPrettyJsonPrintPolicy<CharType> > >& JsonWriter, const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const;
 
    template<typename CharType = TCHAR>
    bool WriteTableAsJSONObject(const TSharedRef< TJsonWriter<CharType, TPrettyJsonPrintPolicy<CharType> > >& JsonWriter, const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const;
 
    template<typename CharType = TCHAR>
    bool WriteRowAsJSON(const TSharedRef< TJsonWriter<CharType, TPrettyJsonPrintPolicy<CharType> > >& JsonWriter, const void* RowData, const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const;
 
    ENGINE_API bool CopyImportOptions(UDataTable* SourceTable);
#endif
    ENGINE_API TArray<FString> CreateTableFromCSVString(const FString& InString);
 
    ENGINE_API TArray<FString> CreateTableFromJSONString(const FString& InString);
 
    TArray<FProperty*> GetTablePropertyArray(const TArray<const TCHAR*>& Cells, UStruct* RowStruct, TArray<FString>& OutProblems, int32 KeyColumn = 0);
    
    ENGINE_API TArray<FString> CreateTableFromOtherTable(const UDataTable* InTable);
 
    ENGINE_API TArray<FString> CreateTableFromRawData(TMap<FName, const uint8*>& DataMap, UScriptStruct* InRowStruct);
 
#if WITH_EDITOR
    ENGINE_API TArray<FString> GetColumnTitles() const;
 
    ENGINE_API TArray<FString> GetUniqueColumnTitles() const;
 
    ENGINE_API TArray< TArray<FString> > GetTableData(const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const;
#endif //WITH_EDITOR
 
    //~ End UDataTable Interface
 
protected:
    void SaveStructData(FStructuredArchiveSlot Slot);
    void LoadStructData(FStructuredArchiveSlot Slot);
 
    void OnPostDataImported(OUT TArray<FString>& OutCollectedImportProblems);
 
    UScriptStruct& GetEmptyUsingStruct() const;
 
    struct FScopedDataTableChange
    {
        FScopedDataTableChange(UDataTable* InTable);
        FScopedDataTableChange(UDataTable* InTable,FName Row);
        ~FScopedDataTableChange();
 
    private:
        UDataTable* Table;
        FName RowName;
        static TMap<UDataTable*, int32> ScopeCount;
        static FTransactionallySafeCriticalSection CriticalSection;
    };
 
private:
    ENGINE_API bool CommonTypeCheck(UScriptStruct* Type, const TCHAR* MethodName, const TCHAR* ContextString) const;
    ENGINE_API uint8* FindRowInternal(UScriptStruct* Type, FName RowName, const TCHAR* ContextString, bool bWarnIfRowMissing) const;
};
 
 
USTRUCT(BlueprintType)
struct FDataTableRowHandle
{
    GENERATED_USTRUCT_BODY()
 
    FDataTableRowHandle()
        : DataTable(nullptr)
        , RowName(NAME_None)
    {
 
    }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=DataTableRowHandle)
    TObjectPtr<const UDataTable>    DataTable;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=DataTableRowHandle)
    FName               RowName;
 
    bool IsNull() const
    {
        return DataTable == nullptr && RowName.IsNone();
    }
 
    template <class T>
    T* GetRow(const TCHAR* ContextString) const
    {
        if(DataTable == nullptr)
        {
            if (RowName != NAME_None)
            {
                UE_LOG(LogDataTable, Warning, TEXT("FDataTableRowHandle::GetRow : No DataTable for row %s (%s)."), *RowName.ToString(), ContextString);
            }
            return nullptr;
        }
 
        return DataTable->FindRow<T>(RowName, ContextString);
    }
 
    template <class T>
    T* GetRow(const FString& ContextString) const
    {
        return GetRow<T>(*ContextString);
    }
 
    FString ToDebugString(bool bUseFullPath = false) const
    {
        if (DataTable == nullptr)
        {
            return FString::Printf(TEXT("No Data Table Specified, Row: %s"), *RowName.ToString());
        }
 
        return FString::Printf(TEXT("Table: %s, Row: %s"), bUseFullPath ? *DataTable->GetPathName() : *DataTable->GetName(), *RowName.ToString());
    }
 
    ENGINE_API bool operator==(FDataTableRowHandle const& Other) const;
    ENGINE_API bool operator!=(FDataTableRowHandle const& Other) const;
    ENGINE_API void PostSerialize(const FArchive& Ar);
};
 
template<>
struct TStructOpsTypeTraits< FDataTableRowHandle > : public TStructOpsTypeTraitsBase2< FDataTableRowHandle >
{
    enum
    {
        WithPostSerialize = true,
    };
};
 
USTRUCT(BlueprintType)
struct FDataTableCategoryHandle
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=DataTableCategoryHandle)
    TObjectPtr<const class UDataTable>  DataTable = nullptr;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=DataTableCategoryHandle)
    FName               ColumnName;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=DataTableCategoryHandle)
    FName               RowContents;
 
    bool IsNull() const
    {
        return DataTable == nullptr && ColumnName == NAME_None && RowContents == NAME_None;
    }
 
    template <class T>
    void GetRows(TArray<T*>& OutRows, const FString& ContextString) const
    {
        OutRows.Empty();
        if (DataTable == nullptr)
        {
            if (RowContents != NAME_None)
            {
                UE_LOG(LogDataTable, Warning, TEXT("FDataTableCategoryHandle::GetRows : No DataTable for row %s (%s)."), *RowContents.ToString(), *ContextString);
            }
 
            return;
        }
 
        if (ColumnName == NAME_None)
        {
            if (RowContents != NAME_None)
            {
                UE_LOG(LogDataTable, Warning, TEXT("FDataTableCategoryHandle::GetRows : No Column selected for row %s (%s)."), *RowContents.ToString(), *ContextString);
            }
 
            return;
        }
 
        // Find the property that matches the desired column (ColumnName)
        FProperty* Property = DataTable->FindTableProperty(ColumnName);
        if (Property == nullptr)
        {
            return;
        }
 
        // check each row to see if the value in the Property element is the one we're looking for (RowContents). If it is, add the row to OutRows
        uint8* RowContentsAsBinary = (uint8*)FMemory_Alloca(Property->GetSize());
        Property->InitializeValue(RowContentsAsBinary);
        if (Property->ImportText_Direct(*RowContents.ToString(), RowContentsAsBinary, nullptr, PPF_None) == nullptr)
        {
            Property->DestroyValue(RowContentsAsBinary);
            return;
        }
 
        for (auto RowIt = DataTable->GetRowMap().CreateConstIterator(); RowIt; ++RowIt)
        {
            uint8* RowData = RowIt.Value();
 
            if (Property->Identical(Property->ContainerPtrToValuePtr<void>(RowData, 0), RowContentsAsBinary, PPF_None))
            {
                OutRows.Add((T*)RowData);
            }
        }
        Property->DestroyValue(RowContentsAsBinary);
 
        return;
    }
 
    ENGINE_API bool operator==(FDataTableCategoryHandle const& Other) const;
    ENGINE_API bool operator!=(FDataTableCategoryHandle const& Other) const;
};
 
 
#define GETROW_REPORTERROR(Handle, Template) Handle.GetRow<Template>(FString::Printf(TEXT("%s.%s"), *GetPathName(), TEXT(#Handle)))
#define GETROWOBJECT_REPORTERROR(Object, Handle, Template) Handle.GetRow<Template>(FString::Printf(TEXT("%s.%s"), *Object->GetPathName(), TEXT(#Handle)))