momo  3.12
Public Types | Public Member Functions | Friends | List of all members
momo::stdish::vector_adaptor< TArray > Class Template Reference

#include <vector.h>

Public Types

typedef Array::Item value_type
 
typedef std::allocator_traits< typename MemManager::ByteAllocator >::template rebind_alloc< value_type > allocator_type
 
typedef Array nested_container_type
 
typedef size_t size_type
 
typedef ptrdiff_t difference_type
 
typedef Array::Iterator iterator
 
typedef Array::ConstIterator const_iterator
 
typedef value_type & reference
 
typedef const value_type & const_reference
 
typedef value_type * pointer
 
typedef const value_type * const_pointer
 
typedef std::reverse_iterator< iterator > reverse_iterator
 
typedef std::reverse_iterator< const_iterator > const_reverse_iterator
 

Public Member Functions

 vector_adaptor () noexcept(noexcept(Array()))
 
 vector_adaptor (const allocator_type &alloc) noexcept
 
 vector_adaptor (size_type count, const allocator_type &alloc=allocator_type())
 
 vector_adaptor (size_type count, const value_type &value, const allocator_type &alloc=allocator_type())
 
template<typename Iterator , typename = typename std::iterator_traits<Iterator>::iterator_category>
 vector_adaptor (Iterator first, Iterator last, const allocator_type &alloc=allocator_type())
 
 vector_adaptor (std::initializer_list< value_type > values, const allocator_type &alloc=allocator_type())
 
 vector_adaptor (vector_adaptor &&right) noexcept
 
 vector_adaptor (vector_adaptor &&right, const allocator_type &alloc) noexcept(std::is_empty< allocator_type >::value)
 
 vector_adaptor (const vector_adaptor &right)
 
 vector_adaptor (const vector_adaptor &right, const allocator_type &alloc)
 
 ~vector_adaptor ()=default
 
vector_adaptor & operator= (vector_adaptor &&right) noexcept(momo::internal::ContainerAssignerStd::IsNothrowMoveAssignable< vector_adaptor >::value)
 
vector_adaptor & operator= (const vector_adaptor &right)
 
vector_adaptor & operator= (std::initializer_list< value_type > values)
 
void swap (vector_adaptor &right) noexcept
 
const nested_container_type & get_nested_container () const noexcept
 
nested_container_type & get_nested_container () noexcept
 
const_iterator begin () const noexcept
 
iterator begin () noexcept
 
const_iterator end () const noexcept
 
iterator end () noexcept
 
const_reverse_iterator rbegin () const noexcept
 
reverse_iterator rbegin () noexcept
 
const_reverse_iterator rend () const noexcept
 
reverse_iterator rend () noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
value_type * data () noexcept
 
const value_type * data () const noexcept
 
allocator_type get_allocator () const noexcept
 
size_type max_size () const noexcept
 
size_type size () const noexcept
 
void resize (size_type size)
 
void resize (size_type size, const value_type &value)
 
MOMO_NODISCARD bool empty () const noexcept
 
void clear () noexcept
 
size_type capacity () const noexcept
 
void reserve (size_type count)
 
void shrink_to_fit ()
 
const_reference operator[] (size_type index) const
 
reference operator[] (size_type index)
 
const_reference at (size_type index) const
 
reference at (size_type index)
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
void push_back (value_type &&value)
 
void push_back (const value_type &value)
 
iterator insert (const_iterator where, value_type &&value)
 
iterator insert (const_iterator where, const value_type &value)
 
iterator insert (const_iterator where, size_type count, const value_type &value)
 
template<typename Iterator , typename = typename std::iterator_traits<Iterator>::iterator_category>
iterator insert (const_iterator where, Iterator first, Iterator last)
 
iterator insert (const_iterator where, std::initializer_list< value_type > values)
 
template<typename... ValueArgs>
reference emplace_back (ValueArgs &&... valueArgs)
 
template<typename... ValueArgs>
iterator emplace (const_iterator where, ValueArgs &&... valueArgs)
 
void pop_back ()
 
iterator erase (const_iterator where)
 
iterator erase (const_iterator first, const_iterator last)
 
void assign (size_type count, const value_type &value)
 
template<typename Iterator , typename = typename std::iterator_traits<Iterator>::iterator_category>
void assign (Iterator first, Iterator last)
 
