StructView.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "StructUtils/InstancedStruct.h"
#include "StructUtils/SharedStruct.h"
#include "StructUtils.h"
#include <type_traits>
 
 
struct [[nodiscard]] FStructView
{
public:
 
    FStructView() = default;
 
    FStructView(const UScriptStruct* InScriptStruct, uint8* InStructMemory = nullptr)
        : ScriptStruct(InScriptStruct)
        , StructMemory(InStructMemory)
    {}
 
    FStructView(FInstancedStruct& InstancedStruct)
        : FStructView(InstancedStruct.GetScriptStruct(), InstancedStruct.GetMutableMemory())
    {}
 
    FStructView(const FSharedStruct& SharedStruct)
        : FStructView(SharedStruct.GetScriptStruct(), SharedStruct.GetMemory())
    {}
 
    template<typename T>
    static FStructView Make(T& InStruct)
    {
        UE::StructUtils::CheckStructType<T>();
        return FStructView(TBaseStructure<T>::Get(), reinterpret_cast<uint8*>(&InStruct));
    }
 
    template<typename T>
    T& Get() const
    {
        return UE::StructUtils::GetStructRef<T>(ScriptStruct, StructMemory);
    }
 
    template<typename T>
    T* GetPtr() const
    {
        return UE::StructUtils::GetStructPtr<T>(ScriptStruct, StructMemory);
    }
 
    const UScriptStruct* GetScriptStruct() const
    {
        return ScriptStruct;
    }
 
    uint8* GetMemory() const
    {
        return StructMemory;
    }
 
    void Reset()
    {
        StructMemory = nullptr;
        ScriptStruct = nullptr;
    }
 
    bool IsValid() const
    {
        return StructMemory != nullptr && ScriptStruct != nullptr;
    }
 
    template <typename OtherType>
    bool operator==(const OtherType& Other) const
    {
        return ((ScriptStruct == Other.GetScriptStruct()) && (StructMemory == Other.GetMemory()));
    }
 
    template <typename OtherType>
    bool operator!=(const OtherType& Other) const
    {
        return !operator==(Other);
    }
 
protected:
    const UScriptStruct* ScriptStruct = nullptr;
    uint8* StructMemory = nullptr;
};
 
template<typename BaseStructT>
struct [[nodiscard]] TStructView : FStructView
{
public:
 
