TwiceAsNice  2019-02-18
Public Types | Public Member Functions | Private Attributes | List of all members
Nice::Vector< T, Allocator > Class Template Reference

#include <Vector.h>

Collaboration diagram for Nice::Vector< T, Allocator >:
Collaboration graph

Public Types

typedef std::vector< T, Allocator >::iterator iterator
 
typedef std::vector< T, Allocator >::const_iterator const_iterator
 
typedef std::vector< T, Allocator >::reverse_iterator reverse_iterator
 
typedef std::vector< T, Allocator >::const_reverse_iterator const_reverse_iterator
 
typedef std::vector< T, Allocator >::allocator_type allocator_type
 
typedef std::vector< T, Allocator >::value_type value_type
 
typedef std::vector< T, Allocator >::size_type size_type
 
typedef std::vector< T, Allocator >::difference_type difference_type
 

Public Member Functions

 Vector (const Allocator &alloc=Allocator())
 
 Vector (size_type n, const T &value=T(), const Allocator &alloc=Allocator())
 
template<class InputIterator >
 Vector (InputIterator first, InputIterator last, const Allocator &alloc=Allocator())
 
 Vector (const Nice::Vector< T, Allocator > &x)
 
Nice::Vector< T, Allocator > & operator= (const Nice::Vector< T, Allocator > &x)
 
 ~Vector (void)
 
iterator begin (void)
 
const_iterator begin (void) const
 
iterator end (void)
 
const_iterator end (void) const
 
reverse_iterator rbegin (void)
 
const_reverse_iterator rbegin (void) const
 
reverse_iterator rend (void)
 
const_reverse_iterator rend (void) const
 
size_type size (void) const
 
size_type max_size (void) const
 
void resize (size_type n, T c=T())
 
size_type capacity (void) const
 
bool empty (void) const
 
void reserve (size_type n)
 
T & operator[] (size_type n)
 
const T & operator[] (size_type n) const
 
T & at (size_type n)
 
const T & at (size_type n) const
 
T & front (void)
 
const T & front (void) const
 
T & back (void)
 
const T & back (void) const
 
void assign (size_type n, T &u)
 
template<class InputIterator >
void assign (InputIterator begin, InputIterator end)
 
void push_back (const T &u)
 
void pop_back (void)
 
iterator insert (iterator pos, const T &u)
 
void insert (iterator pos, size_type n, const T &u)
 
template<class InputIterator >
void insert (iterator pos, InputIterator begin, InputIterator end)
 
void erase (iterator pos)
 
void erase (iterator begin, iterator end)
 
void swap (Nice::Vector< T, Allocator > &x)
 
void clear (void)
 
allocator_type get_allocator (void) const
 
 operator std::vector< T, Allocator > ()
 

Private Attributes

boost::mutex mutex
 
std::vector< T, Allocator > storage
 

Member Typedef Documentation

◆ allocator_type

template<class T , class Allocator = std::allocator<T>>
typedef std::vector<T, Allocator>::allocator_type Nice::Vector< T, Allocator >::allocator_type

◆ const_iterator

template<class T , class Allocator = std::allocator<T>>
typedef std::vector<T, Allocator>::const_iterator Nice::Vector< T, Allocator >::const_iterator

◆ const_reverse_iterator

template<class T , class Allocator = std::allocator<T>>
typedef std::vector<T, Allocator>::const_reverse_iterator Nice::Vector< T, Allocator >::const_reverse_iterator

◆ difference_type

template<class T , class Allocator = std::allocator<T>>
typedef std::vector<T, Allocator>::difference_type Nice::Vector< T, Allocator >::difference_type

◆ iterator

template<class T , class Allocator = std::allocator<T>>
typedef std::vector<T, Allocator>::iterator Nice::Vector< T, Allocator >::iterator

◆ reverse_iterator

template<class T , class Allocator = std::allocator<T>>
typedef std::vector<T, Allocator>::reverse_iterator Nice::Vector< T, Allocator >::reverse_iterator

◆ size_type

template<class T , class Allocator = std::allocator<T>>
typedef std::vector<T, Allocator>::size_type Nice::Vector< T, Allocator >::size_type

◆ value_type

template<class T , class Allocator = std::allocator<T>>
typedef std::vector<T, Allocator>::value_type Nice::Vector< T, Allocator >::value_type

Constructor & Destructor Documentation

◆ Vector() [1/4]

template<class T , class Allocator = std::allocator<T>>
Nice::Vector< T, Allocator >::Vector ( const Allocator &  alloc = Allocator())
inlineexplicit

◆ Vector() [2/4]

template<class T , class Allocator = std::allocator<T>>
Nice::Vector< T, Allocator >::Vector ( size_type  n,
const T &  value = T(),
const Allocator &  alloc = Allocator() 
)
inlineexplicit

◆ Vector() [3/4]

template<class T , class Allocator = std::allocator<T>>
template<class InputIterator >
Nice::Vector< T, Allocator >::Vector ( InputIterator  first,
InputIterator  last,
const Allocator &  alloc = Allocator() 
)
inline

◆ Vector() [4/4]

template<class T , class Allocator = std::allocator<T>>
Nice::Vector< T, Allocator >::Vector ( const Nice::Vector< T, Allocator > &  x)
inline

◆ ~Vector()

template<class T , class Allocator = std::allocator<T>>
Nice::Vector< T, Allocator >::~Vector ( void  )
inline

Member Function Documentation

◆ assign() [1/2]

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::assign ( size_type  n,
T &  u 
)
inline

◆ assign() [2/2]

