MemoryView.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "HAL/PlatformString.h"
#include "Math/NumericLimits.h"
#include "Math/UnrealMathUtility.h"
#include "Memory/MemoryFwd.h" // IWYU pragma: export
#include "Templates/AndOrNot.h"
#include "Templates/EnableIf.h"
#include "Templates/Identity.h"
#include "Templates/PointerIsConvertibleFromTo.h"
#include "Templates/UnrealTemplate.h"
#include "Traits/IsContiguousContainer.h"
 
#include <initializer_list>
#include <type_traits>
 
template <typename DataType>
class TMemoryView
{
    static_assert(std::is_void_v<DataType>, "DataType must be cv-qualified void");
 
    using ByteType = std::conditional_t<std::is_const_v<DataType>, const uint8, uint8>;
 
public:
    constexpr TMemoryView() = default;
 
    template <
        typename OtherDataType
        UE_REQUIRES(std::is_convertible_v<OtherDataType*, DataType*>)
    >
    constexpr inline TMemoryView(const TMemoryView<OtherDataType>& InView)
        : Data(InView.Data)
        , Size(InView.Size)
    {
    }
 
    constexpr inline TMemoryView(DataType* InData, uint64 InSize)
        : Data(InData)
        , Size(InSize)
    {
    }
 
    template <
        typename DataEndType
        UE_REQUIRES(std::is_convertible_v<DataEndType*, DataType*>)
    >
    inline TMemoryView(DataType* InData, DataEndType* InDataEnd)
        : Data(InData)
        , Size(static_cast<uint64>(static_cast<ByteType*>(ImplicitConv<DataType*>(InDataEnd)) - static_cast<ByteType*>(InData)))
    {
    }
 
    [[nodiscard]] constexpr inline DataType* GetData() const { return Data; }
 
    [[nodiscard]] inline DataType* GetDataEnd() const { return GetDataAtOffsetNoCheck(Size); }
 
    [[nodiscard]] constexpr inline uint64 GetSize() const { return Size; }
 
    [[nodiscard]] constexpr inline bool IsEmpty() const { return Size == 0; }
 
    constexpr inline void Reset() { *this = TMemoryView(); }
 
    [[nodiscard]] constexpr inline TMemoryView Left(uint64 InSize) const
    {
        TMemoryView View(*this);
        View.LeftInline(InSize);
        return View;
    }
 
    [[nodiscard]] constexpr inline TMemoryView LeftChop(uint64 InSize) const
    {
        TMemoryView View(*this);
        View.LeftChopInline(InSize);
        return View;
    }
 
    [[nodiscard]] inline TMemoryView Right(uint64 InSize) const
    {
        TMemoryView View(*this);
        View.RightInline(InSize);
        return View;
    }
 
    [[nodiscard]] inline TMemoryView RightChop(uint64 InSize) const
    {
        TMemoryView View(*this);
        View.RightChopInline(InSize);
        return View;
    }
 
    [[nodiscard]] inline TMemoryView Mid(uint64 InOffset, uint64 InSize = TNumericLimits<uint64>::Max()) const
    {
        TMemoryView View(*this);
        View.MidInline(InOffset, InSize);
        return View;
    }
 
    constexpr inline void LeftInline(uint64 InSize)
    {
        Size = FMath::Min(Size, InSize);
    }
 
    constexpr inline void LeftChopInline(uint64 InSize)
    {
        Size -= FMath::Min(Size, InSize);
    }
 
    inline void RightInline(uint64 InSize)
    {
        const uint64 OldSize = Size;
        const uint64 NewSize = FMath::Min(OldSize, InSize);
        Data = GetDataAtOffsetNoCheck(OldSize - NewSize);
        Size = NewSize;
    }
 
    inline void RightChopInline(uint64 InSize)
    {
        const uint64 Offset = FMath::Min(Size, InSize);
        Data = GetDataAtOffsetNoCheck(Offset);
        Size -= Offset;
    }
 
    inline void MidInline(uint64 InOffset, uint64 InSize = TNumericLimits<uint64>::Max())
    {
        RightChopInline(InOffset);
        LeftInline(InSize);
    }
 
    template <typename OtherDataType>
    [[nodiscard]] inline bool Contains(const TMemoryView<OtherDataType>& InView) const
    {
        return Data <= InView.Data && GetDataAtOffsetNoCheck(Size) >= InView.GetDataAtOffsetNoCheck(InView.Size);
    }
 
    template <typename OtherDataType>
    [[nodiscard]] inline bool Intersects(const TMemoryView<OtherDataType>& InView) const
    {
        return Data < InView.GetDataAtOffsetNoCheck(InView.Size) && InView.Data < GetDataAtOffsetNoCheck(Size);
    }
 
