Uni20
Asynchronous tensor and runtime library.
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | List of all members
static_vector< T, 0 > Class Template Reference

Specialization of static_vector for MaxSize == 0. More...

#include <static_vector.hpp>

Public Types

using const_iterator = T const *
 
using const_pointer = T const *
 
using const_reference = T const &
 
using const_reverse_iterator = std::reverse_iterator< const_iterator >
 
using difference_type = std::ptrdiff_t
 
using iterator = T *
 
using pointer = T *
 
using reference = T &
 
using reverse_iterator = std::reverse_iterator< iterator >
 
using size_type = std::size_t
 
using value_type = T
 

Public Member Functions

reference at (size_type)
 
const_reference at (size_type) const
 
reference back ()
 
const_reference back () const
 
const_iterator begin () const noexcept
 
iterator begin () noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
void clear () noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
const_pointer data () const noexcept
 
pointer data () noexcept
 
template<typename... Args>
void emplace_back (Args &&...)
 
constexpr bool empty () const noexcept
 
const_iterator end () const noexcept
 
iterator end () noexcept
 
reference front ()
 
const_reference front () const
 
static_vector & operator= (static_vector &&) noexcept=default
 
static_vector & operator= (static_vector const &)=default
 
static_vector & operator= (std::initializer_list< T > init)
 
reference operator[] (size_type)
 
const_reference operator[] (size_type) const
 
void pop_back ()
 
void push_back (T &&)
 
void push_back (T const &)
 
const_reverse_iterator rbegin () const noexcept
 
reverse_iterator rbegin () noexcept
 
const_reverse_iterator rend () const noexcept
 
reverse_iterator rend () noexcept
 
void resize (size_type count)
 
constexpr size_type size () const noexcept
 
 static_vector () noexcept=default
 
 static_vector (size_type count)
 
 static_vector (size_type count, T const &)
 
 static_vector (static_vector &&) noexcept=default
 
 static_vector (static_vector const &)=default
 
 static_vector (std::initializer_list< T > init)
 
void swap (static_vector &) noexcept
 

Static Public Member Functions

static constexpr size_type capacity () noexcept
 
static constexpr size_type max_size () noexcept
 

Detailed Description

template<typename T>
class static_vector< T, 0 >

Specialization of static_vector for MaxSize == 0.

Provides full API for compatibility with generic code. All modifying operations trigger a PANIC or throw on access.

Member Typedef Documentation

◆ const_iterator

template<typename T >
using static_vector< T, 0 >::const_iterator = T const*

◆ const_pointer

template<typename T >
using static_vector< T, 0 >::const_pointer = T const*

◆ const_reference

template<typename T >
using static_vector< T, 0 >::const_reference = T const&

◆ const_reverse_iterator

template<typename T >
using static_vector< T, 0 >::const_reverse_iterator = std::reverse_iterator<const_iterator>

◆ difference_type

template<typename T >
using static_vector< T, 0 >::difference_type = std::ptrdiff_t

◆ iterator

template<typename T >
using static_vector< T, 0 >::iterator = T*

◆ pointer

template<typename T >
using static_vector< T, 0 >::pointer = T*

◆ reference

template<typename T >
using static_vector< T, 0 >::reference = T&

◆ reverse_iterator

template<typename T >
using static_vector< T, 0 >::reverse_iterator = std::reverse_iterator<iterator>

◆ size_type

template<typename T >
using static_vector< T, 0 >::size_type = std::size_t

◆ value_type

template<typename T >
using static_vector< T, 0 >::value_type = T

Constructor & Destructor Documentation

◆ static_vector() [1/6]

template<typename T >
static_vector< T, 0 >::static_vector ( )
defaultnoexcept

◆ static_vector() [2/6]

template<typename T >
static_vector< T, 0 >::static_vector ( size_type  count)
inlineexplicit

◆ static_vector() [3/6]

template<typename T >
static_vector< T, 0 >::static_vector ( size_type  count,
T const &   
)
inline

◆ static_vector() [4/6]

template<typename T >
static_vector< T, 0 >::static_vector ( std::initializer_list< T >  init)
inline

◆ static_vector() [5/6]

template<typename T >
static_vector< T, 0 >::static_vector ( static_vector< T, 0 > const &  )
default

◆ static_vector() [6/6]

template<typename T >
static_vector< T, 0 >::static_vector ( static_vector< T, 0 > &&  )
defaultnoexcept

Member Function Documentation

◆ at() [1/2]

template<typename T >
reference static_vector< T, 0 >::at ( size_type  )
inline

◆ at() [2/2]