template<class T , class Allocator = std::allocator<T>>
template<class InputIterator >
void Nice::Vector< T, Allocator >::assign ( InputIterator  begin,
InputIterator  end 
)
inline

◆ at() [1/2]

template<class T , class Allocator = std::allocator<T>>
T& Nice::Vector< T, Allocator >::at ( size_type  n)
inline

◆ at() [2/2]

template<class T , class Allocator = std::allocator<T>>
const T& Nice::Vector< T, Allocator >::at ( size_type  n) const
inline

◆ back() [1/2]

template<class T , class Allocator = std::allocator<T>>
T& Nice::Vector< T, Allocator >::back ( void  )
inline

◆ back() [2/2]

template<class T , class Allocator = std::allocator<T>>
const T& Nice::Vector< T, Allocator >::back ( void  ) const
inline

◆ begin() [1/2]

template<class T , class Allocator = std::allocator<T>>
iterator Nice::Vector< T, Allocator >::begin ( void  )
inline

◆ begin() [2/2]

template<class T , class Allocator = std::allocator<T>>
const_iterator Nice::Vector< T, Allocator >::begin ( void  ) const
inline

◆ capacity()

template<class T , class Allocator = std::allocator<T>>
size_type Nice::Vector< T, Allocator >::capacity ( void  ) const
inline

◆ clear()

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::clear ( void  )
inline

◆ empty()

template<class T , class Allocator = std::allocator<T>>
bool Nice::Vector< T, Allocator >::empty ( void  ) const
inline

◆ end() [1/2]

template<class T , class Allocator = std::allocator<T>>
iterator Nice::Vector< T, Allocator >::end ( void  )
inline

◆ end() [2/2]

template<class T , class Allocator = std::allocator<T>>
const_iterator Nice::Vector< T, Allocator >::end ( void  ) const
inline

◆ erase() [1/2]

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::erase ( iterator  pos)
inline

◆ erase() [2/2]

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::erase ( iterator  begin,
iterator  end 
)
inline

◆ front() [1/2]

template<class T , class Allocator = std::allocator<T>>
T& Nice::Vector< T, Allocator >::front ( void  )
inline

◆ front() [2/2]

template<class T , class Allocator = std::allocator<T>>
const T& Nice::Vector< T, Allocator >::front ( void  ) const
inline

◆ get_allocator()

template<class T , class Allocator = std::allocator<T>>
allocator_type Nice::Vector< T, Allocator >::get_allocator ( void  ) const
inline

◆ insert() [1/3]

template<class T , class Allocator = std::allocator<T>>
iterator Nice::Vector< T, Allocator >::insert ( iterator  pos,
const T &  u 
)
inline

◆ insert() [2/3]

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::insert ( iterator  pos,
size_type  n,
const T &  u 
)
inline

◆ insert() [3/3]

template<class T , class Allocator = std::allocator<T>>
template<class InputIterator >
void Nice::Vector< T, Allocator >::insert ( iterator  pos,
InputIterator  begin,
InputIterator  end 
)
inline

◆ max_size()

template<class T , class Allocator = std::allocator<T>>
size_type Nice::Vector< T, Allocator >::max_size ( void  ) const
inline

◆ operator std::vector< T, Allocator >()

template<class T , class Allocator = std::allocator<T>>
Nice::Vector< T, Allocator >::operator std::vector< T, Allocator > ( )
inline

◆ operator=()

template<class T , class Allocator = std::allocator<T>>
Nice::Vector<T, Allocator>& Nice::Vector< T, Allocator >::operator= ( const Nice::Vector< T, Allocator > &  x)
inline

◆ operator[]() [1/2]

template<class T , class Allocator = std::allocator<T>>
T& Nice::Vector< T, Allocator >::operator[] ( size_type  n)
inline

◆ operator[]() [2/2]

template<class T , class Allocator = std::allocator<T>>
const T& Nice::Vector< T, Allocator >::operator[] ( size_type  n) const
inline

◆ pop_back()

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::pop_back ( void  )
inline

◆ push_back()

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::push_back ( const T &  u)
inline

◆ rbegin() [1/2]

template<class T , class Allocator = std::allocator<T>>
reverse_iterator Nice::Vector< T, Allocator >::rbegin ( void  )
inline

◆ rbegin() [2/2]

template<class T , class Allocator = std::allocator<T>>
const_reverse_iterator Nice::Vector< T, Allocator >::rbegin ( void  ) const
inline

◆ rend() [1/2]

template<class T , class Allocator = std::allocator<T>>
reverse_iterator Nice::Vector< T, Allocator >::rend ( void  )
inline

◆ rend() [2/2]

template<class T , class Allocator = std::allocator<T>>
const_reverse_iterator Nice::Vector< T, Allocator >::rend ( void  ) const
inline

◆ reserve()

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::reserve ( size_type  n)

◆ resize()

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::resize ( size_type  n,
T  c = T() 
)
inline

◆ size()

template<class T , class Allocator = std::allocator<T>>
size_type Nice::Vector< T, Allocator >::size ( void  ) const
inline

◆ swap()

template<class T , class Allocator = std::allocator<T>>
void Nice::Vector< T, Allocator >::swap ( Nice::Vector< T, Allocator > &  x)
inline

Member Data Documentation

◆ mutex

template<class T , class Allocator = std::allocator<T>>
boost::mutex Nice::Vector< T, Allocator >::mutex
mutableprivate

◆ storage

template<class T , class Allocator = std::allocator<T>>
std::vector<T, Allocator> Nice::Vector< T, Allocator >::storage
private
The documentation for this class was generated from the following file:
Generated on Mon Feb 18 2019 14:19:24 for TwiceAsNice by   doxygen 1.8.14