// #pragma once

// #include <cstdint>
// #include <type_traits>

// #include "commons/commons_array.h"
// #include "commons/commons_base.h"
// #include "commons/commons_inline_vec_def.h"
// #include "commons/commons_mem.h"
// #include "commons/commons_span.h"

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto inline_vec<T, Capacity>::operator[](uint64_t i) -> T&
// {
//     DASSERT(i < size);
//     return data[i];
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto inline_vec<T, Capacity>::operator[](uint64_t i) const -> const T&
// {
//     DASSERT(i < size);
//     return data[i];
// }

// template <typename T, uint64_t VecCapacity>
// [[nodiscard]]
// INLINE auto InlineVec_Capacity(inline_vec<T, VecCapacity>& self) -> uint64_t
// {
//     return VecCapacity;
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto InlineVec_Size(inline_vec<T, Capacity>& self) -> uint64_t
// {
//     return self.size;
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto InlineVec_DataPtr(inline_vec<T, Capacity>& self) -> T*
// {
//     return self.data.data;
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto InlineVec_AsSpan(inline_vec<T, Capacity>& self) -> span<T>
// {
//     return span<T> { self.data.data, self.size };
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto InlineVec_AsSpan(const inline_vec<T, Capacity>& self) -> span<const T>
// {
//     return span<const T> { self.data.data, self.size };
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto InlineVec_Front(inline_vec<T, Capacity>& self) -> T&
// {
//     DASSERT(self.size);
//     return self[0];
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto InlineVec_Front(const inline_vec<T, Capacity>& self) -> const T&
// {
//     DASSERT(self.size);
//     return self[0];
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto InlineVec_Back(inline_vec<T, Capacity>& self) -> T&
// {
//     DASSERT(self.size);
//     return self[self.size - 1];
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto InlineVec_Back(const inline_vec<T, Capacity>& self) -> const T&
// {
//     DASSERT(self.size);
//     return self[self.size - 1];
// }

// template <typename T, uint64_t Capacity>
// INLINE void InlineVec_Resize(inline_vec<T, Capacity>& self, uint64_t newSize)
// {
//     DASSERT(newSize <= Capacity);
//     self.size = newSize;
// }

// template <typename T, uint64_t Capacity>
// INLINE void InlineVec_Clear(inline_vec<T, Capacity>& self)
// {
//     self.size = 0;
// }

// template <typename T, uint64_t Capacity>
// INLINE auto InlineVec_Append(inline_vec<T, Capacity>& self) -> T&
// {
//     DASSERT(self.size < Capacity);
//     T* p = self.data.data + self.size++;
//     return *p;
// }

// template <typename T, typename D, uint64_t Capacity>
// INLINE auto InlineVec_Append(inline_vec<T, Capacity>& self, const D& data) -> T&
//     requires(std::is_convertible_v<D, T>)
// {
//     T& ret = InlineVec_Append(self);
//     ret = data;
//     return ret;
// }

// template <typename T, uint64_t Capacity>
// INLINE void InlineVec_Append(inline_vec<T, Capacity>& self, span<const T> data)
// {
//     DASSERT(self.size + data.size <= Capacity);
//     MemCpy(self.data.data + self.size, data.data, Span_SizeBytes(data));
//     self.size += data.size;
// }

// template <typename T, uint64_t Capacity>
// INLINE auto InlineVec_PopBack(inline_vec<T, Capacity>& self) -> T
// {
//     T ret = InlineVec_Back(self);
//     --self.size;
//     return ret;
// }

// template <typename T, uint64_t Capacity>
// [[nodiscard]]
// INLINE auto InlineVec_Find(inline_vec<T, Capacity>& self, const T& val) -> T*
// {
//     for (auto& elem : self) {
//         if (elem == val)
//             return &elem;
//     }
//     return nullptr;
// }

// template <typename T, uint64_t Capacity>
// INLINE void InlineVec_Erase(inline_vec<T, Capacity>& self, T* pos)
// {
//     span<T> s = Span_Erase(InlineVec_AsSpan(self), pos);
//     self.size = s.size;
// }

// template <typename T, uint64_t Capacity>
// INLINE auto InlineVec_Insert(inline_vec<T, Capacity>& self, uint64_t index, const T& val) -> T*
// {
//     DASSERT(self.size < Capacity);
//     DASSERT(index <= self.size);
//     MemMove(self.data.data + index + 1, self.data.data + index, (self.size - index) * sizeof(T));
//     self.data.data[index] = val;
//     ++self.size;
//     return self.data.data + index;
// }


// template <typename T, uint64_t Capacity>
// INLINE auto InlineVec_Index(inline_vec<T, Capacity>& self, T* p) -> uint64_t
// {
//     uint64_t index = p - self.data.data;
//     DASSERT(index < self.size);
//     return index;
// }