void assign (std::initializer_list< value_type > values)
 

Friends

void swap (vector_adaptor &left, vector_adaptor &right) noexcept
 
template<typename ValueArg = value_type>
size_type erase (vector_adaptor &cont, const ValueArg &valueArg)
 
template<typename ValueFilter >
size_type erase_if (vector_adaptor &cont, const ValueFilter &valueFilter)
 
bool operator== (const vector_adaptor &left, const vector_adaptor &right)
 
bool operator< (const vector_adaptor &left, const vector_adaptor &right)
 

Member Typedef Documentation

◆ allocator_type

template<typename TArray >
typedef std::allocator_traits<typename MemManager::ByteAllocator>::template rebind_alloc<value_type> momo::stdish::vector_adaptor< TArray >::allocator_type

◆ const_iterator

template<typename TArray >
typedef Array::ConstIterator momo::stdish::vector_adaptor< TArray >::const_iterator

◆ const_pointer

template<typename TArray >
typedef const value_type* momo::stdish::vector_adaptor< TArray >::const_pointer

◆ const_reference

template<typename TArray >
typedef const value_type& momo::stdish::vector_adaptor< TArray >::const_reference

◆ const_reverse_iterator

template<typename TArray >
typedef std::reverse_iterator<const_iterator> momo::stdish::vector_adaptor< TArray >::const_reverse_iterator

◆ difference_type

template<typename TArray >
typedef ptrdiff_t momo::stdish::vector_adaptor< TArray >::difference_type

◆ iterator

template<typename TArray >
typedef Array::Iterator momo::stdish::vector_adaptor< TArray >::iterator

◆ nested_container_type

template<typename TArray >
typedef Array momo::stdish::vector_adaptor< TArray >::nested_container_type

◆ pointer

template<typename TArray >
typedef value_type* momo::stdish::vector_adaptor< TArray >::pointer

◆ reference

template<typename TArray >
typedef value_type& momo::stdish::vector_adaptor< TArray >::reference

◆ reverse_iterator

template<typename TArray >
typedef std::reverse_iterator<iterator> momo::stdish::vector_adaptor< TArray >::reverse_iterator

◆ size_type

template<typename TArray >
typedef size_t momo::stdish::vector_adaptor< TArray >::size_type

◆ value_type

template<typename TArray >
typedef Array::Item momo::stdish::vector_adaptor< TArray >::value_type

Constructor & Destructor Documentation

◆ vector_adaptor() [1/10]

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( )
inlinenoexcept

◆ vector_adaptor() [2/10]

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( const allocator_type &  alloc)
inlineexplicitnoexcept

◆ vector_adaptor() [3/10]

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( size_type  count,
const allocator_type &  alloc = allocator_type() 
)
inlineexplicit

◆ vector_adaptor() [4/10]

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( size_type  count,
const value_type &  value,
const allocator_type &  alloc = allocator_type() 
)
inline

◆ vector_adaptor() [5/10]

template<typename TArray >
template<typename Iterator , typename = typename std::iterator_traits<Iterator>::iterator_category>
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( Iterator  first,
Iterator  last,
const allocator_type &  alloc = allocator_type() 
)
inline

◆ vector_adaptor() [6/10]

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( std::initializer_list< value_type >  values,
const allocator_type &  alloc = allocator_type() 
)
inline

◆ vector_adaptor() [7/10]

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( vector_adaptor< TArray > &&  right)
inlinenoexcept

◆ vector_adaptor() [8/10]

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( vector_adaptor< TArray > &&  right,
const allocator_type &  alloc 
)
inlinenoexcept

◆ vector_adaptor() [9/10]

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( const vector_adaptor< TArray > &  right)
inline

◆ vector_adaptor() [10/10]

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::vector_adaptor ( const vector_adaptor< TArray > &  right,
const allocator_type &  alloc 
)
inline

◆ ~vector_adaptor()

template<typename TArray >
momo::stdish::vector_adaptor< TArray >::~vector_adaptor ( )
default

Member Function Documentation

◆ assign() [1/3]

template<typename TArray >
template<typename Iterator , typename = typename std::iterator_traits<Iterator>::iterator_category>
void momo::stdish::vector_adaptor< TArray >::assign ( Iterator  first,
Iterator  last 
)
inline

◆ assign() [2/3]

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::assign ( size_type  count,
const value_type &  value 
)
inline

