Common ODB Runtime Library: odb::vector< T, A > Class Template Reference

Common ODB Runtime Library

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

Inheritance diagram for odb::vector< T, A >:

Public Types
typedef std::vector< T, A >	base_vector_type

typedef base_vector_type::iterator	base_iterator_type

typedef base_vector_type::reverse_iterator	base_reverse_iterator_type

typedef base_vector_type::reference	reference

typedef base_vector_type::const_reference	const_reference

typedef vector_iterator < vector, base_iterator_type >	iterator

typedef base_vector_type::const_iterator	const_iterator

typedef base_vector_type::size_type	size_type

typedef base_vector_type::difference_type	difference_type

typedef T	value_type

typedef A	allocator_type

typedef base_vector_type::pointer	pointer

typedef base_vector_type::const_pointer	const_pointer

typedef vector_iterator < vector, base_reverse_iterator_type >	reverse_iterator

typedef base_vector_type::const_reverse_iterator	const_reverse_iterator

Public Member Functions
	vector (const A &a=A())

	vector (size_type n)

	vector (size_type n, const T &v, const A &a=A())

template<class I >
	vector (I f, I l, const A &a=A())

	vector (const vector &x)

vector &	operator= (const vector &)

template<class I >
void	assign (I f, I l)

void	assign (size_type n, const T &u)

allocator_type	get_allocator () const

iterator	begin ()

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

reverse_iterator	rbegin ()

reverse_iterator	rend ()

const_reverse_iterator	rbegin () const

const_reverse_iterator	rend () const

base_iterator_type	mbegin ()

base_iterator_type	mend ()

base_reverse_iterator_type	mrbegin ()

base_reverse_iterator_type	mrend ()

size_type	size () const

size_type	max_size () const

void	resize (size_type)

void	resize (size_type, const T &)

size_type	capacity () const

bool	empty () const

void	reserve (size_type)

reference	modify (size_type n)

const_reference	operator[] (size_type n) const

reference	modify_at (size_type n)

const_reference	at (size_type n) const

reference	modify_front ()

const_reference	front () const

reference	modify_back ()

const_reference	back () const

void	push_back (const T &x)

void	pop_back ()

iterator	insert (iterator position, const T &x)

void	insert (iterator position, size_type n, const T &x)

template<class I >
void	insert (iterator position, I first, I last)

iterator	erase (iterator position)

iterator	erase (iterator first, iterator last)

void	swap (vector &)

void	clear ()

	vector (const base_vector_type &x)

vector &	operator= (const base_vector_type &)

	operator const base_vector_type & () const

base_vector_type &	base ()

const base_vector_type &	base () const

void	_start () const

Public Member Functions inherited from odb::vector_base
void	_stop () const

bool	_tracking () const

void	_arm (transaction &t) const

vector_impl &	_impl () const

Additional Inherited Members
Protected Member Functions inherited from odb::vector_base
	vector_base ()

	~vector_base ()

	vector_base (const vector_base &)

void	swap (vector_base &)

Static Protected Member Functions inherited from odb::vector_base
static void	rollback (unsigned short, void *key, unsigned long long)

Protected Attributes inherited from odb::vector_base
vector_impl	impl_

transaction *	tran_

Member Typedef Documentation

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef std::vector<T, A> odb::vector< T, A >::base_vector_type

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::iterator odb::vector< T, A >::base_iterator_type

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::reverse_iterator odb::vector< T, A >::base_reverse_iterator_type

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::reference odb::vector< T, A >::reference

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::const_reference odb::vector< T, A >::const_reference

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef vector_iterator<vector, base_iterator_type> odb::vector< T, A >::iterator

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::const_iterator odb::vector< T, A >::const_iterator

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::size_type odb::vector< T, A >::size_type

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::difference_type odb::vector< T, A >::difference_type

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef T odb::vector< T, A >::value_type

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef A odb::vector< T, A >::allocator_type

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::pointer odb::vector< T, A >::pointer

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::const_pointer odb::vector< T, A >::const_pointer

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef vector_iterator<vector, base_reverse_iterator_type> odb::vector< T, A >::reverse_iterator

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

typedef base_vector_type::const_reverse_iterator odb::vector< T, A >::const_reverse_iterator

Constructor & Destructor Documentation

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

odb::vector< T, A >::vector ( const A & a = A() )

inlineexplicit

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

odb::vector< T, A >::vector ( size_type n )

inlineexplicit

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

odb::vector< T, A >::vector	(	size_type	n,
		const T &	v,
		const A &	a = `A()`
	)

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

template<class I >

odb::vector< T, A >::vector	(	I	f,
		I	l,
		const A &	a = `A()`
	)

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

odb::vector< T, A >::vector ( const vector< T, A > & x )

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

odb::vector< T, A >::vector ( const base_vector_type & x )

inline

Member Function Documentation

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

vector& odb::vector< T, A >::operator= ( const vector< T, A > & )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

template<class I >

void odb::vector< T, A >::assign	(	I	f,
		I	l
	)

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::assign	(	size_type	n,
		const T &	u
	)

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

allocator_type odb::vector< T, A >::get_allocator ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

iterator odb::vector< T, A >::begin ( )

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

iterator odb::vector< T, A >::end ( )

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

const_iterator odb::vector< T, A >::begin ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

const_iterator odb::vector< T, A >::end ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

reverse_iterator odb::vector< T, A >::rbegin ( )

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

reverse_iterator odb::vector< T, A >::rend ( )

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

const_reverse_iterator odb::vector< T, A >::rbegin ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

const_reverse_iterator odb::vector< T, A >::rend ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

base_iterator_type odb::vector< T, A >::mbegin ( )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

base_iterator_type odb::vector< T, A >::mend ( )

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

base_reverse_iterator_type odb::vector< T, A >::mrbegin ( )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

base_reverse_iterator_type odb::vector< T, A >::mrend ( )

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

size_type odb::vector< T, A >::size ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

size_type odb::vector< T, A >::max_size ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::resize ( size_type )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::resize	(	size_type	,
		const T &
	)

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

size_type odb::vector< T, A >::capacity ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

bool odb::vector< T, A >::empty ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::reserve ( size_type )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

reference odb::vector< T, A >::modify ( size_type n )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

const_reference odb::vector< T, A >::operator[] ( size_type n ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

reference odb::vector< T, A >::modify_at ( size_type n )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

const_reference odb::vector< T, A >::at ( size_type n ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

reference odb::vector< T, A >::modify_front ( )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

const_reference odb::vector< T, A >::front ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

reference odb::vector< T, A >::modify_back ( )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

const_reference odb::vector< T, A >::back ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::push_back ( const T & x )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::pop_back ( )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

iterator odb::vector< T, A >::insert	(	iterator	position,
		const T &	x
	)

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::insert	(	iterator	position,
		size_type	n,
		const T &	x
	)

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

template<class I >

void odb::vector< T, A >::insert	(	iterator	position,
		I	first,
		I	last
	)

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

iterator odb::vector< T, A >::erase ( iterator position )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

iterator odb::vector< T, A >::erase	(	iterator	first,
		iterator	last
	)

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::swap ( vector< T, A > & )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::clear ( )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

vector& odb::vector< T, A >::operator= ( const base_vector_type & )

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

odb::vector< T, A >::operator const base_vector_type & ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

base_vector_type& odb::vector< T, A >::base ( )

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

const base_vector_type& odb::vector< T, A >::base ( ) const

inline

template<class T, class A = std::allocator<T> LIBODB_VECTOR_ARG_DEFAULT>

void odb::vector< T, A >::_start ( ) const

inline

The documentation for this class was generated from the following file:

vector.hxx