span< T > Class Template Reference

span&lt; T &gt; Class Template Reference#

Composable Kernel: ck::span< T > Class Template Reference
Public Types | Public Member Functions | List of all members
ck::span< T > Class Template Reference

#include <span.hpp>

Public Types

using element_type = T
using value_type = std::remove_cv_t<element_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 const_iterator = pointer

Public Member Functions

constexpr span ()
constexpr span (pointer first, size_type count)
constexpr span (pointer first, pointer last)
template<std::size_t N>
constexpr span (element_type(&arr)[N]) noexcept
template<std::size_t N>
constexpr span (std::array< value_type, N > &arr) noexcept
template<typename Container>
constexpr span (const Container &container)
constexpr iterator begin () const noexcept
constexpr const_iterator cbegin () const noexcept
constexpr iterator end () const noexcept
constexpr const_iterator cend () const noexcept
constexpr reference front () const
constexpr reference back () const
constexpr reference operator[] (size_type idx) const
constexpr pointer data () const noexcept
constexpr size_type size () const noexcept

Member Typedef Documentation

◆ const_iterator

template<typename T>
using ck::span< T >::const_iterator = pointer

◆ const_pointer

template<typename T>
using ck::span< T >::const_pointer = const element_type*

◆ const_reference

template<typename T>
using ck::span< T >::const_reference = const element_type&

◆ difference_type

template<typename T>
using ck::span< T >::difference_type = std::ptrdiff_t

◆ element_type

template<typename T>
using ck::span< T >::element_type = T

◆ iterator

template<typename T>
using ck::span< T >::iterator = pointer

◆ pointer

template<typename T>
using ck::span< T >::pointer = element_type*

◆ reference

template<typename T>
using ck::span< T >::reference = element_type&

◆ size_type

template<typename T>
using ck::span< T >::size_type = std::size_t

◆ value_type

template<typename T>
using ck::span< T >::value_type = std::remove_cv_t<element_type>

Constructor & Destructor Documentation

◆ span() [1/6]

template<typename T>
ck::span< T >::span ( )
inlineconstexpr

◆ span() [2/6]

template<typename T>
ck::span< T >::span ( pointer first,
size_type count )
inlineconstexpr

◆ span() [3/6]

template<typename T>
ck::span< T >::span ( pointer first,
pointer last )
inlineconstexpr

◆ span() [4/6]

template<typename T>
template<std::size_t N>
ck::span< T >::span ( element_type(&) arr[N])
inlineconstexprnoexcept

◆ span() [5/6]

template<typename T>
template<std::size_t N>
ck::span< T >::span ( std::array< value_type, N > & arr)
inlineconstexprnoexcept

◆ span() [6/6]

template<typename T>
template<typename Container>
ck::span< T >::span ( const Container & container)
inlineconstexpr

Member Function Documentation

◆ back()

template<typename T>
reference ck::span< T >::back ( ) const
inlineconstexpr

◆ begin()

template<typename T>
iterator ck::span< T >::begin ( ) const
inlineconstexprnoexcept

◆ cbegin()

template<typename T>
const_iterator ck::span< T >::cbegin ( ) const
inlineconstexprnoexcept

◆ cend()

template<typename T>
const_iterator ck::span< T >::cend ( ) const
inlineconstexprnoexcept

◆ data()

template<typename T>
pointer ck::span< T >::data ( ) const
inlineconstexprnoexcept

◆ end()

template<typename T>
iterator ck::span< T >::end ( ) const
inlineconstexprnoexcept

◆ front()

template<typename T>
reference ck::span< T >::front ( ) const
inlineconstexpr

◆ operator[]()

template<typename T>
reference ck::span< T >::operator[] ( size_type idx) const
inlineconstexpr

◆ size()

template<typename T>
size_type ck::span< T >::size ( ) const
inlineconstexprnoexcept
The documentation for this class was generated from the following file: