SharedStruct.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "StructUtils.h"
#include "StructUtils/InstancedStruct.h"
#include "StructUtils/StructUtilsTypes.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"
#include <type_traits>
 
#include "SharedStruct.generated.h"
 
#define UE_API COREUOBJECT_API
 
struct FInstancedStruct;
template<typename BaseStructT> struct TInstancedStruct;
template<typename BaseStructT> struct TStructView;
struct FConstStructView;
template<typename BaseStructT> struct TConstStructView;
 
 
struct FStructSharedMemory
{
    ~FStructSharedMemory()
    {
        ScriptStruct->DestroyStruct(GetMutableMemory());
    }
 
    FStructSharedMemory(const FStructSharedMemory& Other) = delete;
    FStructSharedMemory(const FStructSharedMemory&& Other) = delete;
    FStructSharedMemory& operator=(const FStructSharedMemory& Other) = delete;
    FStructSharedMemory& operator=(const FStructSharedMemory&& Other) = delete;
 
    struct FStructSharedMemoryDeleter
    {
        inline void operator()(FStructSharedMemory* StructSharedMemory) const
        {
            checkf(StructSharedMemory != nullptr
                , TEXT("FStructSharedMemoryDeleter is expected to be used only with a valid FStructSharedMemory. "
                    "See FStructSharedMemory::Create/CreateArgs"));
 
            StructSharedMemory->~FStructSharedMemory();
            FMemory::Free(StructSharedMemory);
        }
    };
 
    static TSharedPtr<FStructSharedMemory> Create(const UScriptStruct* InScriptStruct, const uint8* InStructMemory = nullptr)
    {
        checkf(InScriptStruct, TEXT("FStructSharedMemory::Create - script struct cannot be null"));
 
        FStructSharedMemory* const StructMemory = CreateImpl(InScriptStruct, InStructMemory);
        checkf(StructMemory != nullptr, TEXT("CreateImpl is expected to always return a valid pointer to FStructSharedMemory."));
 
        return MakeShareable(StructMemory, FStructSharedMemoryDeleter());
    }
 
    UE_DEPRECATED(5.6, "FStructSharedMemory::Create should be passed a pointer.")
    static TSharedPtr<FStructSharedMemory> Create(const UScriptStruct& InScriptStruct, const uint8* InStructMemory = nullptr)
    {
        return Create(&InScriptStruct, InStructMemory);
    }
 
    template<typename T, typename... TArgs>
    static TSharedPtr<FStructSharedMemory> CreateArgs(TArgs&&... InArgs)
    {
        UE::StructUtils::CheckStructType<T>();
 
        FStructSharedMemory* const StructMemory = CreateImpl(TBaseStructure<T>::Get());
        checkf(StructMemory != nullptr, TEXT("CreateImpl is expected to always return a valid pointer to FStructSharedMemory."));
 
        new (StructMemory->GetMutableMemory()) T(Forward<TArgs>(InArgs)...);
        return MakeShareable(StructMemory, FStructSharedMemoryDeleter());
    }
 
    const uint8* GetMemory() const
    {
        return Align((uint8*)StructMemory, ScriptStruct->GetMinAlignment());
    }
 
    uint8* GetMutableMemory()
    {
        return Align((uint8*)StructMemory, ScriptStruct->GetMinAlignment());
    }
 
    const UScriptStruct& GetScriptStruct() const
    {
        return *ObjectPtrDecay(ScriptStruct);
    }
 
    TObjectPtr<const UScriptStruct>& GetScriptStructPtr() 
    {
        return ScriptStruct;
    }
 
private:
    explicit FStructSharedMemory(const UScriptStruct* InScriptStruct, const uint8* InStructMemory = nullptr)
        : ScriptStruct(InScriptStruct)
    {
        ScriptStruct->InitializeStruct(GetMutableMemory());
        
        if (InStructMemory)
        {
            ScriptStruct->CopyScriptStruct(GetMutableMemory(), InStructMemory);
        }
    }
 
