Segment.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Assert.h"
#include "../Foundation/Span.h"
#include "../Memory/Memory.h"
#if SC_COMPILER_FILC
#include <stdfil.h>
#endif
 
namespace SC
{
enum class SegmentAllocator
{
    Global      = 0,
    ThreadLocal = 1,
};
 
namespace detail
{
struct SC_MEMORY_EXPORT SegmentHeader;
struct alignas(uint64_t) SegmentHeader
{
    static constexpr uint32_t MaxCapacity = (~static_cast<uint32_t>(0)) >> 1;
 
    SegmentHeader(uint32_t capacity = 0, SegmentAllocator allocator = SegmentAllocator::Global)
    {
        sizeBytes     = 0;
        allocatorType = static_cast<uint32_t>(allocator);
        capacityBytes = capacity;
        hasInlineData = capacity > 0;
    }
    uint32_t sizeBytes : sizeof(uint32_t) * 8 - 1;
    uint32_t allocatorType : 1;
    uint32_t capacityBytes : sizeof(uint32_t) * 8 - 1;
    uint32_t hasInlineData : 1;
};
 
struct SC_MEMORY_EXPORT SegmentHeaderOffset
{
    using PtrOffset = size_t;
    SegmentHeader header;
    PtrOffset     offset = 0; // memory offset representing relative pointer to data from "this"
};
 
#if SC_COMPILER_FILC
inline zexact_ptrtable* filcExactPtrTable() noexcept
{
    static zexact_ptrtable* table = zexact_ptrtable_new();
    return table;
}
 
template <typename T>
inline T* filcResolveRelativePointer(const void* self, size_t address) noexcept
{
    const size_t lower = reinterpret_cast<size_t>(zgetlower(const_cast<void*>(self)));
    const size_t upper = reinterpret_cast<size_t>(zgetupper(const_cast<void*>(self)));
    if (address >= lower and address < upper)
        return static_cast<T*>(zmkptr(const_cast<void*>(self), static_cast<unsigned long>(address)));
    return static_cast<T*>(zexact_ptrtable_decode(filcExactPtrTable(), address));
}
#endif
 
template <typename T>
struct SC_MEMORY_EXPORT SegmentSelfRelativePointer : protected SegmentHeaderOffset
{
    // clang-format off
    SC_COMPILER_FORCE_INLINE T*       data() noexcept
    {
#if SC_COMPILER_FILC
        if (offset == 0)
            return nullptr;
        const auto address = toOffset(this) + offset;
        if (header.hasInlineData and offset == inlineDataOffset())
            return static_cast<T*>(zmkptr(this, static_cast<unsigned long>(address)));
        return filcResolveRelativePointer<T>(this, address);
#else
        return offset == 0 ? nullptr : toPtr(toOffset(this) + offset);
#endif
    }
    SC_COMPILER_FORCE_INLINE const T* data() const noexcept
    {
#if SC_COMPILER_FILC
        if (offset == 0)
            return nullptr;
        const auto address = toOffset(this) + offset;
        if (header.hasInlineData and offset == inlineDataOffset())
            return static_cast<const T*>(zmkptr(const_cast<SegmentSelfRelativePointer*>(this), static_cast<unsigned long>(address)));
        return filcResolveRelativePointer<const T>(this, address);
#else
        return offset == 0 ? nullptr : toPtr(toOffset(this) + offset);
#endif
    }
    SC_COMPILER_FORCE_INLINE bool     isInline() const noexcept { return (offset == inlineDataOffset()) and header.hasInlineData; }
 
  protected:
    struct InlineData : public SegmentHeaderOffset // Data layout corresponds to SmallBuffer, SmallVector etc.
    {
        uint64_t capacity; // Could use uint32_t but we need to align data to 64 bit anyway
        ~InlineData() {}
        union
        {
            T data[1]; // Accessing the whole class through volatile cast anyway so array size can be whatever
        };
    };
    SC_COMPILER_FORCE_INLINE static constexpr PtrOffset inlineDataOffset() noexcept { return sizeof(SegmentHeaderOffset) + sizeof(uint64_t); }
    SC_COMPILER_FORCE_INLINE static auto toOffset(const volatile void* src) noexcept { return reinterpret_cast<PtrOffset>(src); }
    SC_COMPILER_FORCE_INLINE static T*   toPtr(PtrOffset src) noexcept { return reinterpret_cast<T*>(src); }
    SC_COMPILER_FORCE_INLINE void setData(T* mem) noexcept
    {
        offset = mem == nullptr ? 0 : toOffset(mem) - toOffset(this);
#if SC_COMPILER_FILC
        if (mem != nullptr and not (header.hasInlineData and mem == getInlineData()))
            (void)zexact_ptrtable_encode(filcExactPtrTable(), mem);
#endif
    }
    SC_COMPILER_FORCE_INLINE T*   getInlineData() noexcept { return (T*)reinterpret_cast<volatile InlineData*>(this)->data; }
    SC_COMPILER_FORCE_INLINE auto getInlineCapacity() noexcept { return reinterpret_cast<volatile InlineData*>(this)->capacity; }
    // clang-format on
};
 
template <typename T>
struct SC_MEMORY_EXPORT SegmentTrivial
{
    using Type = T;
    inline static void destruct(Span<T> data) noexcept;
    // clang-format off
    template <typename U> inline static void copyConstructAs(Span<T> data, Span<const U> value) noexcept;
    template <typename U> inline static void copyConstruct(Span<T> data, const U* src) noexcept;
    template <typename U> inline static void copyAssign(Span<T> data, const U* src) noexcept;
    template <typename U> inline static void copyInsert(Span<T> data, Span<const U> values) noexcept;
    template <typename U> inline static void moveConstruct(Span<T> data, U* src) noexcept;
    template <typename U> inline static void moveAssign(Span<T> data, U* src) noexcept;
    // clang-format on
    inline static void remove(Span<T> data, size_t numElements) noexcept;
};
 
template <typename ParentSegment, typename CommonParent, int N = 0,
          SegmentAllocator Allocator = SegmentAllocator::ThreadLocal>
struct SC_MEMORY_EXPORT SegmentCustom : public ParentSegment
{
    SegmentCustom() : ParentSegment(N, Allocator) {}
    SegmentCustom(const CommonParent& other) : SegmentCustom() { CommonParent::operator=(other); }
    SegmentCustom(CommonParent&& other) : SegmentCustom() { CommonParent::operator=(move(other)); }
 