◆ assign() [3/3]

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::assign ( std::initializer_list< value_type >  values)
inline

◆ at() [1/2]

template<typename TArray >
reference momo::stdish::vector_adaptor< TArray >::at ( size_type  index)
inline

◆ at() [2/2]

template<typename TArray >
const_reference momo::stdish::vector_adaptor< TArray >::at ( size_type  index) const
inline

◆ back() [1/2]

template<typename TArray >
reference momo::stdish::vector_adaptor< TArray >::back ( )
inline

◆ back() [2/2]

template<typename TArray >
const_reference momo::stdish::vector_adaptor< TArray >::back ( ) const
inline

◆ begin() [1/2]

template<typename TArray >
const_iterator momo::stdish::vector_adaptor< TArray >::begin ( ) const
inlinenoexcept

◆ begin() [2/2]

template<typename TArray >
iterator momo::stdish::vector_adaptor< TArray >::begin ( )
inlinenoexcept

◆ capacity()

template<typename TArray >
size_type momo::stdish::vector_adaptor< TArray >::capacity ( ) const
inlinenoexcept

◆ cbegin()

template<typename TArray >
const_iterator momo::stdish::vector_adaptor< TArray >::cbegin ( ) const
inlinenoexcept

◆ cend()

template<typename TArray >
const_iterator momo::stdish::vector_adaptor< TArray >::cend ( ) const
inlinenoexcept

◆ clear()

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::clear ( )
inlinenoexcept

◆ crbegin()

template<typename TArray >
const_reverse_iterator momo::stdish::vector_adaptor< TArray >::crbegin ( ) const
inlinenoexcept

◆ crend()

template<typename TArray >
const_reverse_iterator momo::stdish::vector_adaptor< TArray >::crend ( ) const
inlinenoexcept

◆ data() [1/2]

template<typename TArray >
const value_type* momo::stdish::vector_adaptor< TArray >::data ( ) const
inlinenoexcept

◆ data() [2/2]

template<typename TArray >
value_type* momo::stdish::vector_adaptor< TArray >::data ( )
inlinenoexcept

◆ emplace()

template<typename TArray >
template<typename... ValueArgs>
iterator momo::stdish::vector_adaptor< TArray >::emplace ( const_iterator  where,
ValueArgs &&...  valueArgs 
)
inline

◆ emplace_back()

template<typename TArray >
template<typename... ValueArgs>
reference momo::stdish::vector_adaptor< TArray >::emplace_back ( ValueArgs &&...  valueArgs)
inline

◆ empty()

template<typename TArray >
MOMO_NODISCARD bool momo::stdish::vector_adaptor< TArray >::empty ( ) const
inlinenoexcept

◆ end() [1/2]

template<typename TArray >
const_iterator momo::stdish::vector_adaptor< TArray >::end ( ) const
inlinenoexcept

◆ end() [2/2]

template<typename TArray >
iterator momo::stdish::vector_adaptor< TArray >::end ( )
inlinenoexcept

◆ erase() [1/2]

template<typename TArray >
iterator momo::stdish::vector_adaptor< TArray >::erase ( const_iterator  first,
const_iterator  last 
)
inline

◆ erase() [2/2]

template<typename TArray >
iterator momo::stdish::vector_adaptor< TArray >::erase ( const_iterator  where)
inline

◆ front() [1/2]

template<typename TArray >
reference momo::stdish::vector_adaptor< TArray >::front ( )
inline

◆ front() [2/2]

template<typename TArray >
const_reference momo::stdish::vector_adaptor< TArray >::front ( ) const
inline

◆ get_allocator()

template<typename TArray >
allocator_type momo::stdish::vector_adaptor< TArray >::get_allocator ( ) const
inlinenoexcept

◆ get_nested_container() [1/2]

template<typename TArray >
const nested_container_type& momo::stdish::vector_adaptor< TArray >::get_nested_container ( ) const
inlinenoexcept

◆ get_nested_container() [2/2]

template<typename TArray >
nested_container_type& momo::stdish::vector_adaptor< TArray >::get_nested_container ( )
inlinenoexcept

◆ insert() [1/5]

template<typename TArray >
iterator momo::stdish::vector_adaptor< TArray >::insert ( const_iterator  where,
const value_type &  value 
)
inline