    static FStructSharedMemory* CreateImpl(const UScriptStruct* InScriptStruct, const uint8* InStructMemory = nullptr)
    {
        // Align RequiredSize to InScriptStruct's alignment to effectively add padding in between ScriptStruct and
        // StructMemory. GetMemory will then round &StructMemory up past this 'padding' to the nearest aligned address.
        const int32 RequiredSize = static_cast<int32>(Align(sizeof(FStructSharedMemory), InScriptStruct->GetMinAlignment())) + InScriptStruct->GetStructureSize();
        // Code analysis is unable to understand correctly what we are doing here, so disabling the warning C6386: Buffer overrun while writing to...
        CA_SUPPRESS( 6386 )
        FStructSharedMemory* StructMemory = new(FMemory::Malloc(RequiredSize, InScriptStruct->GetMinAlignment())) FStructSharedMemory(InScriptStruct, InStructMemory);
        return StructMemory;
    }
 
    TObjectPtr<const UScriptStruct> ScriptStruct;
 
    uint8 StructMemory[0];
};
 
 
USTRUCT()
struct [[nodiscard]] FSharedStruct
{
    GENERATED_BODY();
 
    friend struct FConstSharedStruct;
 
    FSharedStruct() = default;
 
    ~FSharedStruct()
    {
    }
 
    FSharedStruct(const FSharedStruct& InOther) = default;
    FSharedStruct(FSharedStruct&& InOther) = default;
 
    FSharedStruct& operator=(const FSharedStruct& InOther) = default;
    FSharedStruct& operator=(FSharedStruct&& InOther) = default;
 
    UE_API bool Identical(const FSharedStruct* Other, uint32 PortFlags) const;
    UE_API void AddStructReferencedObjects(class FReferenceCollector& Collector) const;
 
    const UScriptStruct* GetScriptStruct() const
    {
        return StructMemoryPtr ? &(StructMemoryPtr.Get()->GetScriptStruct()) : nullptr;
    }
 
    TObjectPtr<const UScriptStruct>* GetScriptStructPtr() const
    {
        return StructMemoryPtr ? &StructMemoryPtr.Get()->GetScriptStructPtr() : nullptr;
    }
 
    uint8* GetMemory() const
    {
        return StructMemoryPtr ? StructMemoryPtr.Get()->GetMutableMemory() : nullptr;
    }
 
    void Reset()
    {
        StructMemoryPtr.Reset();
    }
 
    template<typename T>
    void InitializeAs()
    {
        UE::StructUtils::CheckStructType<T>();
 
        InitializeAs(TBaseStructure<T>::Get(), nullptr);
    }
 
    template <typename T>
    void InitializeAs(const T& Struct)
    {
        if constexpr (UE::StructUtils::TIsSharedInstancedOrViewStruct_V<T>)
        {
            InitializeAs(Struct.GetScriptStruct(), Struct.GetMemory());
        }
        else
        {
            InitializeAs(TBaseStructure<T>::Get(), reinterpret_cast<const uint8*>(&Struct));
        }
    }
 
    void InitializeAs(const UScriptStruct* InScriptStruct, const uint8* InStructMemory = nullptr)
    {
        if (InScriptStruct)
        {
            StructMemoryPtr = FStructSharedMemory::Create(InScriptStruct, InStructMemory);
        }
        else
        {
            Reset();
        }
    }
 
    template<typename T, typename... TArgs>
    void InitializeAs(TArgs&&... InArgs)
    {
        UE::StructUtils::CheckStructType<T>();
 
        StructMemoryPtr = FStructSharedMemory::CreateArgs<T>(Forward<TArgs>(InArgs)...);
    }
 
    template<typename T>
    static FSharedStruct Make()
    {
        FSharedStruct SharedStruct;
        SharedStruct.InitializeAs<T>();
        return SharedStruct;
    }
 
