VVMUniqueString.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
 
#include "Containers/Set.h"
#include "Containers/StringView.h"
#include "Templates/UnrealTemplate.h"
#include "VerseVM/VVMArray.h"
#include "VerseVM/VVMCell.h"
#include "VerseVM/VVMContext.h"
#include "VerseVM/VVMGlobalHeapCensusRoot.h"
#include "VerseVM/VVMGlobalTrivialEmergentTypePtr.h"
#include "VerseVM/VVMLazyInitialized.h"
#include "VerseVM/VVMWeakBarrier.h"
 
namespace Verse
{
enum class EValueStringFormat;
 
struct VUniqueString;
class VUniqueStringSetInternPool;
 
template <typename T>
struct FUniqueStringSetKeyFuncs;
 
template <typename T>
struct FUniqueStringSetKeyFuncsBase : BaseKeyFuncs<T, T, false>
{
    typedef FUtf8StringView KeyInitType;
    typedef VUniqueString& ElementInitType;
 
    static FUtf8StringView GetSetKey(VUniqueString& Element);
 
    static FUtf8StringView GetSetKey(const T& Element);
 
    static bool Matches(FUtf8StringView A, FUtf8StringView B);
 
    static uint32 GetKeyHash(FUtf8StringView Key);
};
 
template <>
struct FUniqueStringSetKeyFuncs<TWeakBarrier<VUniqueString>> : FUniqueStringSetKeyFuncsBase<TWeakBarrier<VUniqueString>>
{
};
 
template <>
struct FUniqueStringSetKeyFuncs<TWriteBarrier<VUniqueString>> : FUniqueStringSetKeyFuncsBase<TWriteBarrier<VUniqueString>>
{
};
 
class VStringInternPool final : FGlobalHeapCensusRoot
{
private:
    VStringInternPool() = default;
 
    COREUOBJECT_API VUniqueString& Intern(FAllocationContext Context, FUtf8StringView String);
 
    COREUOBJECT_API virtual void ConductCensus() override;
 
    // The pool doesn't own the string data, the context does. So these strings are stored as weakrefs.
    // When the GC conducts a census, this string pool is also cleared of the strings that are unmarked.
    TSet<TWeakBarrier<VUniqueString>, FUniqueStringSetKeyFuncs<TWeakBarrier<VUniqueString>>> UniqueStrings;
    static UE::FMutex Mutex;
 
    friend struct VUniqueString;
    friend struct TLazyInitialized<VStringInternPool>;
};
 
struct VUniqueString final : VArray
{
    DECLARE_DERIVED_VCPPCLASSINFO(COREUOBJECT_API, VArray);
    COREUOBJECT_API static TGlobalTrivialEmergentTypePtr<&StaticCppClassInfo> GlobalTrivialEmergentType;
 
    static VUniqueString& New(FAllocationContext Context, FUtf8StringView String)
    {
        return StringPool->Intern(Context, String);
    }
 
    bool operator==(const VUniqueString& Other) const
    {
        return this == &Other;
    }
 
    // Shadow `VArrayBase::AsStringView`, avoiding type test.
    FUtf8StringView AsStringView() const
    {
        return FUtf8StringView(GetData<UTF8CHAR>(), Num());
    }
 
    static constexpr bool SerializeIdentity = false;
    static void SerializeLayout(FAllocationContext Context, VUniqueString*& This, FStructuredArchiveVisitor& Visitor);
    void SerializeImpl(FAllocationContext Context, FStructuredArchiveVisitor& Visitor);
 
private:
    static VUniqueString& Make(FAllocationContext Context, FUtf8StringView String)
    {
        return *new (Context.AllocateFastCell(sizeof(VUniqueString))) VUniqueString(Context, String);
    }
 
    VUniqueString(FAllocationContext Context, FUtf8StringView String)
        : VArray(Context, String, &GlobalTrivialEmergentType.Get(Context))
    {
    }
 
    COREUOBJECT_API static TLazyInitialized<VStringInternPool> StringPool;
    friend class VStringInternPool;
};
 
inline uint32 GetTypeHash(const VUniqueString& String)
{
    return PointerHash(&String);
}
 
struct VUniqueStringSet : VCell
{
    using SetType = TSet<TWriteBarrier<VUniqueString>, FUniqueStringSetKeyFuncs<TWriteBarrier<VUniqueString>>>;
    DECLARE_DERIVED_VCPPCLASSINFO(COREUOBJECT_API, VCell);
    COREUOBJECT_API static TGlobalTrivialEmergentTypePtr<&StaticCppClassInfo> GlobalTrivialEmergentType;
 
