StringTableCore.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Containers/Map.h"
#include "Containers/SparseArray.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Internationalization/Internationalization.h"
#include "Internationalization/LocKeyFuncs.h"
#include "Internationalization/LocalizedTextSourceTypes.h"
#include "Internationalization/StringTableCoreFwd.h"
#include "Internationalization/Text.h"
#include "Internationalization/TextKey.h"
#include "Logging/LogMacros.h"
#include "Misc/AssertionMacros.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "Serialization/Archive.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
 
#include <atomic>
 
class FStringTable;
class UStringTable;
 
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogStringTable, Log, All);
 
class FStringTableEntry
{
public:
    static FStringTableEntryRef NewStringTableEntry(FStringTableConstRef InOwnerTable, FString InSourceString, FTextId InDisplayStringId)
    {
        return MakeShared<FStringTableEntry, ESPMode::ThreadSafe>(MoveTemp(InOwnerTable), MoveTemp(InSourceString), MoveTemp(InDisplayStringId));
    }
 
    CORE_API FStringTableEntry();
 
    CORE_API FStringTableEntry(FStringTableConstRef InOwnerTable, FString InSourceString, FTextId InDisplayStringId);
 
    CORE_API bool IsOwned() const;
 
    CORE_API void Disown();
 
    CORE_API bool IsOwnedBy(const FStringTable& InStringTable) const;
 
    CORE_API const FString& GetSourceString() const;
 
    CORE_API FTextConstDisplayStringPtr GetDisplayString() const;
 
    CORE_API FTextId GetDisplayStringId() const;
 
    static CORE_API const FString& GetPlaceholderSourceString();
 
private:
    FStringTableConstWeakPtr OwnerTable;
 
    FString SourceString;
 
    FTextId DisplayStringId;
};
 
class FStringTable : public TSharedFromThis<FStringTable, ESPMode::ThreadSafe>
{
public:
    static FStringTableRef NewStringTable()
    {
        return MakeShared<FStringTable, ESPMode::ThreadSafe>();
    }
 
    CORE_API FStringTable();
 
    CORE_API ~FStringTable();
 
    CORE_API UStringTable* GetOwnerAsset() const;
 
    CORE_API void SetOwnerAsset(UStringTable* InOwnerAsset);
 
    CORE_API bool IsLoaded() const;
 
    CORE_API void IsLoaded(const bool bInIsLoaded);
 
    CORE_API bool IsInternal() const;
 
    CORE_API void IsInternal(const bool bInIsInternal);
 
    CORE_API FString GetNamespace() const;
 
    CORE_API void SetNamespace(const FTextKey& InNamespace);
 
    CORE_API bool GetSourceString(const FTextKey& InKey, FString& OutSourceString) const;
 
    CORE_API void SetSourceString(const FTextKey& InKey, const FString& InSourceString);
 
    CORE_API void RemoveSourceString(const FTextKey& InKey);
 
    CORE_API void EnumerateSourceStrings(const TFunctionRef<bool(const FString&, const FString&)>& InEnumerator) const;
    CORE_API void EnumerateKeysAndSourceStrings(const TFunctionRef<bool(const FTextKey&, const FString&)>& InEnumerator) const;
 
    CORE_API void ClearSourceStrings(const int32 InSlack = 0);
 
    CORE_API FStringTableEntryConstPtr FindEntry(const FTextKey& InKey) const;
 
    CORE_API bool FindKey(const FStringTableEntryConstRef& InEntry, FString& OutKey) const;
    CORE_API bool FindKey(const FStringTableEntryConstRef& InEntry, FTextKey& OutKey) const;
 
    CORE_API FString GetMetaData(const FTextKey& InKey, const FName InMetaDataId) const;
 
    CORE_API void SetMetaData(const FTextKey& InKey, const FName InMetaDataId, const FString& InMetaDataValue);
 
    CORE_API void RemoveMetaData(const FTextKey& InKey, const FName InMetaDataId);
 
    CORE_API void EnumerateMetaData(const FTextKey& InKey, const TFunctionRef<bool(FName, const FString&)>& InEnumerator) const;
 
    CORE_API void ClearMetaData(const FTextKey& InKey);
 
    CORE_API void ClearMetaData(const int32 InSlack = 0);
 
    CORE_API void Serialize(FArchive& Ar);
 
    CORE_API bool ExportStrings(const FString& InFilename) const;
 
    CORE_API bool ImportStrings(const FString& InFilename);
 
private:
    UStringTable* OwnerAsset;
 
    bool bIsLoaded;
 
    bool bIsInternal;
 
    FTextKey TableNamespace;
 
    TMap<FTextKey, FStringTableEntryPtr> KeysToEntries;
 
