ImFusion::Utils::Span< ElementType, Extent > Class Template Reference

#include <ImFusion/Core/Utils/Span.h>

Describes a non-owning view into contiguous sequence of elements. More...

Detailed Description

template<typename ElementType, std::size_t Extent>
class ImFusion::Utils::Span< ElementType, Extent >

Describes a non-owning view into contiguous sequence of elements.

The main use case of a span is to pass contiguous arrays of objects as function parameters so that the callee can work with/on the elements without requiring a particular container type to be used by the caller. Spans can be constructed conveniently from many different containers such as arrays, std::vector, and std::string.

A span can either have a static extent, in which case the number of elements in the sequence is known at compile-time and encoded in the type, or a dynamic extent. For a Span s, pointers, iterators, and references to elements of s are invalidated when an operation invalidates a pointer in the range [s.data(), s.data() + s.size()).

Template Parameters

ElementType	Type of the wrapped elements, must be a complete type.
Extent	The number of elements in the sequence, or SpanDynamicExtent if dynamic.

Note

This class is a polyfill of std::span from C++20 providing the same interface and functionality.

Public Types
using	element_type = ElementType
using	value_type = typename std::remove_cv<ElementType>::type
using	size_type = std::size_t
using	difference_type = std::ptrdiff_t
using	pointer = element_type*
using	const_pointer = const element_type*
using	reference = element_type&
using	const_reference = const element_type&
using	iterator = pointer
using	reverse_iterator = std::reverse_iterator<iterator>
template<std::size_t Offset, std::size_t Count = SpanDynamicExtent>
using	subspan_return_t

Public Member Functions
constexpr	Span (pointer ptr, size_type count)
constexpr	Span (pointer first_elem, pointer last_elem)
template<std::size_t N, std::size_t E = Extent, typename std::enable_if<(E==SpanDynamicExtent||N==E) &&detail::is_container_element_type_compatible< element_type(&)[N], ElementType >::value, int >::type = 0>
constexpr	Span (element_type(&arr)[N]) noexcept
template<typename T, std::size_t N, std::size_t E = Extent, typename std::enable_if<(E==SpanDynamicExtent||N==E) &&detail::is_container_element_type_compatible< std::array< T, N > &, ElementType >::value, int >::type = 0>
constexpr	Span (std::array< T, N > &arr) noexcept
template<typename T, std::size_t N, std::size_t E = Extent, typename std::enable_if<(E==SpanDynamicExtent||N==E) &&detail::is_container_element_type_compatible< const std::array< T, N > &, ElementType >::value, int >::type = 0>
constexpr	Span (const std::array< T, N > &arr) noexcept
template<typename Container, std::size_t E = Extent, typename std::enable_if< E==SpanDynamicExtent &&detail::is_container< Container >::value &&detail::is_container_element_type_compatible< Container &, ElementType >::value, int >::type = 0>
constexpr	Span (Container &cont)
template<typename Container, std::size_t E = Extent, typename std::enable_if< E==SpanDynamicExtent &&detail::is_container< Container >::value &&detail::is_container_element_type_compatible< const Container &, ElementType >::value, int >::type = 0>
constexpr	Span (const Container &cont)
constexpr	Span (const Span &other) noexcept=default
template<typename OtherElementType, std::size_t OtherExtent, typename std::enable_if<(Extent==SpanDynamicExtent||OtherExtent==SpanDynamicExtent||Extent==OtherExtent) &&std::is_convertible< OtherElementType(*)[], ElementType(*)[]>::value, int >::type = 0>
constexpr	Span (const Span< OtherElementType, OtherExtent > &other) noexcept
constexpr Span &	operator= (const Span &other) noexcept=default
template<std::size_t Count>
constexpr Span< element_type, Count >	first () const
template<std::size_t Count>
constexpr Span< element_type, Count >	last () const
template<std::size_t Offset, std::size_t Count = SpanDynamicExtent>
constexpr subspan_return_t< Offset, Count >	subspan () const
constexpr Span< element_type, SpanDynamicExtent >	first (size_type count) const
constexpr Span< element_type, SpanDynamicExtent >	last (size_type count) const
constexpr Span< element_type, SpanDynamicExtent >	subspan (size_type offset, size_type count=SpanDynamicExtent) const
constexpr size_type	size () const noexcept
constexpr size_type	size_bytes () const noexcept
constexpr bool	empty () const noexcept
constexpr reference	operator[] (size_type idx) const
constexpr reference	front () const
constexpr reference	back () const
constexpr pointer	data () const noexcept
constexpr iterator	begin () const noexcept
constexpr iterator	end () const noexcept
constexpr reverse_iterator	rbegin () const noexcept
constexpr reverse_iterator	rend () const noexcept

Static Public Attributes
static constexpr size_type	extent = Extent

Member Typedef Documentation

subspan_return_t

template<typename ElementType, std::size_t Extent>

template<std::size_t Offset, std::size_t Count = SpanDynamicExtent>

using ImFusion::Utils::Span< ElementType, Extent >::subspan_return_t

Initial value:

 
            Span<ElementType,
                 Count != SpanDynamicExtent ? Count : (Extent != SpanDynamicExtent ? Extent - Offset : SpanDynamicExtent)>

---

The documentation for this class was generated from the following file:

• ImFusion/Core/Utils/Span.h