    // This allows for this type to be used in range-based loops.
    class FConstIterator
    {
    public:
        const TWriteBarrier<VUniqueString>* operator->() const;
        const TWriteBarrier<VUniqueString>& operator*() const;
        bool operator==(const FConstIterator& Rhs) const;
        bool operator!=(const FConstIterator& Rhs) const;
        FConstIterator& operator++();
 
    private:
        friend struct VUniqueStringSet;
        FConstIterator(SetType::TRangedForConstIterator InCurrentIteration);
        SetType::TRangedForConstIterator CurrentIteration;
    };
    FConstIterator begin() const;
    FConstIterator end() const;
 
    static VUniqueStringSet& New(FAllocationContext Context, const TSet<VUniqueString*> InSet);
    static VUniqueStringSet& New(FAllocationContext Context, const std::initializer_list<FUtf8StringView>& InStrings);
 
    bool operator==(const VUniqueStringSet& Other) const;
 
    bool Equals(const VUniqueStringSet& Other) const;
 
    uint32 Num() const;
 
    FSetElementId FindId(const FUtf8StringView& String) const;
 
    bool IsValidId(const FSetElementId& Id) const;
 
    COREUOBJECT_API void AppendToStringImpl(FAllocationContext Context, FUtf8StringBuilderBase& Builder, EValueStringFormat Format, TSet<const void*>& VisitedObjects, uint32 RecursionDepth);
 
private:
    static SetType FormSet(FAllocationContext Context, const TSet<VUniqueString*>& InSet);
    VUniqueStringSet(FAllocationContext Context, const TSet<VUniqueString*>& InSet);
 
    static VUniqueStringSet& Make(FAllocationContext Context, const TSet<VUniqueString*>& InSet);
    static bool Equals(const TSet<VUniqueString*>& A, const TSet<VUniqueString*>& B);
 
    COREUOBJECT_API static TLazyInitialized<VUniqueStringSetInternPool> Pool;
 
    SetType Strings;
 
    friend class VUniqueStringSetInternPool;
    friend struct FHashableUniqueStringSetKeyFuncs;
};
 
uint32 GetSetVUniqueStringTypeHash(const TSet<VUniqueString*>& Set);
uint32 GetTypeHash(const VUniqueStringSet& Set);
 
struct FHashableUniqueStringSetKey
{
    enum class EType : uint8
    {
        Cell,
        Set,
 
        Invalid
    };
 
    union
    {
        const VUniqueStringSet* Cell;
        const TSet<VUniqueString*>* Set;
    };
 
    EType Type;
 
    FHashableUniqueStringSetKey();
    FHashableUniqueStringSetKey(const TSet<VUniqueString*>& InSet);
    FHashableUniqueStringSetKey(const VUniqueStringSet& InCell);
    bool operator==(const FHashableUniqueStringSetKey& Other) const;
};
 
struct FHashableUniqueStringSetKeyFuncs : BaseKeyFuncs<TWeakBarrier<VUniqueStringSet>, TWeakBarrier<VUniqueStringSet>, /*bAllowDuplicateKeys*/ false>
{
    typedef FHashableUniqueStringSetKey KeyInitType;
    typedef VUniqueStringSet& ElementInitType;
 
    static KeyInitType GetSetKey(ElementInitType& Element);
 
    static KeyInitType GetSetKey(const TWeakBarrier<VUniqueStringSet>& Element);
 
    static bool Matches(KeyInitType A, KeyInitType B);
 
    static uint32 GetKeyHash(KeyInitType Key);
};
 
class VUniqueStringSetInternPool final : FGlobalHeapCensusRoot
{
private:
    VUniqueStringSetInternPool() = default;
 
    COREUOBJECT_API VUniqueStringSet& Intern(FAllocationContext Context, const TSet<VUniqueString*>& InSet);
 
    COREUOBJECT_API virtual void ConductCensus() override;
 
    TSet<TWeakBarrier<VUniqueStringSet>, FHashableUniqueStringSetKeyFuncs> Sets;
 
    static UE::FMutex Mutex;
 
    friend struct VUniqueStringSet;
    friend struct TLazyInitialized<VUniqueStringSetInternPool>;
};
 
} // namespace Verse
#endif // WITH_VERSE_VM