// #pragma once

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

// #include "commons/commons_base.h"
// #include "commons/commons_mem.h"

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

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

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_IsEmpty(span<T> self) -> bool
// {
//     return self.size == 0;
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_CStr(span<T> self) -> const char*
//     requires(sizeof(T) == 1)
// {
//     DASSERT(*(self.data + self.size) == 0);
//     return (const char*)self.data;
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_SizeBytes(span<T> self) -> uint64_t
// {
//     return self.size * sizeof(T);
// }

// template <typename T>
// INLINE auto Span_Resize(span<T> self, uint64_t newSize) -> span<T>
// {
//     self.size = newSize;
//     return self;
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_SubSpan(span<T> self, uint64_t from) -> span<T>
// {
//     const uint64_t retSize = self.size - from;
//     DASSERT(retSize >= 0);
//     return { self.data + from, retSize };
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_SubSpan(span<T> self, uint64_t from, uint64_t size) -> span<T>
// {
//     DASSERT(self.size - from >= size);
//     return { self.data + from, size };
// }

// template <typename K, typename T>
// [[nodiscard]]
// INLINE auto Span_Cast(span<T> self) -> span<K>
// {
//     return span<K> { (K*)self.data, self.size * sizeof(T) / sizeof(K) };
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_Front(span<T> self) -> T&
// {
//     return self[0];
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_Back(span<T> self) -> T&
// {
//     return self[self.size - 1];
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_Eq(span<T> self, span<const std::remove_const_t<T>> another) -> bool
// {
//     if (self.size == another.size)
//         return MemEq(self.data, another.data, Span_SizeBytes(self));
//     else
//         return false;
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_StartsWith(span<T> self, span<const std::remove_const_t<T>> prefix) -> bool
// {
//     return MemStartsWith(self.data, Span_SizeBytes(self), prefix.data, Span_SizeBytes(prefix));
// }

// INLINE auto StartsWithIgnoreCase(byteview self, byteview prefix) -> bool
// {
//     if (prefix.size > self.size)
//         return false;

//     for (uint64_t i = 0; i < prefix.size; ++i)
//     {
//         if (self[i] != prefix[i] && (self[i] ^ 0x20) != prefix[i])
//             return false;
//     }

//     return true;
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_EndsWith(span<T> self, span<const std::remove_const_t<T>> suffix) -> bool
// {
//     return MemEndsWith(self.data, Span_SizeBytes(self), suffix.data, Span_SizeBytes(suffix));
// }

// template <typename T>
// [[nodiscard]]
// INLINE auto Span_Copy(span<T> dst, span<const T> src)
// {
//     return MemCpy(dst.data, Span_SizeBytes(dst), src.data, Span_SizeBytes(src));
// }

// INLINE auto Span_FromCStr(const void* str, uint64_t maxLength) -> byteview
// {
//     return byteview { (uint8_t*)str, CStrLen(str, maxLength) };
// }

// template <typename T>
// INLINE auto Span_ByteViewPtr(T* ptr) -> byteview
// {
//     return byteview { (uint8_t*)ptr, sizeof(T) };
// }

// template <typename T>
// INLINE auto Span_Contains(const span<T>& self, const T& value) -> bool
// {
//     for (auto& elem : self) {
//         if (elem == value)
//             return true;
//     }
//     return false;
// }

// template <typename T>
// INLINE auto Span_Erase(span<T> self, T* from, T* to) -> span<T>
// {
//     static_assert(!std::is_const_v<T>);

//     DASSERT(from >= self.begin() && from < self.end());
//     DASSERT(to >= self.begin() && to <= self.end());
//     DASSERT(to >= from);
//     if (from == to)
//         return self;

//     uint64_t numRemoved = to - from;
//     uint64_t numToMove = self.end() - to;

//     if (numToMove > 0)
//         MemMove(from, to, numToMove * sizeof(T));

//     return { self.data, self.size - numRemoved };
// }

// template <typename T>
// INLINE auto Span_Erase(span<T> self, span<T> section) -> span<T>
// {
//     return Span_Erase(self, section.begin(), section.end());
// }

// template <typename T>
// INLINE auto Span_Erase(span<T> self, T* pos) -> span<T>
// {
//     return Span_Erase(self, pos, pos + 1);
// }

// INLINE auto Span_ByteviewEq(byteview a, const char* b) -> bool
// {
//     while (*b) {
//         if (a.size == 0 || a.data[0] != (uint8_t)*b)
//             return false;
//         a.data++;
//         a.size--;
//         b++;
//     }
//     return a.size == 0;
// }