Buffer.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Internal/IGrowableBuffer.h"
#include "../Memory/Memory.h"
#include "../Memory/Segment.h"
 
namespace SC
{
 
 
namespace detail
{
struct SC_MEMORY_EXPORT SegmentBuffer : public SegmentTrivial<char>, public SegmentSelfRelativePointer<char>
{
    static constexpr bool IsArray = false;
};
} // namespace detail
 
struct SC_MEMORY_EXPORT Buffer : public Segment<detail::SegmentBuffer>
{
    using Segment::Segment;
};
 
template <int N>
struct SmallBuffer : public Buffer
{
    SmallBuffer(SegmentAllocator allocator = SegmentAllocator::Global) noexcept : Buffer(N, allocator) {}
    SmallBuffer(const Buffer& other) noexcept : SmallBuffer() { Buffer::operator=(other); }
    SmallBuffer(Buffer&& other) noexcept : SmallBuffer() { Buffer::operator=(move(other)); }
    Buffer& operator=(const Buffer& other) noexcept { return Buffer::operator=(other); }
    Buffer& operator=(Buffer&& other) noexcept { return Buffer::operator=(move(other)); }
 
    // clang-format off
    SmallBuffer(const SmallBuffer& other) noexcept : SmallBuffer() { Buffer::operator=(other); }
    SmallBuffer(SmallBuffer&& other) noexcept : SmallBuffer() { Buffer::operator=(move(other)); }
    SmallBuffer& operator=(const SmallBuffer& other) noexcept { Buffer::operator=(other); return *this; }
    SmallBuffer& operator=(SmallBuffer&& other) noexcept { Buffer::operator=(move(other)); return *this; }
    // clang-format on
 
  protected:
    SmallBuffer(int num, SegmentAllocator allocator) : Buffer(N, allocator) { (void)num; }
 
  private:
    uint64_t inlineCapacity = N;
    char     inlineBuffer[N];
};
 
using BufferTL = detail::SegmentCustom<Buffer, Buffer, 0, SegmentAllocator::ThreadLocal>;
template <int N>
using SmallBufferTL = detail::SegmentCustom<SmallBuffer<N>, Buffer, N, SegmentAllocator::ThreadLocal>;
 
#if SC_COMPILER_MSVC
// Adding the SC_MEMORY_EXPORT on Buffer declaration causes MSVC to issue error C2491
struct SC_MEMORY_EXPORT Buffer;
#endif
 
// Enables File library from reading data from file descriptor into a Buffer
template <>
struct SC_MEMORY_EXPORT GrowableBuffer<Buffer> : public IGrowableBuffer
{
    Buffer& buffer;
    GrowableBuffer(Buffer& buffer) noexcept;
    ~GrowableBuffer() noexcept;
    static bool tryGrowTo(IGrowableBuffer&, size_t newSize) noexcept;
    void        finalize() noexcept;
};
 
template <int N>
struct SC_MEMORY_EXPORT GrowableBuffer<SmallBuffer<N>> : public IGrowableBuffer
{
    Buffer& buffer;
    GrowableBuffer(Buffer& buffer) noexcept : IGrowableBuffer(&GrowableBuffer::tryGrowTo), buffer(buffer)
    {
        IGrowableBuffer::directAccess = {buffer.size(), buffer.capacity(), buffer.data()};
    }
    ~GrowableBuffer() noexcept { finalize(); }
 
    static bool tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept
    {
        GrowableBuffer& self   = static_cast<GrowableBuffer&>(gb);
        const bool      result = self.buffer.resizeWithoutInitializing(newSize);
        self.directAccess      = {self.buffer.size(), self.buffer.capacity(), self.buffer.data()};
        return result;
    }
    void finalize() noexcept { (void)buffer.resizeWithoutInitializing(IGrowableBuffer::directAccess.sizeInBytes); }
};
} // namespace SC