    mutable FTransactionallySafeCriticalSection KeyMappingCS;
 
    typedef TMap<FName, FString> FMetaDataMap;
    TMap<FTextKey, FMetaDataMap> KeysToMetaData;
 
    mutable FTransactionallySafeCriticalSection KeysToMetaDataCS;
};
 
class IStringTableEngineBridge
{
public:
    struct FScopedDeferFindOrLoad
    {
        FScopedDeferFindOrLoad()
        {
            ++DeferFindOrLoad;
        }
 
        ~FScopedDeferFindOrLoad()
        {
            --DeferFindOrLoad;
        }
 
        UE_NONCOPYABLE(FScopedDeferFindOrLoad);
    };
 
    typedef TFunction<void(FName, FName)> FLoadStringTableAssetCallback;
 
    static bool CanFindOrLoadStringTableAsset()
    {
        return FInternationalization::IsAvailable()
            && DeferFindOrLoad.load(std::memory_order_relaxed) <= 0
            && (!InstancePtr || InstancePtr->CanFindOrLoadStringTableAssetImpl());
    }
 
    static int32 LoadStringTableAsset(const FName InTableId, FLoadStringTableAssetCallback InLoadedCallback = FLoadStringTableAssetCallback())
    {
        check(CanFindOrLoadStringTableAsset());
 
        if (InstancePtr)
        {
            return InstancePtr->LoadStringTableAssetImpl(InTableId, InLoadedCallback);
        }
 
        // No bridge instance - just say it's already loaded
        if (InLoadedCallback)
        {
            InLoadedCallback(InTableId, InTableId);
        }
        return INDEX_NONE;
    }
 
    static void FullyLoadStringTableAsset(FName& InOutTableId)
    {
        check(CanFindOrLoadStringTableAsset());
 
        if (InstancePtr)
        {
            return InstancePtr->FullyLoadStringTableAssetImpl(InOutTableId);
        }
    }
 
    static void RedirectStringTableAsset(FName& InOutTableId)
    {
        check(CanFindOrLoadStringTableAsset());
 
        if (InstancePtr)
        {
            InstancePtr->RedirectStringTableAssetImpl(InOutTableId);
        }
    }
 
    static void CollectStringTableAssetReferences(FName& InOutTableId, FStructuredArchive::FSlot Slot)
    {
        if (InstancePtr)
        {
            InstancePtr->CollectStringTableAssetReferencesImpl(InOutTableId, Slot);
        }
    }
 
    static void CollectStringTableAssetSearchableName(const FName InTableId, const FTextKey InKey, const FArchive& Ar)
    {
        if (InstancePtr)
        {
            InstancePtr->CollectStringTableAssetSearchableNameImpl(InTableId, InKey, Ar);
        }
    }
 
    static bool IsStringTableFromAsset(const FName InTableId)
    {
        return InstancePtr && InstancePtr->IsStringTableFromAssetImpl(InTableId);
    }
 
    static bool IsStringTableAssetBeingReplaced(const UStringTable* InStringTableAsset)
    {
        return InstancePtr && InStringTableAsset && InstancePtr->IsStringTableAssetBeingReplacedImpl(InStringTableAsset);
    }
 
protected:
    virtual ~IStringTableEngineBridge() = default;
 
    virtual bool CanFindOrLoadStringTableAssetImpl() = 0;
    virtual int32 LoadStringTableAssetImpl(const FName InTableId, FLoadStringTableAssetCallback InLoadedCallback) = 0;
    virtual void FullyLoadStringTableAssetImpl(FName& InOutTableId) = 0;
    virtual void RedirectStringTableAssetImpl(FName& InOutTableId) = 0;
    virtual void CollectStringTableAssetReferencesImpl(FName& InOutTableId, FStructuredArchive::FSlot Slot) = 0;
    virtual void CollectStringTableAssetSearchableNameImpl(const FName InTableId, const FTextKey InKey, const FArchive& Ar) = 0;
    virtual bool IsStringTableFromAssetImpl(const FName InTableId) = 0;
    virtual bool IsStringTableAssetBeingReplacedImpl(const UStringTable* InStringTableAsset) = 0;
 
    static CORE_API IStringTableEngineBridge* InstancePtr;
 
    static CORE_API std::atomic<int8> DeferFindOrLoad;
};
 
struct FStringTableRedirects
{
    static CORE_API void InitStringTableRedirects();
 
    static CORE_API void RedirectTableId(FName& InOutTableId);
 
    static CORE_API void RedirectKey(const FName InTableId, FTextKey& InOutKey);
 
    static CORE_API void RedirectTableIdAndKey(FName& InOutTableId, FTextKey& InOutKey);
};