Segment.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Assert.h"
#include "../Foundation/Span.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT SegmentHeader;
struct alignas(uint64_t) SegmentHeader
{
    static constexpr uint32_t MaxCapacity = (~static_cast<uint32_t>(0)) >> 1;
 
    uint32_t sizeBytes : sizeof(uint32_t) * 8 - 1;
    uint32_t isInlineBuffer : 1;
    uint32_t capacityBytes : sizeof(uint32_t) * 8 - 1;
    uint32_t isFollowedByInlineBuffer : 1;
    // clang-format off
    template <typename T>       T* getData()       { return reinterpret_cast<T*>(reinterpret_cast<char*>(this) + sizeof(*this)); }
    template <typename T> const T* getData() const { return reinterpret_cast<const T*>(reinterpret_cast<const char*>(this) + sizeof(*this)); }
    // clang-format on
};
 
 
template <typename VTable>
struct Segment
{
    using T = typename VTable::Type;
 
    Segment();
    ~Segment();
    Segment(Segment&& other);
    Segment(const Segment& other);
    Segment& operator=(Segment&& other);
    Segment& operator=(const Segment& other);
 
    template <typename U>
    Segment(Span<const U> span) : Segment()
    {
        SC_ASSERT_RELEASE(assign(span));
    }
 
    Segment(Span<const T> span) : Segment() { SC_ASSERT_RELEASE(assign(span)); }
 
    Segment(std::initializer_list<T> list) : Segment() { SC_ASSERT_RELEASE(assign({list.begin(), list.size()})); }
 
    [[nodiscard]] bool resizeWithoutInitializing(size_t newSize);
 
    [[nodiscard]] bool resize(size_t newSize, const T& value = T());
 
    [[nodiscard]] bool reserve(size_t newCapacity);
 
    [[nodiscard]] bool append(Span<const T> span);
 
    template <typename U>
    [[nodiscard]] bool append(Span<const U> span);
 
    [[nodiscard]] bool appendMove(Segment&& other);
 
    [[nodiscard]] bool shrink_to_fit();
 
    void clear();
 
    [[nodiscard]] bool assign(Span<const T> span);
 
    [[nodiscard]] bool assignMove(Segment&& other);
 
    [[nodiscard]] bool push_back(const T& value) { return resize(size() + 1, value); }
 
    [[nodiscard]] bool push_back(T&& value);
 
    [[nodiscard]] bool push_front(const T& value) { return insert(0, value); }
 
    [[nodiscard]] bool pop_back(T* removedValue = nullptr);
 
    [[nodiscard]] bool pop_front(T* removedValue = nullptr);
 
    // clang-format off
 
    [[nodiscard]] const T* data() const SC_LANGUAGE_LIFETIME_BOUND
    {
        return header == nullptr ? nullptr : reinterpret_cast<const T*>(reinterpret_cast<const char*>(header) + sizeof(SegmentHeader));
    }
 
    [[nodiscard]] T* data() SC_LANGUAGE_LIFETIME_BOUND
    {
        return header == nullptr ? nullptr : reinterpret_cast<T*>(reinterpret_cast<char*>(header) + sizeof(SegmentHeader));
    }
 
    [[nodiscard]] T*       begin()          SC_LANGUAGE_LIFETIME_BOUND { return data(); }
    [[nodiscard]] const T* begin() const    SC_LANGUAGE_LIFETIME_BOUND { return data(); }
    [[nodiscard]] T*       end()            SC_LANGUAGE_LIFETIME_BOUND { return data() + size(); }
    [[nodiscard]] const T* end() const      SC_LANGUAGE_LIFETIME_BOUND { return data() + size(); }
 
    [[nodiscard]] T& back()                 SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_RELEASE(not isEmpty()); return *(data() + size() - 1);}
    [[nodiscard]] T& front()                SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_RELEASE(not isEmpty()); return *data();}
    [[nodiscard]] T& operator[](size_t idx) SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(idx < size()); return *(data() + idx);}
    [[nodiscard]] const T& back() const     SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_RELEASE(not isEmpty()); return *(data() + size() - 1);}
    [[nodiscard]] const T& front() const    SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_RELEASE(not isEmpty()); return *data();}
    [[nodiscard]] const T& operator[](size_t idx) const SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(idx < size()); return *(data() + idx);}
 
    // clang-format on
 
    [[nodiscard]] bool isInlineBuffer() const { return header != nullptr and header->isInlineBuffer; }
 
    [[nodiscard]] bool isEmpty() const { return header == nullptr or header->sizeBytes == 0; }
 
    [[nodiscard]] Span<T> toSpan() SC_LANGUAGE_LIFETIME_BOUND { return {data(), size()}; }
 
    [[nodiscard]] Span<const T> toSpanConst() const SC_LANGUAGE_LIFETIME_BOUND { return {data(), size()}; }
 
    [[nodiscard]] size_t size() const { return header == nullptr ? 0 : header->sizeBytes / sizeof(T); }
 
    [[nodiscard]] size_t capacity() { return header == nullptr ? 0 : header->capacityBytes / sizeof(T); }
 
    [[nodiscard]] bool removeRange(size_t start, size_t length);
 
    [[nodiscard]] bool removeAt(size_t index) { return removeRange(index, 1); }
 
    [[nodiscard]] bool insert(size_t index, Span<const T> data);
 
    void unsafeSetHeader(SegmentHeader* newHeader) { header = newHeader; }
 
    [[nodiscard]] SegmentHeader* unsafeGetHeader() const { return header; }
 
    Segment(SegmentHeader& inlineHeader, uint32_t capacityInBytes);
 
  protected:
    struct Internal;
    // Alignment is relevant for 32 bit platforms
    alignas(alignof(SegmentHeader)) SegmentHeader* header;
};
 
struct SC_COMPILER_EXPORT SegmentTrivial
{
    static void destruct(SegmentHeader& header, size_t bytesOffset, size_t numBytes);
    static void copyConstructSingle(SegmentHeader& dest, size_t bytesOffset, const void* value, size_t numBytes,
                                    size_t valueSize);
    static void copyConstruct(SegmentHeader& dest, size_t bytesOffset, const void* src, size_t numBytes);
    static void copyAssign(SegmentHeader& dest, size_t bytesOffset, const void* src, size_t numBytes);
    static void copyInsert(SegmentHeader& dest, size_t bytesOffset, const void* src, size_t numBytes);
    static void moveConstruct(SegmentHeader& dest, size_t bytesOffset, void* src, size_t numBytes);
    static void moveAssign(SegmentHeader& dest, size_t bytesOffset, void* src, size_t numBytes);
    static void remove(SegmentHeader& dest, size_t fromBytesOffset, size_t toBytesOffset);
};
 
struct SC_COMPILER_EXPORT SegmentAllocator
{
    static SegmentHeader* allocateNewHeader(size_t newCapacityInBytes);
    static SegmentHeader* reallocateExistingHeader(SegmentHeader& src, size_t newCapacityInBytes);
 
    static void destroyHeader(SegmentHeader& header);
};
} // namespace SC