CompositeBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainersFwd.h"
#include "HAL/Platform.h"
#include "Math/NumericLimits.h"
#include "Memory/MemoryFwd.h"
#include "Memory/MemoryView.h"
#include "Memory/SharedBuffer.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/FunctionFwd.h"
 
#include <type_traits>
 
class FCompositeBuffer
{
    template <typename BufferType>
    using CanAppendBufferType = std::bool_constant<
        std::is_same_v<FCompositeBuffer, BufferType> ||
        std::is_same_v<FSharedBuffer, BufferType> ||
        TIsTArray_V<BufferType>>;
 
public:
    template <typename... BufferTypes,
        std::enable_if_t<std::conjunction_v<CanAppendBufferType<std::decay_t<BufferTypes>>...>>* = nullptr>
    inline explicit FCompositeBuffer(BufferTypes&&... Buffers)
    {
        if constexpr (sizeof...(Buffers) > 0)
        {
            Segments.Reserve((GetBufferCount(Forward<BufferTypes>(Buffers)) + ...));
            (AppendBuffers(Forward<BufferTypes>(Buffers)), ...);
            Segments.RemoveAll(&FSharedBuffer::IsNull);
        }
    }
 
    CORE_API ~FCompositeBuffer();
 
    CORE_API void Reset();
 
    [[nodiscard]] CORE_API uint64 GetSize() const;
 
    [[nodiscard]] inline TConstArrayView<FSharedBuffer> GetSegments() const { return Segments; }
 
    [[nodiscard]] inline explicit operator bool() const { return !IsNull(); }
 
    [[nodiscard]] inline bool IsNull() const { return Segments.IsEmpty(); }
 
    [[nodiscard]] CORE_API bool IsOwned() const;
 
    [[nodiscard]] CORE_API FCompositeBuffer MakeOwned() const &;
    [[nodiscard]] CORE_API FCompositeBuffer MakeOwned() &&;
 
    [[nodiscard]] CORE_API FSharedBuffer ToShared() const &;
    [[nodiscard]] CORE_API FSharedBuffer ToShared() &&;
 
    [[nodiscard]] CORE_API FCompositeBuffer Mid(uint64 Offset, uint64 Size = MAX_uint64) const;
 
    [[nodiscard]] CORE_API FMemoryView ViewOrCopyRange(
        uint64 Offset,
        uint64 Size,
        FUniqueBuffer& CopyBuffer) const;
    [[nodiscard]] CORE_API FMemoryView ViewOrCopyRange(
        uint64 Offset,
        uint64 Size,
        FUniqueBuffer& CopyBuffer,
        TFunctionRef<FUniqueBuffer (uint64 Size)> Allocator) const;
 
    CORE_API void CopyTo(FMutableMemoryView Target, uint64 Offset = 0) const;
 
    CORE_API void IterateRange(uint64 Offset, uint64 Size,
        TFunctionRef<void (FMemoryView View)> Visitor) const;
    CORE_API void IterateRange(uint64 Offset, uint64 Size,
        TFunctionRef<void (FMemoryView View, const FSharedBuffer& ViewOuter)> Visitor) const;
 
    [[nodiscard]] CORE_API bool EqualBytes(const FCompositeBuffer& Other) const;
 
    CORE_API static const FCompositeBuffer Null;
 
private:
    static inline int32 GetBufferCount(const FCompositeBuffer& Buffer) { return Buffer.Segments.Num(); }
    inline void AppendBuffers(const FCompositeBuffer& Buffer) { Segments.Append(Buffer.Segments); }
    inline void AppendBuffers(FCompositeBuffer&& Buffer) { Segments.Append(MoveTemp(Buffer.Segments)); }
 
    static inline int32 GetBufferCount(const FSharedBuffer& Buffer) { return 1; }
    inline void AppendBuffers(const FSharedBuffer& Buffer) { Segments.Add(Buffer); }
    inline void AppendBuffers(FSharedBuffer&& Buffer) { Segments.Add(MoveTemp(Buffer)); }
 
    template <typename BufferType, decltype(std::declval<TArray<FSharedBuffer>>().Append(std::declval<BufferType>()))* = nullptr>
    static inline int32 GetBufferCount(BufferType&& Buffer) { return GetNum(Buffer); }
    template <typename BufferType, decltype(std::declval<TArray<FSharedBuffer>>().Append(std::declval<BufferType>()))* = nullptr>
    inline void AppendBuffers(BufferType&& Buffer) { Segments.Append(Forward<BufferType>(Buffer)); }
 
private:
    TArray<FSharedBuffer, TInlineAllocator<1>> Segments;
};