Class span

include/stringzilla/types.hpp:174–219

template <typename value_type_, sz_size_t extent_ = SZ_SIZE_MAX>
struct span {

    using value_type = value_type_;              // ? For STL compatibility
    using size_type = sz_size_t;                 // ? For STL compatibility
    using difference_type = sz_ssize_t;          // ? For STL compatibility
    static constexpr sz_size_t extent = extent_; // ? For STL compatibility

    value_type *data_ {};

    constexpr span() noexcept = default;
    constexpr span(value_type *data) noexcept : data_(data) {}
    sz_constexpr_if_cpp14 span(value_type *data, size_type size) noexcept : data_(data) {
        sz_assert_(extent == size && "The second argument is only intended for compatibility");
        sz_unused_(size);
    }

    sz_constexpr_if_cpp14 explicit operator bool() const noexcept { return data_ != nullptr; }

    constexpr value_type *begin() const noexcept { return data_; }
    constexpr value_type *end() const noexcept { return data_ + extent; }
    constexpr value_type *data() const noexcept { return data_; }
    constexpr size_type size() const noexcept { return extent; }
    constexpr size_type length() const noexcept { return extent; }
    constexpr size_type size_bytes() const noexcept { return extent * sizeof(value_type); }
    constexpr value_type &operator[](size_type i) const noexcept { return data_[i]; }
    constexpr value_type &front() const noexcept { return data_[0]; }
    constexpr value_type &back() const noexcept { return data_[extent - 1]; }
    constexpr bool empty() const noexcept { return extent == 0; }

    template <typename same_value_type_ = value_type,
              typename = typename std::enable_if<!std::is_const<same_value_type_>::value>::type>
    constexpr operator span<typename std::add_const<same_value_type_>::type>() const noexcept {
        return {data_};
    }

    template <typename other_value_type_>
    constexpr span<other_value_type_, extent * sizeof(value_type) / sizeof(other_value_type_)> cast() const noexcept {
        return span<other_value_type_, extent * sizeof(value_type) / sizeof(other_value_type_)>(
            reinterpret_cast<other_value_type_ *>(data_));
    }

    sz_constexpr_if_cpp14 span<value_type, SZ_SIZE_MAX> subspan(size_type offset, size_type count) const noexcept {
        sz_assert_(offset + count <= extent && "Subspan out of bounds");
        return span<value_type, SZ_SIZE_MAX>(data_ + offset, count);
    }
};

template <typename value_type_>
struct span<value_type_, SZ_SIZE_MAX> {