    template<typename T>
    static FSharedStruct Make(const T& Struct)
    {
        FSharedStruct SharedStruct;
        SharedStruct.InitializeAs(Struct);
        return SharedStruct;
    }
 
    static FSharedStruct Make(const UScriptStruct* InScriptStruct, const uint8* InStructMemory = nullptr)
    {
        FSharedStruct SharedStruct;
        SharedStruct.InitializeAs(InScriptStruct, InStructMemory);
        return SharedStruct;
    }
 
    template<typename T, typename... TArgs>
    static FSharedStruct Make(TArgs&&... InArgs)
    {
        FSharedStruct SharedStruct;
        SharedStruct.InitializeAs<T>(Forward<TArgs>(InArgs)...);
        return SharedStruct;
    }
 
    template<typename T>
    T& Get() const
    {
        return UE::StructUtils::GetStructRef<T>(GetScriptStruct(), GetMemory());
    }
 
    template<typename T>
    T* GetPtr() const
    {
        return UE::StructUtils::GetStructPtr<T>(GetScriptStruct(), GetMemory());
    }
 
    bool IsValid() const
    {
        return GetMemory() != nullptr && GetScriptStruct() != nullptr;
    }
 
    template <typename OtherType>
    bool operator==(const OtherType& Other) const
    {
        return ((GetScriptStruct() == Other.GetScriptStruct()) && (GetMemory() == Other.GetMemory()));
    }
 
    template <typename OtherType>
    bool operator!=(const OtherType& Other) const
    {
        return !operator==(Other);
    }
 
    template <typename OtherType>
    bool CompareStructValues(const OtherType& Other, uint32 PortFlags = 0) const
    {
        UE::StructUtils::CheckWrapperType<OtherType>();
        const UScriptStruct* ScriptStruct = GetScriptStruct();
        return (ScriptStruct == Other.GetScriptStruct())
            && (!ScriptStruct || ScriptStruct->CompareScriptStruct(GetMemory(), Other.GetMemory(), PortFlags));
    }
 
protected:
    TSharedPtr<FStructSharedMemory> StructMemoryPtr;
};
 