template<typename T >
const_reference static_vector< T, 0 >::at ( size_type  ) const
inline

◆ back() [1/2]

template<typename T >
reference static_vector< T, 0 >::back ( )
inline

◆ back() [2/2]

template<typename T >
const_reference static_vector< T, 0 >::back ( ) const
inline

◆ begin() [1/2]

template<typename T >
const_iterator static_vector< T, 0 >::begin ( ) const
inlinenoexcept

◆ begin() [2/2]

template<typename T >
iterator static_vector< T, 0 >::begin ( )
inlinenoexcept

◆ capacity()

template<typename T >
static constexpr size_type static_vector< T, 0 >::capacity ( )
inlinestaticconstexprnoexcept

◆ cbegin()

template<typename T >
const_iterator static_vector< T, 0 >::cbegin ( ) const
inlinenoexcept

◆ cend()

template<typename T >
const_iterator static_vector< T, 0 >::cend ( ) const
inlinenoexcept

◆ clear()

template<typename T >
void static_vector< T, 0 >::clear ( )
inlinenoexcept

◆ crbegin()

template<typename T >
const_reverse_iterator static_vector< T, 0 >::crbegin ( ) const
inlinenoexcept

◆ crend()

template<typename T >
const_reverse_iterator static_vector< T, 0 >::crend ( ) const
inlinenoexcept

◆ data() [1/2]

template<typename T >
const_pointer static_vector< T, 0 >::data ( ) const
inlinenoexcept

◆ data() [2/2]

template<typename T >
pointer static_vector< T, 0 >::data ( )
inlinenoexcept

◆ emplace_back()

template<typename T >
template<typename... Args>
void static_vector< T, 0 >::emplace_back ( Args &&  ...)
inline

◆ empty()

template<typename T >
constexpr bool static_vector< T, 0 >::empty ( ) const
inlineconstexprnoexcept

◆ end() [1/2]

template<typename T >
const_iterator static_vector< T, 0 >::end ( ) const
inlinenoexcept

◆ end() [2/2]

template<typename T >
iterator static_vector< T, 0 >::end ( )
inlinenoexcept

◆ front() [1/2]

template<typename T >
reference static_vector< T, 0 >::front ( )
inline

◆ front() [2/2]

template<typename T >
const_reference static_vector< T, 0 >::front ( ) const
inline

◆ max_size()

template<typename T >
static constexpr size_type static_vector< T, 0 >::max_size ( )
inlinestaticconstexprnoexcept

◆ operator=() [1/3]

template<typename T >
static_vector & static_vector< T, 0 >::operator= ( static_vector< T, 0 > &&  )
defaultnoexcept

◆ operator=() [2/3]

template<typename T >
static_vector & static_vector< T, 0 >::operator= ( static_vector< T, 0 > const &  )
default

◆ operator=() [3/3]

template<typename T >
static_vector & static_vector< T, 0 >::operator= ( std::initializer_list< T >  init)
inline

◆ operator[]() [1/2]

template<typename T >
reference static_vector< T, 0 >::operator[] ( size_type  )
inline

◆ operator[]() [2/2]

template<typename T >
const_reference static_vector< T, 0 >::operator[] ( size_type  ) const
inline

◆ pop_back()

template<typename T >
void static_vector< T, 0 >::pop_back ( )
inline

◆ push_back() [1/2]

template<typename T >
void static_vector< T, 0 >::push_back ( T &&  )
inline

◆ push_back() [2/2]

template<typename T >
void static_vector< T, 0 >::push_back ( T const &  )
inline

◆ rbegin() [1/2]

template<typename T >
const_reverse_iterator static_vector< T, 0 >::rbegin ( ) const
inlinenoexcept

◆ rbegin() [2/2]

template<typename T >
reverse_iterator static_vector< T, 0 >::rbegin ( )
inlinenoexcept

◆ rend() [1/2]

template<typename T >
const_reverse_iterator static_vector< T, 0 >::rend ( ) const
inlinenoexcept

◆ rend() [2/2]

template<typename T >
reverse_iterator static_vector< T, 0 >::rend ( )
inlinenoexcept

◆ resize()

template<typename T >
void static_vector< T, 0 >::resize ( size_type  count)
inline

◆ size()

template<typename T >
constexpr size_type static_vector< T, 0 >::size ( ) const
inlineconstexprnoexcept

◆ swap()

template<typename T >
void static_vector< T, 0 >::swap ( static_vector< T, 0 > &  )
inlinenoexcept
The documentation for this class was generated from the following file:
Generated by doxygen 1.9.8