    SegmentCustom(const SegmentCustom& other) : SegmentCustom() { ParentSegment::operator=(other); }
    SegmentCustom(SegmentCustom&& other) : SegmentCustom() { ParentSegment::operator=(move(other)); }
    // clang-format off
    SegmentCustom& operator=(const SegmentCustom& other) { ParentSegment::operator=(other); return *this; }
    SegmentCustom& operator=(SegmentCustom&& other) { ParentSegment::operator=(move(other)); return *this; }
    // clang-format on
};
} // namespace detail
 
template <typename VTable>
struct SC_MEMORY_EXPORT Segment : public VTable
{
    using VTable::data;
    using T = typename VTable::Type;
    Segment(uint32_t capacityInBytes, SegmentAllocator allocator = SegmentAllocator::Global) noexcept;
 
    Segment() noexcept;
    ~Segment() noexcept;
    Segment(Segment&& other) noexcept;
    Segment(const Segment& other) noexcept;
    Segment& operator=(Segment&& other) noexcept;
    Segment& operator=(const Segment& other) noexcept;
 
    // clang-format off
    template <typename U = T> Segment(Span<const U> span) noexcept : Segment() { SC_ASSERT_RELEASE(assign(span)); }
    // clang-format on
    Segment(std::initializer_list<T> list) noexcept;
 
    [[nodiscard]] bool resizeWithoutInitializing(size_t newSize) noexcept;
 
    [[nodiscard]] bool resize(size_t newSize, const T& value = T()) noexcept;
 
    [[nodiscard]] bool reserve(size_t capacity) noexcept;
 
    template <typename U = T>
    [[nodiscard]] bool append(Span<const U> span) noexcept;
 
    template <typename VTable2>
    [[nodiscard]] bool appendMove(Segment<VTable2>&& other) noexcept;
 
    [[nodiscard]] bool shrink_to_fit() noexcept;
 
    void clear() noexcept;
 
    template <typename U = T>
    [[nodiscard]] bool assign(Span<const U> span) noexcept;
 
    template <typename VTable2>
    [[nodiscard]] bool assignMove(Segment<VTable2>&& other) noexcept;
 
    [[nodiscard]] bool push_back(const T& value) noexcept { return resize(size() + 1, value); }
 
    [[nodiscard]] bool push_back(T&& value) noexcept;
 
    [[nodiscard]] bool push_front(const T& value) noexcept { return insert(0, value); }
 
    [[nodiscard]] bool pop_back(T* removedValue = nullptr) noexcept;
 
    [[nodiscard]] bool pop_front(T* removedValue = nullptr) noexcept;
 
    // clang-format off
    [[nodiscard]] T*       begin()       noexcept SC_LANGUAGE_LIFETIME_BOUND { return data(); }
    [[nodiscard]] const T* begin() const noexcept SC_LANGUAGE_LIFETIME_BOUND { return data(); }
    [[nodiscard]] T*       end()         noexcept SC_LANGUAGE_LIFETIME_BOUND { return data() + size(); }
    [[nodiscard]] const T* end()   const noexcept SC_LANGUAGE_LIFETIME_BOUND { return data() + size(); }
 
    [[nodiscard]] T& back()              noexcept SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_RELEASE(not isEmpty()); return *(data() + size() - 1);}
    [[nodiscard]] T& front()             noexcept SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_RELEASE(not isEmpty()); return *data();}
    [[nodiscard]] const T& back()  const noexcept SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_RELEASE(not isEmpty()); return *(data() + size() - 1);}
    [[nodiscard]] const T& front() const noexcept SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_RELEASE(not isEmpty()); return *data();}
 
    [[nodiscard]] T&       operator[](size_t idx)       noexcept SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(idx < size()); return *(data() + idx);}
    [[nodiscard]] const T& operator[](size_t idx) const noexcept SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(idx < size()); return *(data() + idx);}
    // clang-format on
 
    [[nodiscard]] bool isEmpty() const noexcept { return VTable::header.sizeBytes == 0; }
 
    [[nodiscard]] Span<T> toSpan() noexcept SC_LANGUAGE_LIFETIME_BOUND { return {data(), size()}; }
 
    [[nodiscard]] Span<const T> toSpanConst() const noexcept SC_LANGUAGE_LIFETIME_BOUND { return {data(), size()}; }
 
    [[nodiscard]] size_t size() const noexcept { return VTable::header.sizeBytes / sizeof(T); }
 
    [[nodiscard]] size_t capacity() const noexcept { return VTable::header.capacityBytes / sizeof(T); }
 
    [[nodiscard]] bool removeRange(size_t start, size_t length) noexcept;
 
    [[nodiscard]] bool removeAt(size_t index) noexcept { return removeRange(index, 1); }
 
    [[nodiscard]] bool insert(size_t index, Span<const T> data) noexcept;
 
  protected:
    template <typename VTable2>
    friend struct Segment;
    struct Internal;
};
 
} // namespace SC