span< ElementType, Extent > Class Template Reference

#include <geom_span.hpp>

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 = dynamic_extent>
using	subspan_return_t = span< ElementType, Count !=dynamic_extent ? Count :(Extent !=dynamic_extent ? Extent - Offset :dynamic_extent)>

Public Member Functions
template<std::size_t E = Extent, typename std::enable_if<(E==dynamic_extent||E<=0), int >::type = 0>
constexpr	span () noexcept
TCB_SPAN_CONSTEXPR11	span (pointer ptr, size_type count)
TCB_SPAN_CONSTEXPR11	span (pointer first_elem, pointer last_elem)
template<std::size_t N, std::size_t E = Extent, typename std::enable_if<(E==dynamic_extent||N==E) &&detail::is_container_element_type_compatible< element_type(&)[N], ElementType >::value, int >::type = 0>
constexpr	span (element_type(&arr)[N]) noexcept
template<std::size_t N, std::size_t E = Extent, typename std::enable_if<(E==dynamic_extent||N==E) &&detail::is_container_element_type_compatible< std::array< value_type, N > &, ElementType >::value, int >::type = 0>
TCB_SPAN_ARRAY_CONSTEXPR	span (std::array< value_type, N > &arr) noexcept
template<std::size_t N, std::size_t E = Extent, typename std::enable_if<(E==dynamic_extent||N==E) &&detail::is_container_element_type_compatible< const std::array< value_type, N > &, ElementType >::value, int >::type = 0>
TCB_SPAN_ARRAY_CONSTEXPR	span (const std::array< value_type, N > &arr) noexcept
template<typename Container , std::size_t E = Extent, typename std::enable_if< E==dynamic_extent &&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==dynamic_extent &&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==OtherExtent||Extent==dynamic_extent) &&std::is_convertible< OtherElementType(*)[], ElementType(*)[]>::value, int >::type = 0>
constexpr	span (const span< OtherElementType, OtherExtent > &other) noexcept
	~span () noexcept=default
TCB_SPAN_CONSTEXPR_ASSIGN span &	operator= (const span &other) noexcept=default
template<std::size_t Count>
TCB_SPAN_CONSTEXPR11 span< element_type, Count >	first () const
template<std::size_t Count>
TCB_SPAN_CONSTEXPR11 span< element_type, Count >	last () const
template<std::size_t Offset, std::size_t Count = dynamic_extent>
TCB_SPAN_CONSTEXPR11 subspan_return_t< Offset, Count >	subspan () const
TCB_SPAN_CONSTEXPR11 span< element_type, dynamic_extent >	first (size_type count) const
TCB_SPAN_CONSTEXPR11 span< element_type, dynamic_extent >	last (size_type count) const
TCB_SPAN_CONSTEXPR11 span< element_type, dynamic_extent >	subspan (size_type offset, size_type count=dynamic_extent) const
constexpr size_type	size () const noexcept
constexpr size_type	size_bytes () const noexcept
TCB_SPAN_NODISCARD constexpr bool	empty () const noexcept
TCB_SPAN_CONSTEXPR11 reference	operator[] (size_type idx) const
TCB_SPAN_CONSTEXPR11 reference	front () const
TCB_SPAN_CONSTEXPR11 reference	back () const
constexpr pointer	data () const noexcept
constexpr iterator	begin () const noexcept
constexpr iterator	end () const noexcept
TCB_SPAN_ARRAY_CONSTEXPR reverse_iterator	rbegin () const noexcept
TCB_SPAN_ARRAY_CONSTEXPR reverse_iterator	rend () const noexcept

Static Public Attributes
static constexpr size_type	extent = Extent

Member Typedef Documentation

element_type

using element_type = ElementType

value_type

using value_type = typename std::remove_cv<ElementType>::type

size_type

using size_type = std::size_t

difference_type

using difference_type = std::ptrdiff_t

pointer

using pointer = element_type*

const_pointer

using const_pointer = const element_type*

reference

using reference = element_type&

const_reference

using const_reference = const element_type&

iterator

using iterator = pointer

reverse_iterator

using reverse_iterator = std::reverse_iterator<iterator>

subspan_return_t

using subspan_return_t = span<ElementType, Count != dynamic_extent ? Count : (Extent != dynamic_extent ? Extent - Offset : dynamic_extent)>

Constructor & Destructor Documentation

span() [1/10]

constexpr span ( )

inlineconstexprnoexcept

    {
    }

span() [2/10]

TCB_SPAN_CONSTEXPR11 span ( pointer  ptr, size_type  count  )

inline

            : storage_(ptr, count)
    {
        TCB_SPAN_EXPECT(extent == dynamic_extent || count == extent);
    }

span() [3/10]

TCB_SPAN_CONSTEXPR11 span ( pointer  first_elem, pointer  last_elem  )

inline

            : storage_(first_elem, last_elem - first_elem)
    {
        TCB_SPAN_EXPECT(extent == dynamic_extent || last_elem - first_elem == static_cast<std::ptrdiff_t>(extent));
    }

