UniversalObjectLocatorResolveParameterBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Math/UnrealMathUtility.h"
#include "UniversalObjectLocatorFwd.h"
#include "UniversalObjectLocatorParameterTypeHandle.h"
 
class UObject;
 
namespace UE::UniversalObjectLocator
{
 
 
struct FResolveParameterHeader
{
    // 2 Bytes
    uint16 ParameterOffset = 0;
 
    // 1 Byte
    uint8 Sizeof = 0;
 
    // 1 Byte
    uint8 Alignment = 0;
 
    void* Resolve(void* InMemory) const
    {
        return static_cast<uint8*>(InMemory) + ParameterOffset;
    }
};
 
struct FResolveParameterBuffer
{
    UNIVERSALOBJECTLOCATOR_API FResolveParameterBuffer();
 
    UNIVERSALOBJECTLOCATOR_API ~FResolveParameterBuffer();
 
    FResolveParameterBuffer(const FResolveParameterBuffer&) = delete;
    FResolveParameterBuffer& operator=(const FResolveParameterBuffer&) = delete;
 
    FResolveParameterBuffer(FResolveParameterBuffer&& RHS) = delete;
    FResolveParameterBuffer& operator=(FResolveParameterBuffer&& RHS) = delete;
 
public:
 
    template<typename T>
    const T* FindParameter() const;
 
 
    template<typename T>
    const T* FindParameter(TParameterTypeHandle<T> ParameterTypeHandle) const;
 
 
    template<typename T, typename ...ArgTypes>
    T* AddParameter(TParameterTypeHandle<T> ParameterTypeHandle, ArgTypes&&... InArgs);
 
protected:
 
    bool HasParameter(uint32 ParameterBit) const;
 
    const void* FindParameterImpl(uint32 ParameterBit) const;
 
 
    template<typename ParameterType, typename ...ArgTypes>
    ParameterType* AddParameterImpl(uint32 ParameterBit, ArgTypes&&... InArgs);
 
 
    const FResolveParameterHeader& GetHeader(uint8 Index) const;
 
 
    int32 GetParameterIndex(uint32 ParameterBit) const;
 
 
    void Destroy();
 
protected:
 
    uint8* Memory = nullptr;
 
    uint32 AllParameters = 0u;
 
    uint16 Capacity = 0u;
 
    uint8 Num = 0u;
 
    bool bCanFreeMemory = false;
 
public:
 
    static constexpr int32 MaxNumParameters = sizeof(AllParameters) * 8;
};
 
template<int InlineByteSize>
struct alignas(8) TInlineResolveParameterBuffer : FResolveParameterBuffer
{
    TInlineResolveParameterBuffer()
    {
        Memory = InlineBuffer;
        Capacity = InlineByteSize;
 
        bCanFreeMemory = false;
    }
 
private:
 
    uint8 InlineBuffer[InlineByteSize];
};
 
 
template<typename T>
const T* FResolveParameterBuffer::FindParameter() const
{
    return FindParameter(T::ParameterType);
}
 
template<typename T>
const T* FResolveParameterBuffer::FindParameter(TParameterTypeHandle<T> ParameterTypeHandle) const
{
    const uint8 ParameterIndex = ParameterTypeHandle.GetIndex();
 
    const uint32 ParameterBit = 1 << ParameterIndex;
    return static_cast<const T*>(FindParameterImpl(ParameterBit));
}
 
inline bool FResolveParameterBuffer::HasParameter(uint32 ParameterBit) const
{
    return (AllParameters & ParameterBit) != 0;
}
 
inline const void* FResolveParameterBuffer::FindParameterImpl(uint32 ParameterBit) const
{
    if (HasParameter(ParameterBit))
    {
        const int32 Index = GetParameterIndex(ParameterBit);
        check(Index >= 0 && Index < 255);
        return GetHeader(static_cast<uint8>(Index)).Resolve(Memory);
    }
 
    return nullptr;
}
 
inline const FResolveParameterHeader& FResolveParameterBuffer::GetHeader(uint8 Index) const
{
    check(Index < Num);
    return reinterpret_cast<FResolveParameterHeader*>(Memory)[Index];
}
 
inline int32 FResolveParameterBuffer::GetParameterIndex(uint32 ParameterBit) const
{
    if ( (AllParameters & ParameterBit) == 0)
    {
        return INDEX_NONE;
    }
    return FMath::CountBits(AllParameters & (ParameterBit-1u));
}
 
} // namespace UE::UniversalObjectLocator