    template <typename OtherDataType>
    [[nodiscard]] inline int32 CompareBytes(const TMemoryView<OtherDataType>& InView) const
    {
        const int32 Compare = Data == InView.Data ? 0 : FMemory::Memcmp(Data, InView.Data, FMath::Min(Size, InView.Size));
        return Compare || Size == InView.Size ? Compare : Size < InView.Size ? -1 : 1;
    }
 
    template <typename OtherDataType>
    [[nodiscard]] inline bool EqualBytes(const TMemoryView<OtherDataType>& InView) const
    {
        return Size == InView.Size && (Data == InView.Data || FMemory::Memcmp(Data, InView.Data, Size) == 0);
    }
 
    template <typename OtherDataType>
    [[nodiscard]] constexpr inline bool Equals(const TMemoryView<OtherDataType>& InView) const
    {
        return Size == InView.Size && (Size == 0 || Data == InView.Data);
    }
 
    template <typename OtherDataType>
    [[nodiscard]] constexpr inline bool operator==(const TMemoryView<OtherDataType>& InView) const
    {
        return Equals(InView);
    }
 
    template <typename OtherDataType>
    [[nodiscard]] constexpr inline bool operator!=(const TMemoryView<OtherDataType>& InView) const
    {
        return !Equals(InView);
    }
 
    constexpr inline TMemoryView& operator+=(uint64 InOffset)
    {
        RightChopInline(InOffset);
        return *this;
    }
 
    inline TMemoryView CopyFrom(FMemoryView InView) const
    {
        checkf(InView.Size <= Size, TEXT("Failed to copy from a view of %" UINT64_FMT " bytes "
            "to a view of %" UINT64_FMT " bytes."), InView.Size, Size);
        if (InView.Size)
        {
            FMemory::Memcpy(Data, InView.Data, InView.Size);
        }
        return RightChop(InView.Size);
    }
 
private:
    [[nodiscard]] inline DataType* GetDataAtOffsetNoCheck(uint64 InOffset) const
    {
        return reinterpret_cast<ByteType*>(Data) + InOffset;
    }
 
    template <typename OtherDataType>
    friend class TMemoryView;
 
private:
    DataType* Data = nullptr;
    uint64 Size = 0;
};
 
template <typename DataType>
[[nodiscard]] constexpr inline TMemoryView<DataType> operator+(const TMemoryView<DataType>& View, uint64 Offset)
{
    return TMemoryView<DataType>(View) += Offset;
}
 
template <typename DataType>
[[nodiscard]] constexpr inline TMemoryView<DataType> operator+(uint64 Offset, const TMemoryView<DataType>& View)
{
    return TMemoryView<DataType>(View) += Offset;
}
 
[[nodiscard]] constexpr inline TMemoryView<void> MakeMemoryView(void* Data, uint64 Size)
{
    return TMemoryView<void>(Data, Size);
}
 
[[nodiscard]] constexpr inline TMemoryView<const void> MakeMemoryView(const void* Data, uint64 Size)
{
    return TMemoryView<const void>(Data, Size);
}
 
template <typename DataType, typename DataEndType>
[[nodiscard]] inline auto MakeMemoryView(DataType* Data, DataEndType* DataEnd)
{
    // This function is templated on pointer type to prevent MakeMemoryView(Ptr, 0) being deduced as a null end pointer
 
    using VoidType = std::conditional_t<std::is_const_v<DataType> || std::is_const_v<DataEndType>, const void, void>;
 
    return TMemoryView<VoidType>(Data, DataEnd);
}
 
template <typename T>
[[nodiscard]] constexpr inline TMemoryView<const void> MakeMemoryView(std::initializer_list<typename TIdentity<T>::Type> List)
{
    return TMemoryView<const void>(GetData(List), GetNum(List) * sizeof(T));
}
 
template <
    typename ContainerType
    UE_REQUIRES(TIsContiguousContainer<ContainerType>::Value)
>
[[nodiscard]] constexpr inline auto MakeMemoryView(ContainerType&& Container)
{
    using ElementType = typename TRemovePointer<decltype(GetData(DeclVal<ContainerType>()))>::Type;
    constexpr bool bIsConst = std::is_const_v<ElementType>;
    using DataType = std::conditional_t<bIsConst, const void, void>;
    return TMemoryView<DataType>(GetData(Container), GetNum(Container) * sizeof(ElementType));
}
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_7
#include "Templates/IsConst.h"
#endif