span() [4/10]

constexpr span ( element_type(&)  arr[N] )

inlineconstexprnoexcept

            : storage_(arr, N)
    {
    }

span() [5/10]

TCB_SPAN_ARRAY_CONSTEXPR span ( std::array< value_type, N > &  arr )

inlinenoexcept

            : storage_(arr.data(), N)
    {
    }

span() [6/10]

TCB_SPAN_ARRAY_CONSTEXPR span ( const std::array< value_type, N > &  arr )

inlinenoexcept

            : storage_(arr.data(), N)
    {
    }

span() [7/10]

constexpr span ( Container &  cont )

inlineconstexpr

            : storage_(detail::data(cont), detail::size(cont))
    {
    }

span() [8/10]

constexpr span ( const Container &  cont )

inlineconstexpr

            : storage_(detail::data(cont), detail::size(cont))
    {
    }

span() [9/10]

constexpr span ( const span< ElementType, Extent > &  other )

constexprdefaultnoexcept

span() [10/10]

constexpr span ( const span< OtherElementType, OtherExtent > &  other )

inlineconstexprnoexcept

            : storage_(other.data(), other.size())
    {
    }

~span()

~span ( )

defaultnoexcept

Member Function Documentation

operator=()

TCB_SPAN_CONSTEXPR_ASSIGN span & operator= ( const span< ElementType, Extent > &  other )

defaultnoexcept

first() [1/2]

TCB_SPAN_CONSTEXPR11 span< element_type, Count > first ( ) const

inline

    {
        TCB_SPAN_EXPECT(Count <= size());
        return { data(), Count };
    }

last() [1/2]

TCB_SPAN_CONSTEXPR11 span< element_type, Count > last ( ) const

inline

    {
        TCB_SPAN_EXPECT(Count <= size());
        return { data() + (size() - Count), Count };
    }

subspan() [1/2]

TCB_SPAN_CONSTEXPR11 subspan_return_t< Offset, Count > subspan ( ) const

inline

    {
        TCB_SPAN_EXPECT(Offset <= size() && (Count == dynamic_extent || Offset + Count <= size()));
        return { data() + Offset, Count != dynamic_extent ? Count : size() - Offset };
    }

first() [2/2]

TCB_SPAN_CONSTEXPR11 span< element_type, dynamic_extent > first ( size_type  count ) const

inline

    {
        TCB_SPAN_EXPECT(count <= size());
        return { data(), count };
    }

last() [2/2]

TCB_SPAN_CONSTEXPR11 span< element_type, dynamic_extent > last ( size_type  count ) const

inline

    {
        TCB_SPAN_EXPECT(count <= size());
        return { data() + (size() - count), count };
    }

subspan() [2/2]

TCB_SPAN_CONSTEXPR11 span< element_type, dynamic_extent > subspan ( size_type  offset, size_type  count = dynamic_extent  ) const

inline

    {
        TCB_SPAN_EXPECT(offset <= size() && (count == dynamic_extent || offset + count <= size()));
        return { data() + offset, count == dynamic_extent ? size() - offset : count };
    }

size()

constexpr size_type size ( ) const

inlineconstexprnoexcept

    {
        return storage_.size;
    }

size_bytes()

constexpr size_type size_bytes ( ) const

inlineconstexprnoexcept

    {
        return size() * sizeof(element_type);
    }

empty()

TCB_SPAN_NODISCARD constexpr bool empty ( ) const

inlineconstexprnoexcept

    {
        return size() == 0;
    }

operator[]()

TCB_SPAN_CONSTEXPR11 reference operator[] ( size_type  idx ) const

inline

    {
        TCB_SPAN_EXPECT(idx < size());
        return *(data() + idx);
    }

front()

TCB_SPAN_CONSTEXPR11 reference front ( ) const

inline

    {
        TCB_SPAN_EXPECT(!empty());
        return *data();
    }

back()

TCB_SPAN_CONSTEXPR11 reference back ( ) const

inline

    {
        TCB_SPAN_EXPECT(!empty());
        return *(data() + (size() - 1));
    }

data()

constexpr pointer data ( ) const

inlineconstexprnoexcept

    {
        return storage_.ptr;
    }

begin()

constexpr iterator begin ( ) const

inlineconstexprnoexcept

    {
        return data();
    }

end()

constexpr iterator end ( ) const

inlineconstexprnoexcept

    {
        return data() + size();
    }

rbegin()

TCB_SPAN_ARRAY_CONSTEXPR reverse_iterator rbegin ( ) const

inlinenoexcept

    {
        return reverse_iterator(end());
    }

rend()

TCB_SPAN_ARRAY_CONSTEXPR reverse_iterator rend ( ) const

inlinenoexcept

    {
        return reverse_iterator(begin());
    }

Member Data Documentation

extent

constexpr size_type extent = Extent

staticconstexpr