template<typename BaseStructT>
struct [[nodiscard]] TSharedStruct
{
    explicit TSharedStruct() = default;
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TSharedStruct(const TSharedStruct<T>& InOther)
        : SharedStruct(InOther.SharedStruct)
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TSharedStruct(TSharedStruct<T>&& InOther)
        : SharedStruct(MoveTemp(InOther.SharedStruct))
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TSharedStruct& operator=(const TSharedStruct<T>& InOther)
    {
        if (this != &InOther)
        {
            SharedStruct = InOther.SharedStruct;
        }
        return *this;
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TSharedStruct& operator=(TSharedStruct<T>&& InOther)
    {
        if (this != &InOther)
        {
            SharedStruct = MoveTemp(InOther.SharedStruct);
        }
        return *this;
    }
 
    const UScriptStruct* GetScriptStruct() const
    {
        return SharedStruct.GetScriptStruct();
    }
 
    TObjectPtr<const UScriptStruct>* GetScriptStructPtr() const
    {
        return SharedStruct.GetScriptStructPtr();
    }
 
    uint8* GetMemory() const
    {
        return SharedStruct.GetMemory();
    }
 
    void Reset()
    {
        SharedStruct.Reset();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    void Initialize()
    {
        SharedStruct.InitializeAs<T>();
    }
 
    template<typename T = BaseStructT>
        requires(
            std::is_base_of_v<BaseStructT, std::decay_t<T>>
            && !(std::is_same_v<TStructView<T>, T>
                || std::is_same_v<TConstStructView<T>, T>
                || std::is_same_v<TSharedStruct<T>, T>
                || std::is_same_v<TConstSharedStruct<T>, T>
                || std::is_same_v<TInstancedStruct<T>, T>))
    void Initialize(const T& Struct)
    {
        SharedStruct.InitializeAs(TBaseStructure<T>::Get(), reinterpret_cast<const uint8*>(&Struct));
    }
 
    template<typename T = BaseStructT, typename... TArgs>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    void Initialize(TArgs&&... InArgs)
    {
        SharedStruct.InitializeAs(Forward<TArgs>(InArgs)...);
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    static TSharedStruct Make()
    {
        return FSharedStruct::Make<T>();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    static TSharedStruct Make(const T& Struct)
    {
        return FSharedStruct::Make<T>(Struct);
    }
 
    template< typename... TArgs>
    static TSharedStruct Make(TArgs&&... InArgs)
    {
        return FSharedStruct::Make<BaseStructT>(Forward<TArgs>(InArgs)...);
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    T& Get() const
    {
        return SharedStruct.Get<T>();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    T* GetPtr() const
    {
        return SharedStruct.GetPtr<T>();
    }
 
    bool IsValid() const
    {
        return SharedStruct.IsValid();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    bool operator==(const T& Other) const
    {
        return SharedStruct.operator==(Other);
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    bool operator!=(const T& Other) const
    {
        return SharedStruct.operator!=(Other);
    }
 
private:
    FSharedStruct SharedStruct;
 
    template <typename U> friend struct TSharedStruct;
};
 
template<>
struct TStructOpsTypeTraits<FSharedStruct> : public TStructOpsTypeTraitsBase2<FSharedStruct>
{
    enum
    {
        WithIdentical = true,
        WithAddStructReferencedObjects = true,
    };
};
 
 
USTRUCT()
struct [[nodiscard]] FConstSharedStruct
{
    GENERATED_BODY();
 
    FConstSharedStruct() = default;
 
    FConstSharedStruct(const FConstSharedStruct& Other) = default;
    FConstSharedStruct(const FSharedStruct& SharedStruct)
        : StructMemoryPtr(SharedStruct.StructMemoryPtr)
    {}
 
    FConstSharedStruct(FConstSharedStruct&& Other) = default;
    FConstSharedStruct(FSharedStruct&& SharedStruct)
        : StructMemoryPtr(MoveTemp(SharedStruct.StructMemoryPtr))
    {}
 
    FConstSharedStruct& operator=(const FConstSharedStruct& Other) = default;
    FConstSharedStruct& operator=(const FSharedStruct& SharedStruct)
    {
        StructMemoryPtr = SharedStruct.StructMemoryPtr;
        return *this;
    }
 
    FConstSharedStruct& operator=(FConstSharedStruct&& Other) = default;
    FConstSharedStruct& operator=(FSharedStruct&& InSharedStruct)
    {
        StructMemoryPtr = MoveTemp(InSharedStruct.StructMemoryPtr);
        return *this;
    }
 
    UE_API bool Identical(const FConstSharedStruct* Other, uint32 PortFlags) const;
    UE_API void AddStructReferencedObjects(class FReferenceCollector& Collector);
 
    const UScriptStruct* GetScriptStruct() const
    {
        return StructMemoryPtr ? &(StructMemoryPtr.Get()->GetScriptStruct()) : nullptr;
    }
 
    TObjectPtr<const UScriptStruct>* GetScriptStructPtr()
    {
        return StructMemoryPtr ?
            &const_cast<FStructSharedMemory*>(StructMemoryPtr.Get())->GetScriptStructPtr() : nullptr;
    }
 
    const uint8* GetMemory() const
    {
        return StructMemoryPtr ? StructMemoryPtr.Get()->GetMemory() : nullptr;
    }
 
    void Reset()
    {
        StructMemoryPtr.Reset();
    }
 
    template<typename T>
    void InitializeAs()
    {
        UE::StructUtils::CheckStructType<T>();
 
        InitializeAs(TBaseStructure<T>::Get(), nullptr);
    }
 
    template <typename T>
    void InitializeAs(const T& Struct)
    {
        if constexpr (UE::StructUtils::TIsSharedInstancedOrViewStruct_V<T>)
        {
            InitializeAs(Struct.GetScriptStruct(), Struct.GetMemory());
        }
        else
        {
            InitializeAs(TBaseStructure<T>::Get(), reinterpret_cast<const uint8*>(&Struct));
        }
    }
 
    void InitializeAs(const UScriptStruct* InScriptStruct, const uint8* InStructMemory = nullptr)
    {
        if (InScriptStruct)
        {
            StructMemoryPtr = FStructSharedMemory::Create(InScriptStruct, InStructMemory);
        }
        else
        {
            Reset();
        }
    }
 
    template<typename T, typename... TArgs>
    void InitializeAs(TArgs&&... InArgs)
    {
        UE::StructUtils::CheckStructType<T>();
 
        StructMemoryPtr = FStructSharedMemory::CreateArgs<T>(Forward<TArgs>(InArgs)...);
    }
 
    template<typename T>
    static FConstSharedStruct Make()
    {
        FConstSharedStruct SharedStruct;
        SharedStruct.InitializeAs<T>();
        return SharedStruct;
    }
 
    template<typename T>
    static FConstSharedStruct Make(const T& Struct)
    {
        FConstSharedStruct SharedStruct;
        SharedStruct.InitializeAs<T>(Struct);
        return SharedStruct;
    }
 
    static FConstSharedStruct Make(const UScriptStruct* InScriptStruct, const uint8* InStructMemory = nullptr)
    {
        FConstSharedStruct SharedStruct;
        SharedStruct.InitializeAs(InScriptStruct, InStructMemory);
        return SharedStruct;
    }
 
    template<typename T, typename... TArgs>
    static FConstSharedStruct Make(TArgs&&... InArgs)
    {
        FConstSharedStruct SharedStruct;
        SharedStruct.InitializeAs<T>(Forward<TArgs>(InArgs)...);
        return SharedStruct;
    }
 
    template<typename T>
        requires (std::is_const_v<T>)
    constexpr T& Get() const
    {
        return UE::StructUtils::GetStructRef<T>(GetScriptStruct(), GetMemory());
    }
 
    template<typename T>
        requires (std::is_const_v<T>)
    constexpr T* GetPtr() const
    {
        return UE::StructUtils::GetStructPtr<T>(GetScriptStruct(), GetMemory());
    }
 
    bool IsValid() const
    {
        return GetMemory() != nullptr && GetScriptStruct() != nullptr;
    }
 
    template <typename OtherType>
    bool operator==(const OtherType& Other) const
    {
        return ((GetScriptStruct() == Other.GetScriptStruct()) && (GetMemory() == Other.GetMemory()));
    }
 
    template <typename OtherType>
    bool operator!=(const OtherType& Other) const
    {
        return !operator==(Other);
    }
 
    template <typename OtherType>
    bool CompareStructValues(const OtherType& Other, uint32 PortFlags = 0) const
    {
        UE::StructUtils::CheckWrapperType<OtherType>();
        const UScriptStruct* ScriptStruct = GetScriptStruct();
        return (ScriptStruct == Other.GetScriptStruct())
            && (!ScriptStruct || ScriptStruct->CompareScriptStruct(GetMemory(), Other.GetMemory(), PortFlags));
    }
 
protected:
 
    TSharedPtr<const FStructSharedMemory> StructMemoryPtr;
};
 
template<typename BaseStructT>
struct [[nodiscard]] TConstSharedStruct
{
    explicit TConstSharedStruct() = default;
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstSharedStruct(const TConstSharedStruct<T>& Other)
        : ConstSharedStruct(Other.ConstSharedStruct)
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstSharedStruct(const TSharedStruct<T>& ConstSharedStruct)
        : ConstSharedStruct(ConstSharedStruct.SharedStruct)
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstSharedStruct(TConstSharedStruct<T>&& Other)
        : ConstSharedStruct(MoveTemp(Other.ConstSharedStruct))
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstSharedStruct(TSharedStruct<T>&& ConstSharedStruct)
        : ConstSharedStruct(MoveTemp(ConstSharedStruct.SharedStruct))
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstSharedStruct& operator=(const TConstSharedStruct<T>& Other)
    {
        if (this == &Other)
        {
            ConstSharedStruct = Other.ConstSharedStruct;
        }
        return *this;
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstSharedStruct& operator=(const TSharedStruct<T>& SharedStruct)
    {
        if (this != &SharedStruct)
        {
            ConstSharedStruct = SharedStruct.SharedStruct;
        }
        return *this;
    }
 
    const uint8* GetMemory() const
    {
        return ConstSharedStruct.GetMemory();
    }
 
    void Reset()
    {
        ConstSharedStruct.Reset();
    }
 
    void Initialize()
    {
        ConstSharedStruct.InitializeAs<BaseStructT>();
    }
 
    template<typename T = BaseStructT>
        requires(
            std::is_base_of_v<BaseStructT, std::decay_t<T>>
            && !(std::is_same_v<TStructView<T>, T>
                || std::is_same_v<TConstStructView<T>, T>
                || std::is_same_v<TSharedStruct<T>, T>
                || std::is_same_v<TConstSharedStruct<T>, T>
                || std::is_same_v<TInstancedStruct<T>, T>))
    void Initialize(const T& Struct)
    {
        ConstSharedStruct.InitializeAs<T>(Struct);
    }
 
    template<typename T = BaseStructT, typename... TArgs>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    void Initialize(TArgs&&... InArgs)
    {
        ConstSharedStruct.InitializeAs<T>(Forward<TArgs>(InArgs)...);
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    static TConstSharedStruct Make()
    {
        FConstSharedStruct SharedStruct;
        SharedStruct.InitializeAs<BaseStructT>();
        return SharedStruct;
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    static TConstSharedStruct Make(const T& Struct)
    {
        FConstSharedStruct SharedStruct;
        SharedStruct.InitializeAs<BaseStructT>(Struct);
        return SharedStruct;
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    static TConstSharedStruct Make(const uint8* InStructMemory = nullptr)
    {
        TConstSharedStruct SharedStruct;
        SharedStruct.template Initialize<T>(InStructMemory);
        return SharedStruct;
    }
 
    template<typename T = BaseStructT, typename... TArgs>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    static TConstSharedStruct Make(TArgs&&... InArgs)
    {
        TConstSharedStruct SharedStruct;
        SharedStruct.template Initialize<T>(Forward<TArgs>(InArgs)...);
        return SharedStruct;
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    constexpr const T& Get() const
    {
        return ConstSharedStruct.Get<T>();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_const_v<T> && std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    constexpr T& Get() const
    {
        return ConstSharedStruct.Get<T>();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    constexpr const T* GetPtr() const
    {
        return ConstSharedStruct.GetPtr<T>();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_const_v<T> && std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    constexpr T* GetPtr() const
    {
        return ConstSharedStruct.GetPtr<T>();
    }
 
    bool IsValid() const
    {
        return ConstSharedStruct.IsValid();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    bool operator==(const T& Other) const
    {
        return ConstSharedStruct.operator==(Other);
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    bool operator!=(const T& Other) const
    {
        return ConstSharedStruct.operator!=(Other);
    }
 
private:
    FConstSharedStruct ConstSharedStruct;
 
    template <typename U> friend struct TConstSharedStruct;
};
 
template<>
struct TStructOpsTypeTraits<FConstSharedStruct> : public TStructOpsTypeTraitsBase2<FConstSharedStruct>
{
    enum
    {
        WithIdentical = true,
        WithAddStructReferencedObjects = true,
    };
};
 
#undef UE_API