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 >
constexpr ck::span< T >::span ( )
inlineconstexpr

◆ span() [2/6]

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

◆ span() [3/6]

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

◆ span() [4/6]

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

◆ span() [5/6]

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

◆ span() [6/6]

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

Member Function Documentation

◆ back()

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

◆ begin()

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

◆ cbegin()

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

◆ cend()

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

◆ data()

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

◆ end()

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

◆ front()

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

◆ operator[]()

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

◆ size()

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