◆ insert() [2/5]

template<typename TArray >
template<typename Iterator , typename = typename std::iterator_traits<Iterator>::iterator_category>
iterator momo::stdish::vector_adaptor< TArray >::insert ( const_iterator  where,
Iterator  first,
Iterator  last 
)
inline

◆ insert() [3/5]

template<typename TArray >
iterator momo::stdish::vector_adaptor< TArray >::insert ( const_iterator  where,
size_type  count,
const value_type &  value 
)
inline

◆ insert() [4/5]

template<typename TArray >
iterator momo::stdish::vector_adaptor< TArray >::insert ( const_iterator  where,
std::initializer_list< value_type >  values 
)
inline

◆ insert() [5/5]

template<typename TArray >
iterator momo::stdish::vector_adaptor< TArray >::insert ( const_iterator  where,
value_type &&  value 
)
inline

◆ max_size()

template<typename TArray >
size_type momo::stdish::vector_adaptor< TArray >::max_size ( ) const
inlinenoexcept

◆ operator=() [1/3]

template<typename TArray >
vector_adaptor& momo::stdish::vector_adaptor< TArray >::operator= ( const vector_adaptor< TArray > &  right)
inline

◆ operator=() [2/3]

template<typename TArray >
vector_adaptor& momo::stdish::vector_adaptor< TArray >::operator= ( std::initializer_list< value_type >  values)
inline

◆ operator=() [3/3]

template<typename TArray >
vector_adaptor& momo::stdish::vector_adaptor< TArray >::operator= ( vector_adaptor< TArray > &&  right)
inlinenoexcept

◆ operator[]() [1/2]

template<typename TArray >
reference momo::stdish::vector_adaptor< TArray >::operator[] ( size_type  index)
inline

◆ operator[]() [2/2]

template<typename TArray >
const_reference momo::stdish::vector_adaptor< TArray >::operator[] ( size_type  index) const
inline

◆ pop_back()

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::pop_back ( )
inline

◆ push_back() [1/2]

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::push_back ( const value_type &  value)
inline

◆ push_back() [2/2]

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::push_back ( value_type &&  value)
inline

◆ rbegin() [1/2]

template<typename TArray >
const_reverse_iterator momo::stdish::vector_adaptor< TArray >::rbegin ( ) const
inlinenoexcept

◆ rbegin() [2/2]

template<typename TArray >
reverse_iterator momo::stdish::vector_adaptor< TArray >::rbegin ( )
inlinenoexcept

◆ rend() [1/2]

template<typename TArray >
const_reverse_iterator momo::stdish::vector_adaptor< TArray >::rend ( ) const
inlinenoexcept

◆ rend() [2/2]

template<typename TArray >
reverse_iterator momo::stdish::vector_adaptor< TArray >::rend ( )
inlinenoexcept

◆ reserve()

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::reserve ( size_type  count)
inline

◆ resize() [1/2]

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::resize ( size_type  size)
inline

◆ resize() [2/2]

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::resize ( size_type  size,
const value_type &  value 
)
inline

◆ shrink_to_fit()

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::shrink_to_fit ( )
inline

◆ size()

template<typename TArray >
size_type momo::stdish::vector_adaptor< TArray >::size ( ) const
inlinenoexcept

◆ swap()

template<typename TArray >
void momo::stdish::vector_adaptor< TArray >::swap ( vector_adaptor< TArray > &  right)
inlinenoexcept

Friends And Related Function Documentation

◆ erase

template<typename TArray >
template<typename ValueArg = value_type>
size_type erase ( vector_adaptor< TArray > &  cont,
const ValueArg &  valueArg 
)
friend

◆ erase_if

template<typename TArray >
template<typename ValueFilter >
size_type erase_if ( vector_adaptor< TArray > &  cont,
const ValueFilter &  valueFilter 
)
friend

◆ operator<

template<typename TArray >
bool operator< ( const vector_adaptor< TArray > &  left,
const vector_adaptor< TArray > &  right 
)
friend

◆ operator==

template<typename TArray >
bool operator== ( const vector_adaptor< TArray > &  left,
const vector_adaptor< TArray > &  right 
)
friend

◆ swap

template<typename TArray >
void swap ( vector_adaptor< TArray > &  left,
vector_adaptor< TArray > &  right 
)
friend
The documentation for this class was generated from the following file: