blob: 4767e800d1c707ae2fa083baf740284113b1ca5c [file]
/*
* Copyright 2022 Rive
*/
#ifndef _RIVE_SPAN_HPP_
#define _RIVE_SPAN_HPP_
#include "rive/rive_types.hpp"
#include <initializer_list>
#include <type_traits>
#include <iterator>
/*
* Span : cheap impl of std::span (which is C++20)
*
* Inspired by Skia's SkSpan
*/
namespace rive
{
namespace internal
{
template <typename T, typename = void> struct IsSpannableImpl : std::false_type
{};
// A type is "spannable" if it has a data() member that returns a pointer and a
// size() member that returns an integer. This is true for Span, std::span,
// std::vector, etc.
template <typename T>
struct IsSpannableImpl<
T,
std::enable_if_t<
!std::is_reference_v<T> &&
std::is_pointer_v<decltype(std::declval<T>().data())> &&
std::is_integral_v<decltype(std::declval<T>().size())>,
void>> : std::true_type
{};
template <typename T, size_t N> struct IsSpannableImpl<T[N]> : std::true_type
{};
template <typename T>
struct IsSpannableImpl<T&> : IsSpannableImpl<std::remove_reference_t<T>>
{};
template <typename T> constexpr bool IsSpannable = IsSpannableImpl<T>::value;
template <typename SpannableType, typename ElementType, typename = void>
struct IsTypedSpannableImpl : std::false_type
{};
template <typename SpannableType, typename ElementType>
struct IsTypedSpannableImpl<
SpannableType,
ElementType,
std::enable_if_t<
std::is_assignable_v<
ElementType*&,
decltype(std::declval<SpannableType>().data())>,
void>> : IsSpannableImpl<SpannableType>
{};
template <typename S, typename E>
constexpr bool IsTypedSpannable = IsTypedSpannableImpl<S, E>::value;
template <typename S, typename = std::enable_if_t<IsSpannable<S>, void>>
using SpannableElementType = std::remove_reference_t<decltype(*std::begin(
std::declval<std::remove_reference_t<S>&>()))>;
template <typename T, typename U, typename = void>
struct IsConstCompatibleImpl : std::false_type
{};
template <typename Dst, typename Src>
struct IsConstCompatibleImpl<
Dst,
Src,
std::enable_if_t<
std::is_same_v<std::remove_const_t<Dst>, std::remove_const_t<Src>> &&
(std::is_const_v<Dst> || !std::is_const_v<Src>),
void>> : std::true_type
{};
template <typename Dst, typename Src>
constexpr bool IsConstCompatible = IsConstCompatibleImpl<Dst, Src>::value;
} // namespace internal
enum class ToEnd_t
{
toEnd,
};
constexpr auto ToEnd = ToEnd_t::toEnd;
template <typename T> class Span
{
T* m_Ptr;
size_t m_Size;
public:
constexpr Span() : m_Ptr(nullptr), m_Size(0) {}
constexpr Span(T* ptr, size_t size) : m_Ptr(ptr), m_Size(size)
{
assert(ptr <= ptr + size);
}
template <size_t N> constexpr Span(T (&array)[N]) : m_Ptr(array), m_Size(N) {}
// Make a sub-span from an existing span
constexpr Span(Span<T> span, size_t startIndex, size_t count)
: m_Ptr{span.data() + startIndex}
, m_Size{count}
{
assert(startIndex + count <= span.size());
}
// Make a sub-span from an existing span with const-compatibility
template <
typename U,
std::enable_if_t<
internal::IsConstCompatible<T, internal::SpannableElementType<U>>,
U>>
constexpr Span(U&& span, size_t startIndex, size_t count)
: m_Ptr{span.data() + startIndex}
, m_Size{count}
{
assert(startIndex + count <= span.size());
}
// Make a sub-span from an existing span with a given start index, taking all
// of the elements from there to the end.
constexpr Span(Span<T> span, size_t startIndex, ToEnd_t)
: m_Ptr{span.data() + startIndex}
, m_Size{span.size() - startIndex}
{
assert(startIndex <= span.size());
}
// Make a sub-span from an existing span (with const-compatibility) with a
// given start index, taking all of the elements from there to the end.
template <
typename U,
std::enable_if_t<
internal::IsConstCompatible<T, internal::SpannableElementType<U>>,
U>>
constexpr Span(U&& span, size_t startIndex, ToEnd_t)
: m_Ptr{span.data() + startIndex}
, m_Size{span.size() - startIndex}
{
assert(startIndex <= span.size());
}
// Handle assignment from any types that have data and size members
template <
typename U,
typename = typename std::enable_if_t<internal::IsTypedSpannable<U, T>, U>>
constexpr Span(U& that) : Span(that.data(), that.size())
{}
template <
typename U,
typename =
typename std::enable_if_t<internal::IsTypedSpannable<const U, T>, U>>
constexpr Span(const U& that) : Span(that.data(), that.size())
{}
T& operator[](size_t index) const
{
assert(index < m_Size);
return m_Ptr[index];
}
constexpr T* data() const { return m_Ptr; }
constexpr size_t size() const { return m_Size; }
constexpr bool empty() const { return m_Size == 0; }
constexpr T* begin() const { return m_Ptr; }
constexpr T* end() const { return m_Ptr + m_Size; }
constexpr T& front() const { return (*this)[0]; }
constexpr T& back() const { return (*this)[m_Size - 1]; }
// returns byte-size of the entire span
constexpr size_t size_bytes() const { return m_Size * sizeof(T); }
constexpr size_t count() const { return m_Size; }
Span<T> subset(size_t offset, size_t size) const
{
assert(offset <= m_Size);
assert(size <= m_Size - offset);
return {m_Ptr + offset, size};
}
// Makes rive::Span std::Container compatible
// https://en.cppreference.com/w/cpp/named_req/Container
typedef typename std::remove_cv<T>::type value_type;
typedef T& reference;
typedef T const& const_reference;
typedef T* iterator;
typedef T const* const_iterator;
typedef std::ptrdiff_t difference_type;
typedef size_t size_type;
bool operator!=(const Span<T>& that) const
{
return m_Ptr != that.m_Ptr || m_Size != that.m_Size;
}
bool operator==(const Span<T>& that) const
{
return m_Ptr == that.m_Ptr && m_Size == that.m_Size;
}
};
// Deduction guides so that spannable types will deduce the template type
// properly.
template <typename T> Span(T&&) -> Span<internal::SpannableElementType<T>>;
template <typename T>
Span(T&&, size_t, size_t) -> Span<internal::SpannableElementType<T>>;
template <typename T>
Span(T&&, size_t, ToEnd_t) -> Span<internal::SpannableElementType<T>>;
// Deduction guide to make array conversions automatic
template <typename T, size_t N> Span(T (&)[N]) -> Span<T>;
template <typename T> Span<T> make_span(T* ptr, size_t size)
{
return Span<T>(ptr, size);
}
template <typename T, size_t N> Span<T> make_span(T (&ptr)[N])
{
return Span<T>(ptr, N);
}
} // namespace rive
#endif