    explicit TStructView() = default;
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TStructView(T& InStruct)
        : FStructView(T::StaticStruct(), reinterpret_cast<uint8*>(&InStruct))
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    explicit TStructView(uint8* InStructMemory = nullptr)
        : FStructView(T::StaticStruct(), InStructMemory)
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    explicit TStructView(const UScriptStruct* InScriptStruct, uint8* InStructMemory = nullptr)
        : FStructView(InScriptStruct, InStructMemory)
    {
        checkf(!InScriptStruct || InScriptStruct->IsChildOf(TBaseStructure<T>::Get()), TEXT("Struct type must be a child of T!"));
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TStructView(TInstancedStruct<T>& InstancedStruct)
        : FStructView(InstancedStruct.GetScriptStruct(), InstancedStruct.GetMutableMemory())
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TStructView(const TSharedStruct<T>& SharedStruct)
        : FStructView(SharedStruct.GetScriptStruct(), SharedStruct.GetMemory())
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    T& Get() const
    {
        return UE::StructUtils::GetStructRef<T>(ScriptStruct, StructMemory);
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    T* GetPtr() const
    {
        return UE::StructUtils::GetStructPtr<T, BaseStructT>(ScriptStruct, StructMemory);
    }
 
    BaseStructT* operator->() const
    {
        check(IsValid());
        return GetPtr();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    bool operator==(const TStructView<T>& Other) const
    {
        return ((ScriptStruct == Other.GetScriptStruct()) && (StructMemory == Other.GetMemory()));
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    bool operator!=(const TStructView<T>& Other) const
    {
        return !operator==(Other);
    }
};
 
 
struct [[nodiscard]] FConstStructView
{
public:
 
    FConstStructView() = default;
 
    FConstStructView(const UScriptStruct* InScriptStruct, const uint8* InStructMemory = nullptr)
        : ScriptStruct(InScriptStruct)
        , StructMemory(InStructMemory)
    {}
 
    FConstStructView(const FInstancedStruct& InstancedStruct)
        : FConstStructView(InstancedStruct.GetScriptStruct(), InstancedStruct.GetMemory())
    {}
 
    FConstStructView(const FSharedStruct& SharedStruct)
        : FConstStructView(SharedStruct.GetScriptStruct(), SharedStruct.GetMemory())
    {}
 
    FConstStructView(const FConstSharedStruct& SharedStruct)
        : FConstStructView(SharedStruct.GetScriptStruct(), SharedStruct.GetMemory())
    {}
 
    FConstStructView(const FStructView StructView)
        : FConstStructView(StructView.GetScriptStruct(), StructView.GetMemory())
 
    {}
 
    template<typename T>
    static FConstStructView Make(const T& Struct)
    {
        UE::StructUtils::CheckStructType<T>();
        return FConstStructView(TBaseStructure<T>::Get(), reinterpret_cast<const uint8*>(&Struct));
    }
 
    template<typename T>
        requires (std::is_const_v<T>)
    constexpr T& Get() const
    {
        return UE::StructUtils::GetStructRef<T>(ScriptStruct, StructMemory);
    }
 
    template<typename T>
        requires (std::is_const_v<T>)
    constexpr T* GetPtr() const
    {
        return UE::StructUtils::GetStructPtr<T>(ScriptStruct, StructMemory);
    }
 
    const UScriptStruct* GetScriptStruct() const
    {
        return ScriptStruct;
    }
 
    const uint8* GetMemory() const
    {
        return StructMemory;
    }
 
    void Reset()
    {
        StructMemory = nullptr;
        ScriptStruct = nullptr;
    }
 
    bool IsValid() const
    {
        return StructMemory != nullptr && ScriptStruct != nullptr;
    }
 
    template <typename OtherType>
    bool operator==(const OtherType& Other) const
    {
        return ((ScriptStruct == Other.GetScriptStruct()) && (StructMemory == Other.GetMemory()));
    }
 
    template <typename OtherType>
    bool operator!=(const OtherType& Other) const
    {
        return !operator==(Other);
    }
 
    void SetStructData(const UScriptStruct* InScriptStruct, const uint8* InStructMemory)
    {
        ScriptStruct = InScriptStruct;
        StructMemory = InStructMemory;
    }
 
protected:
    const UScriptStruct* ScriptStruct = nullptr;
    const uint8* StructMemory = nullptr;
};
 
template<typename BaseStructT>
struct [[nodiscard]] TConstStructView : FConstStructView
{
    explicit TConstStructView() = default;
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstStructView(const T& InStruct)
        : FConstStructView(T::StaticStruct(), reinterpret_cast<const uint8*>(&InStruct))
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    explicit TConstStructView(const uint8* InStructMemory = nullptr)
        : FConstStructView(T::StaticStruct(), InStructMemory)
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstStructView(const TInstancedStruct<T>& InstancedStruct)
        : FConstStructView(InstancedStruct.GetScriptStruct(), InstancedStruct.GetMemory())
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstStructView(const TSharedStruct<T>& SharedStruct)
        : FConstStructView(SharedStruct.GetScriptStruct(), SharedStruct.GetMemory())
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstStructView(const TConstSharedStruct<T>& SharedStruct)
        : FConstStructView(SharedStruct.GetScriptStruct(), SharedStruct.GetMemory())
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    TConstStructView(const TStructView<T> StructView)
        : FConstStructView(StructView.GetScriptStruct(), StructView.GetMemory())
    {
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    constexpr const T& Get() const
    {
        return UE::StructUtils::GetStructRef<T>(ScriptStruct, StructMemory);
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    constexpr const T* GetPtr() const
    {
        return UE::StructUtils::GetStructPtr<T, BaseStructT>(ScriptStruct, StructMemory);
    }
 
    BaseStructT* operator->() const
    {
        check(IsValid());
        return GetPtr();
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    bool operator==(const TConstStructView<T>& Other) const
    {
        return ((ScriptStruct == Other.GetScriptStruct()) && (StructMemory == Other.GetMemory()));
    }
 
    template<typename T = BaseStructT>
        requires (std::is_base_of_v<BaseStructT, std::decay_t<T>>)
    bool operator!=(const TConstStructView<T>& Other) const
    {
        return !operator==(Other);
    }
};