Fix line endings

1 files changed, 459 insertions, 459 deletions

diff --git a/asl/buffer.hpp b/asl/buffer.hpp
index b714e5a..5cf9964 100644
--- a/asl/buffer.hpp
+++ b/asl/buffer.hpp
@@ -1,459 +1,459 @@
-#pragma once

-

-#include "asl/meta.hpp"

-#include "asl/allocator.hpp"

-#include "asl/annotations.hpp"

-#include "asl/memory.hpp"

-#include "asl/assert.hpp"

-#include "asl/span.hpp"

-#include "asl/hash.hpp"

-

-namespace asl

-{

-

-template<is_object T, allocator Allocator = DefaultAllocator>

-class buffer

-{

-    T*         m_data{};

-    isize_t    m_capacity{};

-

-    static constexpr size_t kOnHeapMask = 0x8000'0000'0000'0000ULL;

-    

-    // bit 63       : 1 = on heap, 0 = inline

-    // bits [62:56] : size when inline

-    // bits [62:0]  : size when on heap

-    size_t     m_size_encoded_{};

-    

-    ASL_NO_UNIQUE_ADDRESS Allocator m_allocator;

-

-    static constexpr isize_t kInlineRegionSize = size_of<T*> + size_of<isize_t> + size_of<size_t>;

-    

-public:

-    static constexpr isize_t kInlineCapacity = []() {

-        // 1 byte is used for size inline in m_size_encoded.

-        // This is enough because we have at most 24 bytes available,

-        // so 23 chars of capacity.

-        const isize_t available_size = kInlineRegionSize - 1;

-        return available_size / size_of<T>;

-    }();

-

-private:

-    static_assert(align_of<T> <= align_of<T*>);

-    static_assert(align_of<T*> == align_of<isize_t>);

-    static_assert(align_of<T*> == align_of<size_t>);

-

-    constexpr size_t load_size_encoded() const

-    {

-        size_t s{};

-        asl::memcpy(&s, &m_size_encoded_, sizeof(size_t));

-        return s;

-    }

-

-    constexpr void store_size_encoded(size_t encoded)

-    {

-        asl::memcpy(&m_size_encoded_, &encoded, sizeof(size_t));

-    }

-

-    static constexpr bool is_on_heap(size_t size_encoded)

-    {

-        return (size_encoded & kOnHeapMask) != 0;

-    }

-

-    static constexpr size_t encode_size_heap(isize_t size)

-    {

-        return static_cast<size_t>(size) | kOnHeapMask;

-    }

-

-    static constexpr isize_t decode_size(size_t size_encoded)

-    {

-        if constexpr (kInlineCapacity == 0)

-        {

-            return is_on_heap(size_encoded)

-                ? static_cast<isize_t>(size_encoded & (~kOnHeapMask))

-                : 0;

-        }

-        else

-        {

-            return is_on_heap(size_encoded)

-                ? static_cast<isize_t>(size_encoded & (~kOnHeapMask))

-                : static_cast<isize_t>(size_encoded >> 56);

-        }

-    }

-

-    constexpr bool is_on_heap() const

-    {

-        return is_on_heap(load_size_encoded());

-    }

-

-    constexpr T* push_uninit()

-    {

-        isize_t sz = size();

-        resize_uninit_inner(sz + 1);

-        return data() + sz;

-    }

-

-    constexpr void resize_uninit_inner(isize_t new_size)

-    {

-        isize_t old_size = size();

-        if (!trivially_destructible<T> && new_size < old_size)

-        {

-            destroy_n(data() + new_size, old_size - new_size);

-        }

-        reserve_capacity(new_size);

-        set_size(new_size);

-    }

-

-    constexpr void set_size_inline(isize_t new_size)

-    {

-        ASL_ASSERT(new_size >= 0 && new_size <= kInlineCapacity);

-        size_t size_encoded = (load_size_encoded() & size_t{0x00ff'ffff'ffff'ffff}) | (bit_cast<size_t>(new_size) << 56);

-        store_size_encoded(size_encoded);

-    }

-

-    constexpr void set_size(isize_t new_size)

-    {

-        ASL_ASSERT(new_size >= 0 && new_size <= capacity());

-        if (is_on_heap())

-        {

-            store_size_encoded(encode_size_heap(new_size));

-        }

-        else

-        {

-            set_size_inline(new_size);

-        }

-    }

-

-    // NOLINTNEXTLINE(*-rvalue-reference-param-not-moved)

-    void move_from_other(buffer&& other, bool assign)

-    {

-        if (other.is_on_heap())

-        {

-            destroy();

-            m_data = other.m_data;

-            m_capacity = other.m_capacity;

-            store_size_encoded(other.load_size_encoded());

-        }

-        else if (trivially_move_constructible<T>)

-        {

-            destroy();

-            asl::memcpy(this, &other, kInlineRegionSize);

-        }

-        else if (!assign || m_allocator == other.m_allocator)

-        {

-            isize_t other_n = other.size();

-            isize_t this_n = size();

-            resize_uninit_inner(other_n);

-            if (other_n <= this_n)

-            {

-                relocate_assign_n(data(), other.data(), other_n);

-            }

-            else

-            {

-                relocate_assign_n(data(), other.data(), this_n);

-                relocate_uninit_n(data() + this_n, other.data() + this_n, other_n - this_n);

-            }

-        }

-        else

-        {

-            destroy();

-            isize_t n = other.size();

-            ASL_ASSERT(n <= kInlineCapacity);

-            relocate_uninit_n(data(), other.data(), n);

-            set_size_inline(n);

-        }

-

-        other.set_size_inline(0);

-        

-        if (assign)

-        {

-            m_allocator = ASL_MOVE(other.m_allocator);

-        }

-    }

-

-    void copy_range(span<const T> to_copy)

-    {

-        isize_t this_size = size();

-        isize_t new_size = to_copy.size();

-        

-        resize_uninit_inner(to_copy.size());

-        ASL_ASSERT(capacity() >= new_size);

-        ASL_ASSERT(size() == to_copy.size());

-

-        if (new_size <= this_size)

-        {

-            copy_assign_n(data(), to_copy.data(), new_size);

-        }

-        else

-        {

-            copy_assign_n(data(), to_copy.data(), this_size);

-            copy_uninit_n(data() + this_size, to_copy.data() + this_size, new_size - this_size);

-        }

-    }

-

-    template<typename... Args>

-    void resize_inner(isize_t new_size, Args&&... args)

-        requires constructible_from<T, Args&&...>

-    {

-        ASL_ASSERT(new_size >= 0);

-

-        isize_t old_size = size();

-        resize_uninit_inner(new_size);

-    

-        T* data_ptr = data();

-        T* end = data_ptr + new_size;

-

-        // NOLINTNEXTLINE(*-pointer-arithmetic)

-        for (T* it = data_ptr + old_size; it < end; ++it)

-        {

-            construct_at<T>(it, ASL_FWD(args)...);

-        }

-    }

-

-public:

-    constexpr buffer() requires default_constructible<Allocator> = default;

-    

-    explicit constexpr buffer(span<const T> s)

-        requires default_constructible<Allocator>

-        : buffer{}

-    {

-        copy_range(s);

-    }

-

-    explicit constexpr buffer(Allocator allocator)

-        : m_allocator{ASL_MOVE(allocator)}

-    {}

-    

-    explicit constexpr buffer(span<const T> s, Allocator allocator)

-        : m_allocator{ASL_MOVE(allocator)}

-    {

-        copy_range(s);

-    }

-

-    constexpr buffer(const buffer& other)

-        requires copy_constructible<Allocator> && copyable<T>

-        : m_allocator{other.m_allocator}

-    {

-        copy_range(other);

-    }

-

-    constexpr buffer(buffer&& other)

-        requires moveable<T>

-        : buffer(ASL_MOVE(other.m_allocator))

-    {

-        move_from_other(ASL_MOVE(other), false);

-    }

-    

-    constexpr buffer& operator=(const buffer& other)

-        requires copyable<T>

-    {

-        if (&other == this) { return *this; }

-        copy_range(other);

-        return *this;

-    }

-

-    constexpr buffer& operator=(buffer&& other)

-        requires moveable<T>

-    {

-        if (&other == this) { return *this; }

-        move_from_other(ASL_MOVE(other), true);

-        return *this;

-    }

-

-    ~buffer()

-    {

-        destroy();

-    }

-

-    constexpr isize_t size() const

-    {

-        return decode_size(load_size_encoded());

-    }

-

-    constexpr isize_t capacity() const

-    {

-        if constexpr (kInlineCapacity == 0)

-        {

-            return m_capacity;

-        }

-        else

-        {

-            return is_on_heap() ? m_capacity : kInlineCapacity;

-        }

-    }

-

-    void clear()

-    {

-        isize_t current_size = size();

-        if (current_size == 0) { return; }

-        

-        destroy_n(data(), current_size);

-        set_size(0);

-    }

-

-    void destroy()

-    {

-        clear();

-        if (is_on_heap())

-        {

-            if (m_data != nullptr)

-            {

-                auto current_layout = layout::array<T>(m_capacity);

-                m_allocator.dealloc(m_data, current_layout);

-            }

-            set_size_inline(0);

-        }

-    }

-

-    void reserve_capacity(isize_t new_capacity)

-    {

-        ASL_ASSERT(new_capacity >= 0);

-        ASL_ASSERT_RELEASE(new_capacity <= 0x4000'0000'0000'0000);

-        

-        if (new_capacity <= capacity()) { return; }

-        ASL_ASSERT(new_capacity > kInlineCapacity);

-

-        new_capacity = static_cast<isize_t>(round_up_pow2(static_cast<uint64_t>(new_capacity)));

-

-        T* old_data = data();

-        const isize_t old_capacity = capacity();

-        const isize_t current_size = size();

-        const bool currently_on_heap = is_on_heap();

-

-        auto old_layout = layout::array<T>(old_capacity);

-        auto new_layout = layout::array<T>(new_capacity);

-            

-        if (currently_on_heap && trivially_move_constructible<T>)

-        {

-            m_data = reinterpret_cast<T*>(m_allocator.realloc(m_data, old_layout, new_layout));

-            m_capacity = new_capacity;

-            return;

-        }

-

-        T* new_data = reinterpret_cast<T*>(m_allocator.alloc(new_layout));

-

-        relocate_uninit_n(new_data, old_data, current_size);

-

-        if (currently_on_heap)

-        {

-            m_allocator.dealloc(old_data, old_layout);

-        }

-

-        m_data = new_data;

-        m_capacity = new_capacity;

-        store_size_encoded(encode_size_heap(current_size));

-    }

-

-    constexpr void resize_uninit(isize_t new_size)

-        requires trivially_default_constructible<T> && trivially_destructible<T>

-    {

-        reserve_capacity(new_size);

-        set_size(new_size);

-    }

-

-    constexpr void resize_zero(isize_t new_size)

-        requires trivially_default_constructible<T> && trivially_destructible<T>

-    {

-        isize_t old_size = size();

-        resize_uninit(new_size);

-

-        if (new_size > old_size)

-        {

-            memzero(data() + old_size, (new_size - old_size) * size_of<T>);

-        }

-    }

-

-    void resize(isize_t new_size)

-        requires default_constructible<T>

-    {

-        resize_inner(new_size);

-    }

-

-    void resize(isize_t new_size, const T& value)

-    {

-        resize_inner(new_size, value);

-    }

-

-    constexpr T& push(auto&&... args)

-        requires constructible_from<T, decltype(args)&&...>

-    {

-        T* uninit = push_uninit();

-        T* init = construct_at<T>(uninit, ASL_FWD(args)...);

-        return *init;

-    }

-

-    // @Todo(C++23) Use deducing this

-    const T* data() const

-    {

-        if constexpr (kInlineCapacity == 0)

-        {

-            return m_data;

-        }

-        else

-        {

-            return is_on_heap() ? m_data : reinterpret_cast<const T*>(this);

-        }

-    }

-

-    T* data()

-    {

-        if constexpr (kInlineCapacity == 0)

-        {

-            return m_data;

-        }

-        else

-        {

-            return is_on_heap() ? m_data : reinterpret_cast<T*>(this);

-        }

-    }

-

-    // @Todo(C++23) Use deducing this

-    constexpr contiguous_iterator<const T> begin() const { return contiguous_iterator{data()}; }

-    constexpr contiguous_iterator<const T> end() const { return contiguous_iterator{data() + size()}; }

-    

-    constexpr contiguous_iterator<T> begin() { return contiguous_iterator{data()}; }

-    constexpr contiguous_iterator<T> end() { return contiguous_iterator{data() + size()}; }

-

-    // @Todo(C++23) Deducing this

-    constexpr operator span<const T>() const // NOLINT(*-explicit-conversions)

-    {

-        return as_span();

-    }

-    

-    constexpr operator span<T>() // NOLINT(*-explicit-conversions)

-    {

-        return as_span();

-    }

-    

-    constexpr span<const T> as_span() const

-    {

-        return span<const T>{data(), size()};

-    }

-    

-    constexpr span<T> as_span()

-    {

-        return span<T>{data(), size()};

-    }

-

-    // @Todo(C++23) Use deducing this

-    constexpr T& operator[](isize_t i)

-    {

-        ASL_ASSERT(i >= 0 && i <= size());

-        return data()[i];

-    }

-    

-    constexpr const T& operator[](isize_t i) const

-    {

-        ASL_ASSERT(i >= 0 && i <= size());

-        return data()[i];

-    }

-

-    template<typename H>

-    requires hashable<T>

-    friend H AslHashValue(H h, const buffer& b)

-    {

-        return H::combine_contiguous(ASL_MOVE(h), b.as_span());

-    }

-};

-

-} // namespace asl

-

+#pragma once
+
+#include "asl/meta.hpp"
+#include "asl/allocator.hpp"
+#include "asl/annotations.hpp"
+#include "asl/memory.hpp"
+#include "asl/assert.hpp"
+#include "asl/span.hpp"
+#include "asl/hash.hpp"
+
+namespace asl
+{
+
+template<is_object T, allocator Allocator = DefaultAllocator>
+class buffer
+{
+    T*         m_data{};
+    isize_t    m_capacity{};
+
+    static constexpr size_t kOnHeapMask = 0x8000'0000'0000'0000ULL;
+
+    // bit 63       : 1 = on heap, 0 = inline
+    // bits [62:56] : size when inline
+    // bits [62:0]  : size when on heap
+    size_t     m_size_encoded_{};
+
+    ASL_NO_UNIQUE_ADDRESS Allocator m_allocator;
+
+    static constexpr isize_t kInlineRegionSize = size_of<T*> + size_of<isize_t> + size_of<size_t>;
+
+public:
+    static constexpr isize_t kInlineCapacity = []() {
+        // 1 byte is used for size inline in m_size_encoded.
+        // This is enough because we have at most 24 bytes available,
+        // so 23 chars of capacity.
+        const isize_t available_size = kInlineRegionSize - 1;
+        return available_size / size_of<T>;
+    }();
+
+private:
+    static_assert(align_of<T> <= align_of<T*>);
+    static_assert(align_of<T*> == align_of<isize_t>);
+    static_assert(align_of<T*> == align_of<size_t>);
+
+    constexpr size_t load_size_encoded() const
+    {
+        size_t s{};
+        asl::memcpy(&s, &m_size_encoded_, sizeof(size_t));
+        return s;
+    }
+
+    constexpr void store_size_encoded(size_t encoded)
+    {
+        asl::memcpy(&m_size_encoded_, &encoded, sizeof(size_t));
+    }
+
+    static constexpr bool is_on_heap(size_t size_encoded)
+    {
+        return (size_encoded & kOnHeapMask) != 0;
+    }
+
+    static constexpr size_t encode_size_heap(isize_t size)
+    {
+        return static_cast<size_t>(size) | kOnHeapMask;
+    }
+
+    static constexpr isize_t decode_size(size_t size_encoded)
+    {
+        if constexpr (kInlineCapacity == 0)
+        {
+            return is_on_heap(size_encoded)
+                ? static_cast<isize_t>(size_encoded & (~kOnHeapMask))
+                : 0;
+        }
+        else
+        {
+            return is_on_heap(size_encoded)
+                ? static_cast<isize_t>(size_encoded & (~kOnHeapMask))
+                : static_cast<isize_t>(size_encoded >> 56);
+        }
+    }
+
+    constexpr bool is_on_heap() const
+    {
+        return is_on_heap(load_size_encoded());
+    }
+
+    constexpr T* push_uninit()
+    {
+        isize_t sz = size();
+        resize_uninit_inner(sz + 1);
+        return data() + sz;
+    }
+
+    constexpr void resize_uninit_inner(isize_t new_size)
+    {
+        isize_t old_size = size();
+        if (!trivially_destructible<T> && new_size < old_size)
+        {
+            destroy_n(data() + new_size, old_size - new_size);
+        }
+        reserve_capacity(new_size);
+        set_size(new_size);
+    }
+
+    constexpr void set_size_inline(isize_t new_size)
+    {
+        ASL_ASSERT(new_size >= 0 && new_size <= kInlineCapacity);
+        size_t size_encoded = (load_size_encoded() & size_t{0x00ff'ffff'ffff'ffff}) | (bit_cast<size_t>(new_size) << 56);
+        store_size_encoded(size_encoded);
+    }
+
+    constexpr void set_size(isize_t new_size)
+    {
+        ASL_ASSERT(new_size >= 0 && new_size <= capacity());
+        if (is_on_heap())
+        {
+            store_size_encoded(encode_size_heap(new_size));
+        }
+        else
+        {
+            set_size_inline(new_size);
+        }
+    }
+
+    // NOLINTNEXTLINE(*-rvalue-reference-param-not-moved)
+    void move_from_other(buffer&& other, bool assign)
+    {
+        if (other.is_on_heap())
+        {
+            destroy();
+            m_data = other.m_data;
+            m_capacity = other.m_capacity;
+            store_size_encoded(other.load_size_encoded());
+        }
+        else if (trivially_move_constructible<T>)
+        {
+            destroy();
+            asl::memcpy(this, &other, kInlineRegionSize);
+        }
+        else if (!assign || m_allocator == other.m_allocator)
+        {
+            isize_t other_n = other.size();
+            isize_t this_n = size();
+            resize_uninit_inner(other_n);
+            if (other_n <= this_n)
+            {
+                relocate_assign_n(data(), other.data(), other_n);
+            }
+            else
+            {
+                relocate_assign_n(data(), other.data(), this_n);
+                relocate_uninit_n(data() + this_n, other.data() + this_n, other_n - this_n);
+            }
+        }
+        else
+        {
+            destroy();
+            isize_t n = other.size();
+            ASL_ASSERT(n <= kInlineCapacity);
+            relocate_uninit_n(data(), other.data(), n);
+            set_size_inline(n);
+        }
+
+        other.set_size_inline(0);
+
+        if (assign)
+        {
+            m_allocator = ASL_MOVE(other.m_allocator);
+        }
+    }
+
+    void copy_range(span<const T> to_copy)
+    {
+        isize_t this_size = size();
+        isize_t new_size = to_copy.size();
+
+        resize_uninit_inner(to_copy.size());
+        ASL_ASSERT(capacity() >= new_size);
+        ASL_ASSERT(size() == to_copy.size());
+
+        if (new_size <= this_size)
+        {
+            copy_assign_n(data(), to_copy.data(), new_size);
+        }
+        else
+        {
+            copy_assign_n(data(), to_copy.data(), this_size);
+            copy_uninit_n(data() + this_size, to_copy.data() + this_size, new_size - this_size);
+        }
+    }
+
+    template<typename... Args>
+    void resize_inner(isize_t new_size, Args&&... args)
+        requires constructible_from<T, Args&&...>
+    {
+        ASL_ASSERT(new_size >= 0);
+
+        isize_t old_size = size();
+        resize_uninit_inner(new_size);
+
+        T* data_ptr = data();
+        T* end = data_ptr + new_size;
+
+        // NOLINTNEXTLINE(*-pointer-arithmetic)
+        for (T* it = data_ptr + old_size; it < end; ++it)
+        {
+            construct_at<T>(it, ASL_FWD(args)...);
+        }
+    }
+
+public:
+    constexpr buffer() requires default_constructible<Allocator> = default;
+
+    explicit constexpr buffer(span<const T> s)
+        requires default_constructible<Allocator>
+        : buffer{}
+    {
+        copy_range(s);
+    }
+
+    explicit constexpr buffer(Allocator allocator)
+        : m_allocator{ASL_MOVE(allocator)}
+    {}
+
+    explicit constexpr buffer(span<const T> s, Allocator allocator)
+        : m_allocator{ASL_MOVE(allocator)}
+    {
+        copy_range(s);
+    }
+
+    constexpr buffer(const buffer& other)
+        requires copy_constructible<Allocator> && copyable<T>
+        : m_allocator{other.m_allocator}
+    {
+        copy_range(other);
+    }
+
+    constexpr buffer(buffer&& other)
+        requires moveable<T>
+        : buffer(ASL_MOVE(other.m_allocator))
+    {
+        move_from_other(ASL_MOVE(other), false);
+    }
+
+    constexpr buffer& operator=(const buffer& other)
+        requires copyable<T>
+    {
+        if (&other == this) { return *this; }
+        copy_range(other);
+        return *this;
+    }
+
+    constexpr buffer& operator=(buffer&& other)
+        requires moveable<T>
+    {
+        if (&other == this) { return *this; }
+        move_from_other(ASL_MOVE(other), true);
+        return *this;
+    }
+
+    ~buffer()
+    {
+        destroy();
+    }
+
+    constexpr isize_t size() const
+    {
+        return decode_size(load_size_encoded());
+    }
+
+    constexpr isize_t capacity() const
+    {
+        if constexpr (kInlineCapacity == 0)
+        {
+            return m_capacity;
+        }
+        else
+        {
+            return is_on_heap() ? m_capacity : kInlineCapacity;
+        }
+    }
+
+    void clear()
+    {
+        isize_t current_size = size();
+        if (current_size == 0) { return; }
+
+        destroy_n(data(), current_size);
+        set_size(0);
+    }
+
+    void destroy()
+    {
+        clear();
+        if (is_on_heap())
+        {
+            if (m_data != nullptr)
+            {
+                auto current_layout = layout::array<T>(m_capacity);
+                m_allocator.dealloc(m_data, current_layout);
+            }
+            set_size_inline(0);
+        }
+    }
+
+    void reserve_capacity(isize_t new_capacity)
+    {
+        ASL_ASSERT(new_capacity >= 0);
+        ASL_ASSERT_RELEASE(new_capacity <= 0x4000'0000'0000'0000);
+
+        if (new_capacity <= capacity()) { return; }
+        ASL_ASSERT(new_capacity > kInlineCapacity);
+
+        new_capacity = static_cast<isize_t>(round_up_pow2(static_cast<uint64_t>(new_capacity)));
+
+        T* old_data = data();
+        const isize_t old_capacity = capacity();
+        const isize_t current_size = size();
+        const bool currently_on_heap = is_on_heap();
+
+        auto old_layout = layout::array<T>(old_capacity);
+        auto new_layout = layout::array<T>(new_capacity);
+
+        if (currently_on_heap && trivially_move_constructible<T>)
+        {
+            m_data = reinterpret_cast<T*>(m_allocator.realloc(m_data, old_layout, new_layout));
+            m_capacity = new_capacity;
+            return;
+        }
+
+        T* new_data = reinterpret_cast<T*>(m_allocator.alloc(new_layout));
+
+        relocate_uninit_n(new_data, old_data, current_size);
+
+        if (currently_on_heap)
+        {
+            m_allocator.dealloc(old_data, old_layout);
+        }
+
+        m_data = new_data;
+        m_capacity = new_capacity;
+        store_size_encoded(encode_size_heap(current_size));
+    }
+
+    constexpr void resize_uninit(isize_t new_size)
+        requires trivially_default_constructible<T> && trivially_destructible<T>
+    {
+        reserve_capacity(new_size);
+        set_size(new_size);
+    }
+
+    constexpr void resize_zero(isize_t new_size)
+        requires trivially_default_constructible<T> && trivially_destructible<T>
+    {
+        isize_t old_size = size();
+        resize_uninit(new_size);
+
+        if (new_size > old_size)
+        {
+            memzero(data() + old_size, (new_size - old_size) * size_of<T>);
+        }
+    }
+
+    void resize(isize_t new_size)
+        requires default_constructible<T>
+    {
+        resize_inner(new_size);
+    }
+
+    void resize(isize_t new_size, const T& value)
+    {
+        resize_inner(new_size, value);
+    }
+
+    constexpr T& push(auto&&... args)
+        requires constructible_from<T, decltype(args)&&...>
+    {
+        T* uninit = push_uninit();
+        T* init = construct_at<T>(uninit, ASL_FWD(args)...);
+        return *init;
+    }
+
+    // @Todo(C++23) Use deducing this
+    const T* data() const
+    {
+        if constexpr (kInlineCapacity == 0)
+        {
+            return m_data;
+        }
+        else
+        {
+            return is_on_heap() ? m_data : reinterpret_cast<const T*>(this);
+        }
+    }
+
+    T* data()
+    {
+        if constexpr (kInlineCapacity == 0)
+        {
+            return m_data;
+        }
+        else
+        {
+            return is_on_heap() ? m_data : reinterpret_cast<T*>(this);
+        }
+    }
+
+    // @Todo(C++23) Use deducing this
+    constexpr contiguous_iterator<const T> begin() const { return contiguous_iterator{data()}; }
+    constexpr contiguous_iterator<const T> end() const { return contiguous_iterator{data() + size()}; }
+
+    constexpr contiguous_iterator<T> begin() { return contiguous_iterator{data()}; }
+    constexpr contiguous_iterator<T> end() { return contiguous_iterator{data() + size()}; }
+
+    // @Todo(C++23) Deducing this
+    constexpr operator span<const T>() const // NOLINT(*-explicit-conversions)
+    {
+        return as_span();
+    }
+
+    constexpr operator span<T>() // NOLINT(*-explicit-conversions)
+    {
+        return as_span();
+    }
+
+    constexpr span<const T> as_span() const
+    {
+        return span<const T>{data(), size()};
+    }
+
+    constexpr span<T> as_span()
+    {
+        return span<T>{data(), size()};
+    }
+
+    // @Todo(C++23) Use deducing this
+    constexpr T& operator[](isize_t i)
+    {
+        ASL_ASSERT(i >= 0 && i <= size());
+        return data()[i];
+    }
+
+    constexpr const T& operator[](isize_t i) const
+    {
+        ASL_ASSERT(i >= 0 && i <= size());
+        return data()[i];
+    }
+
+    template<typename H>
+    requires hashable<T>
+    friend H AslHashValue(H h, const buffer& b)
+    {
+        return H::combine_contiguous(ASL_MOVE(h), b.as_span());
+    }
+};
+
+} // namespace asl
+