Component bslstl_vector [Package bslstl]

Provide an STL-compliant vector class. More...

Classes
struct	bsl::Vector_Util
struct	bsl::Vector_DeduceIteratorCategory< BSLSTL_ITERATOR, BSLSTL_NOTSPECIALIZED >
struct	bsl::Vector_DeduceIteratorCategory< BSLSTL_ITERATOR, true >
struct	bsl::vector_ForwardIteratorForPtrs< TARGET, ITERATOR, bool >
struct	bsl::vector_ForwardIteratorForPtrs< TARGET, ITERATOR, false >
class	bsl::vectorBase< VALUE_TYPE >
class	bsl::vector< VALUE_TYPE, ALLOCATOR >
class	bsl::vector< VALUE_TYPE, ALLOCATOR >::Proctor
class	bsl::vector< VALUE_TYPE *, ALLOCATOR >
Typedefs
typedef VALUE_TYPE	bsl::vectorBase::value_type
typedef VALUE_TYPE &	bsl::vectorBase::reference
typedef VALUE_TYPE const &	bsl::vectorBase::const_reference
typedef VALUE_TYPE *	bsl::vectorBase::iterator
typedef VALUE_TYPE const *	bsl::vectorBase::const_iterator
typedef std::size_t	bsl::vectorBase::size_type
typedef std::ptrdiff_t	bsl::vectorBase::difference_type
typedef bsl::reverse_iterator < iterator >	bsl::vectorBase::reverse_iterator
typedef bsl::reverse_iterator < const_iterator >	bsl::vectorBase::const_reverse_iterator
typedef VALUE_TYPE	bsl::vector::value_type
typedef ALLOCATOR	bsl::vector::allocator_type
typedef VALUE_TYPE &	bsl::vector::reference
typedef const VALUE_TYPE &	bsl::vector::const_reference
typedef AllocatorTraits::size_type	bsl::vector::size_type
typedef AllocatorTraits::difference_type	bsl::vector::difference_type
typedef AllocatorTraits::pointer	bsl::vector::pointer
typedef AllocatorTraits::const_pointer	bsl::vector::const_pointer
typedef VALUE_TYPE *	bsl::vector::iterator
typedef VALUE_TYPE const *	bsl::vector::const_iterator
typedef bsl::reverse_iterator < iterator >	bsl::vector::reverse_iterator
typedef bsl::reverse_iterator < const_iterator >	bsl::vector::const_reverse_iterator
typedef VALUE_TYPE *	bsl::vector< VALUE_TYPE *, ALLOCATOR >::value_type
typedef value_type &	bsl::vector< VALUE_TYPE *, ALLOCATOR >::reference
typedef const value_type &	bsl::vector< VALUE_TYPE *, ALLOCATOR >::const_reference
typedef VALUE_TYPE **	bsl::vector< VALUE_TYPE *, ALLOCATOR >::iterator
typedef VALUE_TYPE *const *	bsl::vector< VALUE_TYPE *, ALLOCATOR >::const_iterator
typedef std::size_t	bsl::vector< VALUE_TYPE *, ALLOCATOR >::size_type
typedef std::ptrdiff_t	bsl::vector< VALUE_TYPE *, ALLOCATOR >::difference_type
typedef ALLOCATOR	bsl::vector< VALUE_TYPE *, ALLOCATOR >::allocator_type
typedef ALLOCATOR::pointer	bsl::vector< VALUE_TYPE *, ALLOCATOR >::pointer
typedef ALLOCATOR::const_pointer	bsl::vector< VALUE_TYPE *, ALLOCATOR >::const_pointer
typedef bsl::reverse_iterator < iterator >	bsl::vector< VALUE_TYPE *, ALLOCATOR >::reverse_iterator
typedef bsl::reverse_iterator < const_iterator >	bsl::vector< VALUE_TYPE *, ALLOCATOR >::const_reverse_iterator
Functions
static void	bsl::Vector_Util::swap (void *a, void *b)
	bsl::vectorBase::vectorBase ()
void	bsl::vectorBase::adopt (BloombergLP::bslmf::MovableRef< vectorBase > base)
iterator	bsl::vectorBase::begin () BSLS_KEYWORD_NOEXCEPT
iterator	bsl::vectorBase::end () BSLS_KEYWORD_NOEXCEPT
reverse_iterator	bsl::vectorBase::rbegin () BSLS_KEYWORD_NOEXCEPT
reverse_iterator	bsl::vectorBase::rend () BSLS_KEYWORD_NOEXCEPT
reference	bsl::vectorBase::operator[] (size_type position)
reference	bsl::vectorBase::at (size_type position)
reference	bsl::vectorBase::front ()
reference	bsl::vectorBase::back ()
VALUE_TYPE *	bsl::vectorBase::data () BSLS_KEYWORD_NOEXCEPT
const_iterator	bsl::vectorBase::begin () const BSLS_KEYWORD_NOEXCEPT
const_iterator	bsl::vectorBase::cbegin () const BSLS_KEYWORD_NOEXCEPT
const_iterator	bsl::vectorBase::end () const BSLS_KEYWORD_NOEXCEPT
const_iterator	bsl::vectorBase::cend () const BSLS_KEYWORD_NOEXCEPT
const_reverse_iterator	bsl::vectorBase::rbegin () const BSLS_KEYWORD_NOEXCEPT
const_reverse_iterator	bsl::vectorBase::crbegin () const BSLS_KEYWORD_NOEXCEPT
const_reverse_iterator	bsl::vectorBase::rend () const BSLS_KEYWORD_NOEXCEPT
const_reverse_iterator	bsl::vectorBase::crend () const BSLS_KEYWORD_NOEXCEPT
size_type	bsl::vectorBase::size () const BSLS_KEYWORD_NOEXCEPT
size_type	bsl::vectorBase::capacity () const BSLS_KEYWORD_NOEXCEPT
bool	bsl::vectorBase::empty () const BSLS_KEYWORD_NOEXCEPT
const_reference	bsl::vectorBase::operator[] (size_type position) const
const_reference	bsl::vectorBase::at (size_type position) const
const_reference	bsl::vectorBase::front () const
const_reference	bsl::vectorBase::back () const
const VALUE_TYPE *	bsl::vectorBase::data () const BSLS_KEYWORD_NOEXCEPT
	bsl::vector::Proctor::Proctor (VALUE_TYPE *data, std::size_t capacity, ContainerBase *container)
	bsl::vector::Proctor::~Proctor ()
void	bsl::vector::Proctor::release ()
	bsl::vector::vector () BSLS_KEYWORD_NOEXCEPT
	bsl::vector::vector (const ALLOCATOR &basicAllocator) BSLS_KEYWORD_NOEXCEPT
	bsl::vector::vector (size_type initialSize, const ALLOCATOR &basicAllocator=ALLOCATOR())
	bsl::vector::vector (size_type initialSize, const VALUE_TYPE &value, const ALLOCATOR &basicAllocator=ALLOCATOR())
template<class INPUT_ITER >
	bsl::vector::vector (INPUT_ITER first, INPUT_ITER last, const ALLOCATOR &basicAllocator=ALLOCATOR())
	bsl::vector::vector (const vector &original)
	bsl::vector::vector (BloombergLP::bslmf::MovableRef< vector > original) BSLS_KEYWORD_NOEXCEPT
	bsl::vector::vector (const vector &original, const typename type_identity< ALLOCATOR >::type &basicAllocator)
	bsl::vector::vector (BloombergLP::bslmf::MovableRef< vector > original, const typename type_identity< ALLOCATOR >::type &basicAllocator)
	bsl::vector::vector (std::initializer_list< VALUE_TYPE > values, const ALLOCATOR &basicAllocator=ALLOCATOR())
	bsl::vector::~vector ()
vector &	bsl::vector::operator= (const vector &rhs)
vector &operator=(	bsl::vector::operator= (std::initializer_list< VALUE_TYPE > values) BloombergLP::bslmf::MovableRef< vector< VALUE_TYPE, ALLOCATOR > > rhs) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(AllocatorTraits vector &
void	bsl::vector::assign (std::initializer_list< VALUE_TYPE > values)
template<class INPUT_ITER >
void	bsl::vector::assign (INPUT_ITER first, INPUT_ITER last)
void	bsl::vector::assign (size_type numElements, const VALUE_TYPE &value)
void	bsl::vector::resize (size_type newSize)
void	bsl::vector::resize (size_type newSize, const VALUE_TYPE &value)
void	bsl::vector::reserve (size_type newCapacity)
void	bsl::vector::shrink_to_fit ()
template<class... Args>
VALUE_TYPE &	bsl::vector::emplace_back (Args &&...arguments)
void	bsl::vector::push_back (const VALUE_TYPE &value)
void	bsl::vector::push_back (BloombergLP::bslmf::MovableRef< VALUE_TYPE > value)
void	bsl::vector::pop_back ()
template<class... Args>
iterator	bsl::vector::emplace (const_iterator position, Args &&...arguments)
iterator	bsl::vector::insert (const_iterator position, const VALUE_TYPE &value)
iterator	bsl::vector::insert (const_iterator position, BloombergLP::bslmf::MovableRef< VALUE_TYPE > value)
iterator	bsl::vector::insert (const_iterator position, size_type numElements, const VALUE_TYPE &value)
template<class INPUT_ITER >
iterator	bsl::vector::insert (const_iterator position, INPUT_ITER first, INPUT_ITER last)
iterator	bsl::vector::insert (const_iterator position, std::initializer_list< VALUE_TYPE > values)
iterator	bsl::vector::erase (const_iterator position)
iterator	bsl::vector::erase (const_iterator first, const_iterator last)
allocator_type	bsl::vector::get_allocator () const BSLS_KEYWORD_NOEXCEPT
size_type	bsl::vector::max_size () const BSLS_KEYWORD_NOEXCEPT
template<class VALUE_TYPE , class ALLOCATOR >
bool	bsl::operator== (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	bsl::operator!= (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	bsl::operator< (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	bsl::operator> (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	bsl::operator<= (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	bsl::operator>= (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR , class BDE_OTHER_TYPE >
vector< VALUE_TYPE, ALLOCATOR > ::size_type	bsl::erase (vector< VALUE_TYPE, ALLOCATOR > &vec, const BDE_OTHER_TYPE &value)
template<class VALUE_TYPE , class ALLOCATOR , class PREDICATE >
vector< VALUE_TYPE, ALLOCATOR > ::size_type	bsl::erase_if (vector< VALUE_TYPE, ALLOCATOR > &vec, PREDICATE predicate)
template<class VALUE_TYPE , class ALLOCATOR >
void	bsl::swap (vector< VALUE_TYPE, ALLOCATOR > &a, vector< VALUE_TYPE, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector () BSLS_KEYWORD_NOEXCEPT
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector (const ALLOCATOR &basicAllocator) BSLS_KEYWORD_NOEXCEPT
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector (size_type initialSize, const ALLOCATOR &basicAllocator=ALLOCATOR())
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector (size_type initialSize, VALUE_TYPE *value, const ALLOCATOR &basicAllocator=ALLOCATOR())
template<class INPUT_ITER >
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector (INPUT_ITER first, INPUT_ITER last, const ALLOCATOR &basicAllocator=ALLOCATOR())
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector (const vector &original)
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector (BloombergLP::bslmf::MovableRef< vector > original) BSLS_KEYWORD_NOEXCEPT
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector (const vector &original, const typename type_identity< ALLOCATOR >::type &basicAllocator)
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector (BloombergLP::bslmf::MovableRef< vector > original, const typename type_identity< ALLOCATOR >::type &basicAllocator)
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector (std::initializer_list< VALUE_TYPE * > values, const ALLOCATOR &basicAllocator=ALLOCATOR())
	bsl::vector< VALUE_TYPE *, ALLOCATOR >::~vector ()
vector &	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator= (const vector &rhs)
vector &	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator= (BloombergLP::bslmf::MovableRef< vector< VALUE_TYPE *, ALLOCATOR > > rhs) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(d_impl
vector &	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator= (std::initializer_list< VALUE_TYPE * > values)
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::assign (std::initializer_list< VALUE_TYPE * > values)
template<class INPUT_ITER >
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::assign (INPUT_ITER first, INPUT_ITER last)
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::assign (size_type numElements, VALUE_TYPE *value)
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::begin () BSLS_KEYWORD_NOEXCEPT
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::end () BSLS_KEYWORD_NOEXCEPT
reverse_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::rbegin () BSLS_KEYWORD_NOEXCEPT
reverse_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::rend () BSLS_KEYWORD_NOEXCEPT
reference	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator[] (size_type position)
reference	bsl::vector< VALUE_TYPE *, ALLOCATOR >::at (size_type position)
reference	bsl::vector< VALUE_TYPE *, ALLOCATOR >::front ()
reference	bsl::vector< VALUE_TYPE *, ALLOCATOR >::back ()
VALUE_TYPE **	bsl::vector< VALUE_TYPE *, ALLOCATOR >::data () BSLS_KEYWORD_NOEXCEPT
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::resize (size_type newLength)
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::resize (size_type newLength, VALUE_TYPE *value)
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::reserve (size_type newCapacity)
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::shrink_to_fit ()
value_type &	bsl::vector< VALUE_TYPE *, ALLOCATOR >::emplace_back ()
value_type &	bsl::vector< VALUE_TYPE *, ALLOCATOR >::emplace_back (VALUE_TYPE *ptr)
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::push_back (VALUE_TYPE *value)
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::pop_back ()
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::emplace (const_iterator position)
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::emplace (const_iterator position, VALUE_TYPE *ptr)
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::insert (const_iterator position, VALUE_TYPE *value)
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::insert (const_iterator position, size_type numElements, VALUE_TYPE *value)
template<class INPUT_ITER >
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::insert (const_iterator position, INPUT_ITER first, INPUT_ITER last)
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::insert (const_iterator position, std::initializer_list< VALUE_TYPE * > values)
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::erase (const_iterator position)
iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::erase (const_iterator first, const_iterator last)
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::swap (vector< VALUE_TYPE *, ALLOCATOR > &other) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(d_impl.swap(other.d_impl)))
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::clear () BSLS_KEYWORD_NOEXCEPT
allocator_type	bsl::vector< VALUE_TYPE *, ALLOCATOR >::get_allocator () const BSLS_KEYWORD_NOEXCEPT
size_type	bsl::vector< VALUE_TYPE *, ALLOCATOR >::max_size () const BSLS_KEYWORD_NOEXCEPT
const_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::begin () const BSLS_KEYWORD_NOEXCEPT
const_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::cbegin () const BSLS_KEYWORD_NOEXCEPT
const_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::end () const BSLS_KEYWORD_NOEXCEPT
const_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::cend () const BSLS_KEYWORD_NOEXCEPT
const_reverse_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::rbegin () const BSLS_KEYWORD_NOEXCEPT
const_reverse_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::crbegin () const BSLS_KEYWORD_NOEXCEPT
const_reverse_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::rend () const BSLS_KEYWORD_NOEXCEPT
const_reverse_iterator	bsl::vector< VALUE_TYPE *, ALLOCATOR >::crend () const BSLS_KEYWORD_NOEXCEPT
size_type	bsl::vector< VALUE_TYPE *, ALLOCATOR >::size () const BSLS_KEYWORD_NOEXCEPT
size_type	bsl::vector< VALUE_TYPE *, ALLOCATOR >::capacity () const BSLS_KEYWORD_NOEXCEPT
bool	bsl::vector< VALUE_TYPE *, ALLOCATOR >::empty () const BSLS_KEYWORD_NOEXCEPT
const_reference	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator[] (size_type position) const
const_reference	bsl::vector< VALUE_TYPE *, ALLOCATOR >::at (size_type position) const
const_reference	bsl::vector< VALUE_TYPE *, ALLOCATOR >::front () const
const_reference	bsl::vector< VALUE_TYPE *, ALLOCATOR >::back () const
VALUE_TYPE *const *	bsl::vector< VALUE_TYPE *, ALLOCATOR >::data () const BSLS_KEYWORD_NOEXCEPT
Variables
VALUE_TYPE *	bsl::vectorBase::d_dataBegin_p
VALUE_TYPE *	bsl::vectorBase::d_dataEnd_p
std::size_t	bsl::vectorBase::d_capacity
void swap(vector &other) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(AllocatorTraits void	bsl::vector::clear () BSLS_KEYWORD_NOEXCEPT
Friends
bool	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator== (const vector &lhs, const vector &rhs)
bool	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator!= (const vector &lhs, const vector &rhs)
bool	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator< (const vector &lhs, const vector &rhs)
bool	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator> (const vector &lhs, const vector &rhs)
bool	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator<= (const vector &lhs, const vector &rhs)
bool	bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator>= (const vector &lhs, const vector &rhs)
void	bsl::vector< VALUE_TYPE *, ALLOCATOR >::swap (vector &a, vector &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.d_impl.swap(b.d_impl)))

---

Detailed Description

Outline

• Purpose
• Classes
• Description
  • Requirements on VALUE_TYPE
  • Glossary
  • Memory Allocation
    • bslma-Style Allocators
  • Operations
  • Comparing a vector of floating point values
  • Usage
    • Example 1: Creating a Matrix Type

Purpose:

Provide an STL-compliant vector class.

Classes:

bsl::vector

STL-compatible vector template

Canonical Header:

bsl_vector.h

See also:

Component bslstl_deque

Description:

This component defines a single class template, bsl::vector, implementing the standard sequential container, std::vector, holding a dynamic array of values of a template parameter type.

An instantiation of vector is an allocator-aware, value-semantic type whose salient attributes are its size (number of values) and the sequence of values the vector contains. If vector is instantiated with a value type that is not value-semantic, then the vector will not retain all of its value-semantic qualities. In particular, if a value type cannot be tested for equality, then a vector containing objects of that type cannot be tested for equality. It is even possible to instantiate vector with a value type that does not have a copy-constructor, in which case the vector will not be copyable.

A vector meets the requirements of a sequential container with random access iterators in the C++ standard [vector]. The vector implemented here adheres to the C++11 standard when compiled with a C++11 compiler, and makes the best approximation when compiled with a C++03 compiler. In particular, for C++03 we emulate move semantics, but limit forwarding (in emplace) to const lvalues, and make no effort to emulate noexcept or initializer lists.

Requirements on VALUE_TYPE:

A vector is a fully Value-Semantic Type (see bsldoc_glossary) only if the supplied VALUE_TYPE template parameter is fully value-semantic. It is possible to instantiate a vector with a VALUE_TYPE parameter that does not have a full set of value-semantic operations, but then some methods of the container may not be instantiable. The following terminology, adopted from the C++11 standard, is used in the function documentation of vector to describe a function's requirements for the VALUE_TYPE template parameter. These terms are also defined in section [17.6.3.1] of the C++11 standard. Note that, in the context of a vector instantiation, the requirements apply specifically to the vector's entry type, value_type, which is an alias for VALUE_TYPE.

Glossary:

  Legend
  ------
  'X'    - denotes an allocator-aware container type (e.g., 'vector')
  'T'    - 'value_type' associated with 'X'
  'A'    - type of the allocator used by 'X'
  'm'    - lvalue of type 'A' (allocator)
  'p'    - address ('T *') of uninitialized storage for a 'T' within an 'X'
  'rv'   - rvalue of type (non-'const') 'T'
  'v'    - rvalue or lvalue of type (possibly 'const') 'T'
  'args' - 0 or more arguments

The following terms are used to more precisely specify the requirements on template parameter types in function-level documentation.

default-insertable: T has a default constructor. More precisely, T is default-insertable into X means that the following expression is well-formed: allocator_traits<A>construct(m, p)

move-insertable: T provides a constructor that takes an rvalue of type (non-'const') T. More precisely, T is move-insertable into X means that the following expression is well-formed: allocator_traits<A>construct(m, p, rv)

copy-insertable: T provides a constructor that takes an lvalue or rvalue of type (possibly const) T. More precisely, T is copy-insertable into X means that the following expression is well-formed: allocator_traits<A>construct(m, p, v)

move-assignable: T provides an assignment operator that takes an rvalue of type (non-'const') T.

copy-assignable: T provides an assignment operator that takes an lvalue or rvalue of type (possibly const) T.

emplace-constructible: T is emplace-constructible into X from args means that the following expression is well-formed: allocator_traits<A>construct(m, p, args)

erasable: T provides a destructor. More precisely, T is erasable from X means that the following expression is well-formed: allocator_traits<A>destroy(m, p)

equality-comparable: The type provides an equality-comparison operator that defines an equivalence relationship and is both reflexive and transitive.

Memory Allocation:

The type supplied as a vector's ALLOCATOR template parameter determines how that vector will allocate memory. The vector template supports allocators meeting the requirements of the C++03 standard; in addition, it supports scoped-allocators derived from the bslma::Allocator memory allocation protocol. Clients intending to use bslma-style allocators should use the template's default ALLOCATOR type: The default type for the ALLOCATOR template parameter, bsl::allocator, provides a C++11 standard-compatible adapter for a bslma::Allocator object.

bslma-Style Allocators:

If the (template parameter) type ALLOCATOR of a vector instantiation' is bsl::allocator, then objects of that vector type will conform to the standard behavior of a bslma-allocator-enabled type. Such a vector accepts an optional bslma::Allocator argument at construction. If the address of a bslma::Allocator object is explicitly supplied at construction, it is used to supply memory for the vector throughout its lifetime; otherwise, the vector will use the default allocator installed at the time of the vector's construction (see bslma_default). In addition to directly allocating memory from the indicated bslma::Allocator, a vector supplies that allocator's address to the constructors of contained objects of the (template parameter) type VALUE_TYPE, if it defines the bslma::UsesBslmaAllocator trait.

Operations:

This section describes the run-time complexity of operations on instances of vector:

  Legend
  ------
  'V'             - (template parameter) 'VALUE_TYPE' of the vector
  'a', 'b'        - two distinct objects of type 'vector<V>'
  'rv'            - modifiable rvalue of type 'vector<V>'
  'n', 'm'        - number of elements in 'a' and 'b', respectively
  'k'             - non-negative integer
  'al'            - an STL-style memory allocator
  'i1', 'i2'      - two iterators defining a sequence of 'V' objects
  'il'            - object of type 'std::initializer_list<V>'
  'lil'           - length of 'il'
  'vt'            - object of type 'VALUE_TYPE'
  'rvt'           - modifiable rvalue of type 'VALUE_TYPE'
  'p1', 'p2'      - two 'const' iterators belonging to 'a'
  distance(i1,i2) - the number of elements in the range [i1, i2)

  |-----------------------------------------+-------------------------------|
  | Operation                               | Complexity                    |
  |=========================================+===============================|
  | vector<V> a      (default construction) | O[1]                          |
  | vector<V> a(al)                         |                               |
  |-----------------------------------------+-------------------------------|
  | vector<V> a(b)   (copy construction)    | O[n]                          |
  | vector<V> a(b, al)                      |                               |
  |-----------------------------------------+-------------------------------|
  | vector<V> a(rv)  (move construction)    | O[1] if 'a' and 'rv' use the  |
  | vector<V> a(rv, al)                     | same allocator; O[n] otherwise|
  |-----------------------------------------+-------------------------------|
  | vector<V> a(k)                          | O[k]                          |
  | vector<V> a(k, al)                      |                               |
  | vector<V> a(k, vt)                      |                               |
  | vector<V> a(k, vt, al)                  |                               |
  |-----------------------------------------+-------------------------------|
  | vector<V> a(i1, i2)                     | O[distance(i1, i2)]           |
  | vector<V> a(i1, i2, al)                 |                               |
  |-----------------------------------------+-------------------------------|
  | vector<V> a(il)                         | O[lil]                        |
  | vector<V> a(il, al)                     |                               |
  |-----------------------------------------+-------------------------------|
  | a.~vector<V>()  (destruction)           | O[n]                          |
  |-----------------------------------------+-------------------------------|
  | a.assign(k, vt)                         | O[k]                          |
  | a.assign(k, rvt)                        |                               |
  |-----------------------------------------+-------------------------------|
  | a.assign(i1, i2)                        | O[distance(i1, i2)]           |
  |-----------------------------------------+-------------------------------|
  | a.assign(il)                            | O[lil]                        |
  |-----------------------------------------+-------------------------------|
  | get_allocator()                         | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.begin(), a.end(),                     | O[1]                          |
  | a.cbegin(), a.cend(),                   |                               |
  | a.rbegin(), a.rend(),                   |                               |
  | a.crbegin(), a.crend()                  |                               |
  |-----------------------------------------+-------------------------------|
  | a.size()                                | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.max_size()                            | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.resize(k)                             | O[k]                          |
  | a.resize(k, vt)                         |                               |
  |-----------------------------------------+-------------------------------|
  | a.empty()                               | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.reserve(k)                            | O[k]                          |
  |-----------------------------------------+-------------------------------|
  | a.shrink_to_fit()                       | O[n]                          |
  |-----------------------------------------+-------------------------------|
  | a[k]                                    | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.at(k)                                 | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.front()                               | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.back()                                | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.push_back(vt)                         | O[1]                          |
  | a.push_back(rvt)                        |                               |
  |-----------------------------------------+-------------------------------|
  | a.pop_back()                            | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.emplace_back(args)                    | O[1]                          |
  |-----------------------------------------+-------------------------------|
  | a.emplace(p1, args)                     | O[1 + distance(p1, a.end())]  |
  |-----------------------------------------+-------------------------------|
  | a.insert(p1, vt)                        | O[1 + distance(p1, a.end())]  |
  | a.insert(p1, rvt)                       |                               |
  |-----------------------------------------+-------------------------------|
  | a.insert(p1, k, vt)                     | O[k + distance(p1, a.end())]  |
  | a.insert(p1, k, rvt)                    |                               |
  |-----------------------------------------+-------------------------------|
  | a.insert(p1, i1, i2)                    | O[distance(i1, i2)            |
  |                                         |      + distance(p1, a.end())] |
  |-----------------------------------------+-------------------------------|
  | a.insert(p1, il)                        | O[lil                         |
  |                                         |      + distance(p1, a.end())] |
  |-----------------------------------------+-------------------------------|
  | a.erase(p1)                             | O[1 + distance(p1, a.end())]  |
  |-----------------------------------------+-------------------------------|
  | a.erase(p1, p2)                         | O[distance(p1, p2)            |
  |                                         |      + distance(p1, a.end())] |
  |-----------------------------------------+-------------------------------|
  | a.swap(b), swap(a, b)                   | O[1] if 'a' and 'b' use the   |
  |                                         | same allocator; O[n + m]      |
  |                                         | otherwise                     |
  |-----------------------------------------+-------------------------------|
  | a.clear()                               | O[n]                          |
  |-----------------------------------------+-------------------------------|
  | a = b;           (copy assignment)      | O[n]                          |
  |-----------------------------------------+-------------------------------|
  | a = rv;          (move assignment)      | O[1] if 'a' and 'rv' use the  |
  |                                         | same allocator; O[n] otherwise|
  |-----------------------------------------+-------------------------------|
  | a = il;                                 | O[lil]                        |
  |-----------------------------------------+-------------------------------|
  | a == b, a != b                          | O[n]                          |
  |-----------------------------------------+-------------------------------|
  | a < b, a <= b, a > b, a >= b            | O[n]                          |
  |-----------------------------------------+-------------------------------|

Comparing a vector of floating point values:

The comparison operator performs a bit-wise comparison for floating point types (float and double), which produces results for NaN, +0, and -0 values that do not meet the guarantees provided by the standard. The bslmf::IsBitwiseEqualityComparable trait for double and float types returns true which is incorrect because a comparison with a NaN value is always false, and -0 and +0 are equal.

    bsl::vector<double> v;
    v.push_back(bsl::numeric_limits<double>::quiet_NaN());
    ASSERT(v == v);   // This assertion will *NOT* fail!

Addressing this issue, i.e., updating bslmf::IsBitwiseEqualityComparable to return false for floating point types, could potentially destabilize production software so the change (for the moment) has not been made.

Usage:

In this section we show intended use of this component.

Example 1: Creating a Matrix Type:

Suppose we want to define a value-semantic type representing a dynamically resizable two-dimensional matrix.

First, we define the public interface for the MyMatrix class template:

  template <class TYPE>
  class MyMatrix {
      // This value-semantic type characterizes a two-dimensional matrix of
      // objects of the (template parameter) 'TYPE'.  The numbers of columns
      // and rows of the matrix can be specified at construction and, at any
      // time, via the 'reset', 'insertRow', and 'insertColumn' methods.  The
      // value of each element in the matrix can be set and accessed using
      // the 'theValue', and 'theModifiableValue' methods respectively.

    public:
      // PUBLIC TYPES

Here, we create a type alias, RowType, for an instantiation of bsl::vector to represent a row of TYPE objects in the matrix. We create another type alias, MatrixType, for an instantiation of bsl::vector to represent the entire matrix of TYPE objects as a list of rows:

      typedef bsl::vector<TYPE>    RowType;
          // This is an alias representing a row of values of the (template
          // parameter) 'TYPE'.

      typedef bsl::vector<RowType> MatrixType;
          // This is an alias representing a two-dimensional matrix of values
          // of the (template parameter) 'TYPE'.

    private:
      // DATA
      MatrixType d_matrix;      // matrix of values
      int        d_numColumns;  // number of columns

      // FRIENDS
      template <class T>
      friend bool operator==(const MyMatrix<T>&, const MyMatrix<T>&);

    public:
      // PUBLIC TYPES
      typedef typename MatrixType::const_iterator ConstRowIterator;

      // CREATORS
      MyMatrix(int               numRows,
               int               numColumns,
               bslma::Allocator *basicAllocator = 0);
          // Create a 'MyMatrix' object having the specified 'numRows' and
          // the specified 'numColumns'.  All elements of the (template
          // parameter) 'TYPE' in the matrix will have the
          // default-constructed value.  Optionally specify a
          // 'basicAllocator' used to supply memory.  If 'basicAllocator' is
          // 0, the currently installed default allocator is used.  The
          // behavior is undefined unless '0 <= numRows' and
          // '0 <= numColumns'

      MyMatrix(const MyMatrix&   original,
               bslma::Allocator *basicAllocator = 0);
          // Create a 'MyMatrix' object having the same value as the
          // specified 'original' object.  Optionally specify a
          // 'basicAllocator' used to supply memory.  If 'basicAllocator' is
          // 0, the currently installed default allocator is used.

          // Destroy this object.

      // MANIPULATORS
      MyMatrix& operator=(const MyMatrix& rhs);
          // Assign to this object the value of the specified 'rhs' object,
          // and return a reference providing modifiable access to this
          // object.

      void clear();
          // Remove all rows and columns from this object.

      void insertColumn(int columnIndex);
          // Insert, into this matrix, an column at the specified
          // 'columnIndex'.  All elements of the (template parameter) 'TYPE'
          // in the column will have the default-constructed value.  The
          // behavior is undefined unless '0 <= columnIndex <= numColumns()'.

      void insertRow(int rowIndex);
          // Insert, into this matrix, a row at the specified 'rowIndex'.
          // All elements of the (template parameter) 'TYPE' in the row will
          // have the default-constructed value.  The behavior is undefined
          // unless '0 <= rowIndex <= numRows()'.

      TYPE& theModifiableValue(int rowIndex, int columnIndex);
          // Return a reference providing modifiable access to the element at
          // the specified 'rowIndex' and the specified 'columnIndex' in this
          // matrix.  The behavior is undefined unless
          // '0 <= rowIndex < numRows()' and
          // '0 <= columnIndex < numColumns()'.

      // ACCESSORS
      int numRows() const;
          // Return the number of rows in this matrix.

      int numColumns() const;
          // Return the number of columns in this matrix.

      ConstRowIterator beginRow() const;
          // Return an iterator providing non-modifiable access to the
          // 'RowType' objects representing the first row in this matrix.

      ConstRowIterator endRow() const;
          // Return an iterator providing non-modifiable access to the
          // 'RowType' objects representing the past-the-end row in this
          // matrix.

      const TYPE& theValue(int rowIndex, int columnIndex) const;
          // Return a reference providing non-modifiable access to the
          // element at the specified 'rowIndex' and the specified
          // 'columnIndex' in this matrix.  The behavior is undefined unless
          // '0 <= rowIndex < numRows()' and
          // '0 <= columnIndex < numColumns()'.
  };

Then we declare the free operator for MyMatrix:

  // FREE OPERATORS
  template <class TYPE>
  MyMatrix<TYPE> operator==(const MyMatrix<TYPE>& lhs,
                            const MyMatrix<TYPE>& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' objects have the same
      // value, and 'false' otherwise.  Two 'MyMatrix' objects have the same
      // value if they have the same number of rows and columns and every
      // element in both matrices compare equal.

  template <class TYPE>
  MyMatrix<TYPE> operator!=(const MyMatrix<TYPE>& lhs,
                            const MyMatrix<TYPE>& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' objects do not have
      // the same value, and 'false' otherwise.  Two 'MyMatrix' objects do
      // not have the same value if they do not have the same number of rows
      // and columns or every element in both matrices do not compare equal.

  template <class TYPE>
  MyMatrix<TYPE> operator*(const MyMatrix<TYPE>& lhs,
                           const MyMatrix<TYPE>& rhs);
      // Return a 'MyMatrix' objects that is the product of the specified
      // 'lhs' and 'rhs'.  The behavior is undefined unless
      // 'lhs.numColumns() == rhs.numRows()'.

Now, we define the methods of MyMatrix:

  // CREATORS
  template <class TYPE>
  MyMatrix<TYPE>::MyMatrix(int numRows,
                           int numColumns,
                           bslma::Allocator *basicAllocator)
  : d_matrix(numRows, basicAllocator)
  , d_numColumns(numColumns)
  {
      BSLS_ASSERT(0 <= numRows);
      BSLS_ASSERT(0 <= numColumns);

      for (typename MatrixType::iterator itr = d_matrix.begin();
           itr != d_matrix.end();
           ++itr) {
          itr->resize(d_numColumns);
      }
  }
  template <class TYPE>
  MyMatrix<TYPE>::MyMatrix(const MyMatrix& original,
                           bslma::Allocator *basicAllocator)
  : d_matrix(original.d_matrix, basicAllocator)
  , d_numColumns(original.d_numColumns)
  {
  }

Notice that we pass the contained bsl::vector (d_matrix) the allocator specified at construction to supply memory. If the (template parameter) TYPE of the elements has the bslalg_TypeTraitUsesBslmaAllocator trait, this allocator will be passed by the vector to the elements as well.

  // MANIPULATORS
  template <class TYPE>
  MyMatrix<TYPE>& MyMatrix<TYPE>::operator=(const MyMatrix& rhs)
  {
      d_matrix = rhs.d_matrix;
      d_numColumns = rhs.d_numColumns;
  }

  template <class TYPE>
  void MyMatrix<TYPE>::clear()
  {
      d_matrix.clear();
      d_numColumns = 0;
  }

  template <class TYPE>
  void MyMatrix<TYPE>::insertColumn(int colIndex) {
      for (typename MatrixType::iterator itr = d_matrix.begin();
           itr != d_matrix.end();
           ++itr) {
          itr->insert(itr->begin() + colIndex, TYPE());
      }
      ++d_numColumns;
  }

  template <class TYPE>
  void MyMatrix<TYPE>::insertRow(int rowIndex)
  {
      typename MatrixType::iterator itr =
          d_matrix.insert(d_matrix.begin() + rowIndex, RowType());
      itr->resize(d_numColumns);
  }

  template <class TYPE>
  TYPE& MyMatrix<TYPE>::theModifiableValue(int rowIndex, int columnIndex)
  {
      BSLS_ASSERT(0 <= rowIndex);
      BSLS_ASSERT(rowIndex < d_matrix.size());
      BSLS_ASSERT(0 <= columnIndex);
      BSLS_ASSERT(columnIndex < d_numColumns);

      return d_matrix[rowIndex][columnIndex];
  }

  // ACCESSORS
  template <class TYPE>
  int MyMatrix<TYPE>::numRows() const
  {
      return d_matrix.size();
  }

  template <class TYPE>
  int MyMatrix<TYPE>::numColumns() const
  {
      return d_numColumns;
  }

  template <class TYPE>
  typename MyMatrix<TYPE>::ConstRowIterator MyMatrix<TYPE>::beginRow() const
  {
      return d_matrix.begin();
  }

  template <class TYPE>
  typename MyMatrix<TYPE>::ConstRowIterator MyMatrix<TYPE>::endRow() const
  {
      return d_matrix.end();
  }

  template <class TYPE>
  const TYPE& MyMatrix<TYPE>::theValue(int rowIndex, int columnIndex) const
  {
      BSLS_ASSERT(0 <= rowIndex);
      BSLS_ASSERT(rowIndex < d_matrix.size());
      BSLS_ASSERT(0 <= columnIndex);
      BSLS_ASSERT(columnIndex < d_numColumns);

      return d_matrix[rowIndex][columnIndex];
  }

Finally, we defines the free operators for MyMatrix:

  // FREE OPERATORS
  template <class TYPE>
  MyMatrix<TYPE> operator==(const MyMatrix<TYPE>& lhs,
                            const MyMatrix<TYPE>& rhs)
  {
      return lhs.d_numColumns == rhs.d_numColumns &&
                                                lhs.d_matrix == rhs.d_matrix;
  }

  template <class TYPE>
  MyMatrix<TYPE> operator!=(const MyMatrix<TYPE>& lhs,
                            const MyMatrix<TYPE>& rhs)
  {
      return !(lhs == rhs);
  }

---

Typedef Documentation

template<class VALUE_TYPE>

typedef VALUE_TYPE bsl::vectorBase< VALUE_TYPE >::value_type [inherited]

Reimplemented in bsl::vector< VALUE_TYPE, ALLOCATOR >.

template<class VALUE_TYPE>

typedef VALUE_TYPE& bsl::vectorBase< VALUE_TYPE >::reference [inherited]

Reimplemented in bsl::vector< VALUE_TYPE, ALLOCATOR >.

template<class VALUE_TYPE>

typedef VALUE_TYPE const& bsl::vectorBase< VALUE_TYPE >::const_reference [inherited]

Reimplemented in bsl::vector< VALUE_TYPE, ALLOCATOR >.

template<class VALUE_TYPE>

typedef VALUE_TYPE* bsl::vectorBase< VALUE_TYPE >::iterator [inherited]

Reimplemented in bsl::vector< VALUE_TYPE, ALLOCATOR >.

template<class VALUE_TYPE>

typedef VALUE_TYPE const* bsl::vectorBase< VALUE_TYPE >::const_iterator [inherited]

Reimplemented in bsl::vector< VALUE_TYPE, ALLOCATOR >.

template<class VALUE_TYPE>

typedef std::size_t bsl::vectorBase< VALUE_TYPE >::size_type [inherited]

Reimplemented in bsl::vector< VALUE_TYPE, ALLOCATOR >.

template<class VALUE_TYPE>

typedef std::ptrdiff_t bsl::vectorBase< VALUE_TYPE >::difference_type [inherited]

Reimplemented in bsl::vector< VALUE_TYPE, ALLOCATOR >.

template<class VALUE_TYPE>

typedef bsl::reverse_iterator<iterator> bsl::vectorBase< VALUE_TYPE >::reverse_iterator [inherited]

Reimplemented in bsl::vector< VALUE_TYPE, ALLOCATOR >.

template<class VALUE_TYPE>

typedef bsl::reverse_iterator<const_iterator> bsl::vectorBase< VALUE_TYPE >::const_reverse_iterator [inherited]

Reimplemented in bsl::vector< VALUE_TYPE, ALLOCATOR >.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef VALUE_TYPE bsl::vector< VALUE_TYPE, ALLOCATOR >::value_type [inherited]

Reimplemented from bsl::vectorBase< VALUE_TYPE >.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef ALLOCATOR bsl::vector< VALUE_TYPE, ALLOCATOR >::allocator_type [inherited]

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef VALUE_TYPE& bsl::vector< VALUE_TYPE, ALLOCATOR >::reference [inherited]

Reimplemented from bsl::vectorBase< VALUE_TYPE >.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef const VALUE_TYPE& bsl::vector< VALUE_TYPE, ALLOCATOR >::const_reference [inherited]

Reimplemented from bsl::vectorBase< VALUE_TYPE >.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef AllocatorTraits::size_type bsl::vector< VALUE_TYPE, ALLOCATOR >::size_type [inherited]

Reimplemented from bsl::vectorBase< VALUE_TYPE >.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef AllocatorTraits::difference_type bsl::vector< VALUE_TYPE, ALLOCATOR >::difference_type [inherited]

Reimplemented from bsl::vectorBase< VALUE_TYPE >.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef AllocatorTraits::pointer bsl::vector< VALUE_TYPE, ALLOCATOR >::pointer [inherited]

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef AllocatorTraits::const_pointer bsl::vector< VALUE_TYPE, ALLOCATOR >::const_pointer [inherited]

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef VALUE_TYPE* bsl::vector< VALUE_TYPE, ALLOCATOR >::iterator [inherited]

Reimplemented from bsl::vectorBase< VALUE_TYPE >.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef VALUE_TYPE const* bsl::vector< VALUE_TYPE, ALLOCATOR >::const_iterator [inherited]

Reimplemented from bsl::vectorBase< VALUE_TYPE >.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef bsl::reverse_iterator<iterator> bsl::vector< VALUE_TYPE, ALLOCATOR >::reverse_iterator [inherited]

Reimplemented from bsl::vectorBase< VALUE_TYPE >.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

typedef bsl::reverse_iterator<const_iterator> bsl::vector< VALUE_TYPE, ALLOCATOR >::const_reverse_iterator [inherited]

Reimplemented from bsl::vectorBase< VALUE_TYPE >.

template<class VALUE_TYPE , class ALLOCATOR >

typedef VALUE_TYPE* bsl::vector< VALUE_TYPE *, ALLOCATOR >::value_type [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef value_type& bsl::vector< VALUE_TYPE *, ALLOCATOR >::reference [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef const value_type& bsl::vector< VALUE_TYPE *, ALLOCATOR >::const_reference [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef VALUE_TYPE** bsl::vector< VALUE_TYPE *, ALLOCATOR >::iterator [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef VALUE_TYPE* const* bsl::vector< VALUE_TYPE *, ALLOCATOR >::const_iterator [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef std::size_t bsl::vector< VALUE_TYPE *, ALLOCATOR >::size_type [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef std::ptrdiff_t bsl::vector< VALUE_TYPE *, ALLOCATOR >::difference_type [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef ALLOCATOR bsl::vector< VALUE_TYPE *, ALLOCATOR >::allocator_type [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef ALLOCATOR::pointer bsl::vector< VALUE_TYPE *, ALLOCATOR >::pointer [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef ALLOCATOR::const_pointer bsl::vector< VALUE_TYPE *, ALLOCATOR >::const_pointer [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef bsl::reverse_iterator<iterator> bsl::vector< VALUE_TYPE *, ALLOCATOR >::reverse_iterator [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

typedef bsl::reverse_iterator<const_iterator> bsl::vector< VALUE_TYPE *, ALLOCATOR >::const_reverse_iterator [inherited]

---

Function Documentation

static void bsl::Vector_Util::swap	(	void *	a,
		void *	b
	)			[static, inherited]

Exchange the value of the specified a vector with that of the specified b vector.

template<class VALUE_TYPE>

bsl::vectorBase< VALUE_TYPE >::vectorBase

(

)

[inherited]

Create an empty base object with no capacity.

template<class VALUE_TYPE>

void bsl::vectorBase< VALUE_TYPE >::adopt

(

BloombergLP::bslmf::MovableRef< vectorBase< VALUE_TYPE > >

base

)

[inherited]

Adopt all outstanding memory allocations associated with the specified base object. The behavior is undefined unless this object is in a default-constructed state.

template<class VALUE_TYPE>

iterator bsl::vectorBase< VALUE_TYPE >::begin

(

)

[inherited]

Return an iterator providing modifiable access to the first element in this vector, or the past-the-end iterator if this vector is empty.

Referenced by bsl::vector< ThreadUtil::Handle >::emplace(), and bsl::vector< ThreadUtil::Handle >::insert().

template<class VALUE_TYPE>

iterator bsl::vectorBase< VALUE_TYPE >::end

(

)

[inherited]

Return the past-the-end iterator providing modifiable access to this vector.

Referenced by bsl::vector< ThreadUtil::Handle >::emplace(), and bsl::vector< ThreadUtil::Handle >::insert().

template<class VALUE_TYPE>

reverse_iterator bsl::vectorBase< VALUE_TYPE >::rbegin

(

)

[inherited]

Return a reverse iterator providing modifiable access to the last element in this vector, and the past-the-end reverse iterator if this vector is empty.

template<class VALUE_TYPE>

reverse_iterator bsl::vectorBase< VALUE_TYPE >::rend

(

)

[inherited]

Return the past-the-end reverse iterator providing modifiable access to this vector.

template<class VALUE_TYPE>

reference bsl::vectorBase< VALUE_TYPE >::operator[]

(

size_type

position

)

[inherited]

Return a reference providing modifiable access to the element at the specified position in this vector. The behavior is undefined unless position < size().

template<class VALUE_TYPE>

reference bsl::vectorBase< VALUE_TYPE >::at

(

size_type

position

)

[inherited]

Return a reference providing modifiable access to the element at the specified position in this vector. Throw a std::out_of_range exception if position >= size().

template<class VALUE_TYPE>

reference bsl::vectorBase< VALUE_TYPE >::front

(

)

[inherited]

Return a reference providing modifiable access to the first element in this vector. The behavior is undefined unless this vector is not empty.

template<class VALUE_TYPE>

reference bsl::vectorBase< VALUE_TYPE >::back

(

)

[inherited]

Return a reference providing modifiable access to the last element in this vector. The behavior is undefined unless this vector is not empty.

template<class VALUE_TYPE>

VALUE_TYPE* bsl::vectorBase< VALUE_TYPE >::data

(

)

[inherited]

Return the address of the modifiable first element in this vector, or a valid, but non-dereferenceable pointer value if this vector is empty.

template<class VALUE_TYPE>

const_iterator bsl::vectorBase< VALUE_TYPE >::begin

(

)

const [inherited]

template<class VALUE_TYPE>

const_iterator bsl::vectorBase< VALUE_TYPE >::cbegin

(

)

const [inherited]

Return an iterator providing non-modifiable access to the first element in this vector, and the past-the-end iterator if this vector is empty.

template<class VALUE_TYPE>

const_iterator bsl::vectorBase< VALUE_TYPE >::end

(

)

const [inherited]

template<class VALUE_TYPE>

const_iterator bsl::vectorBase< VALUE_TYPE >::cend

(

)

const [inherited]

Return the past-the-end (forward) iterator providing non-modifiable access to this vector.

template<class VALUE_TYPE>

const_reverse_iterator bsl::vectorBase< VALUE_TYPE >::rbegin

(

)

const [inherited]

template<class VALUE_TYPE>

const_reverse_iterator bsl::vectorBase< VALUE_TYPE >::crbegin

(

)

const [inherited]

Return a reverse iterator providing non-modifiable access to the last element in this vector, and the past-the-end reverse iterator if this vector is empty.

template<class VALUE_TYPE>

const_reverse_iterator bsl::vectorBase< VALUE_TYPE >::rend

(

)

const [inherited]

template<class VALUE_TYPE>

const_reverse_iterator bsl::vectorBase< VALUE_TYPE >::crend

(

)

const [inherited]

Return the past-the-end reverse iterator providing non-modifiable access to this vector.

template<class VALUE_TYPE>

size_type bsl::vectorBase< VALUE_TYPE >::size

(

)

const [inherited]

Return the number of elements in this vector.

Referenced by bsl::vector< ThreadUtil::Handle >::emplace().

template<class VALUE_TYPE>

size_type bsl::vectorBase< VALUE_TYPE >::capacity

(

)

const [inherited]

Return the capacity of this vector, i.e., the maximum number of elements for which resizing is guaranteed not to trigger a reallocation.

template<class VALUE_TYPE>

bool bsl::vectorBase< VALUE_TYPE >::empty

(

)

const [inherited]

Return true if this vector has size 0, and false otherwise.

template<class VALUE_TYPE>

const_reference bsl::vectorBase< VALUE_TYPE >::operator[]

(

size_type

position

)

const [inherited]

Return a reference providing non-modifiable access to the element at the specified position in this vector. The behavior is undefined unless position < size().

template<class VALUE_TYPE>

const_reference bsl::vectorBase< VALUE_TYPE >::at

(

size_type

position

)

const [inherited]

Return a reference providing non-modifiable access to the element at the specified position in this vector. Throw a bsl::out_of_range exception if position >= size().

template<class VALUE_TYPE>

const_reference bsl::vectorBase< VALUE_TYPE >::front

(

)

const [inherited]

Return a reference providing non-modifiable access to the first element in this vector. The behavior is undefined unless this vector is not empty.

template<class VALUE_TYPE>

const_reference bsl::vectorBase< VALUE_TYPE >::back

(

)

const [inherited]

Return a reference providing non-modifiable access to the last element in this vector. The behavior is undefined unless this vector is not empty.

template<class VALUE_TYPE>

const VALUE_TYPE* bsl::vectorBase< VALUE_TYPE >::data

(

)

const [inherited]

Return the address of the non-modifiable first element in this vector, or a valid, but non-dereferenceable pointer value if this vector is empty.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::Proctor::Proctor	(	VALUE_TYPE *	data,
		std::size_t	capacity,
		ContainerBase *	container
	)			[inherited]

Create a proctor for the specified data array of the specified capacity, using the deallocateN method of the specified container to return data to its allocator upon destruction, unless this proctor's release is called prior.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::Proctor::~Proctor

(

)

[inherited]

Destroy this proctor, deallocating any data under management.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::Proctor::release

(

)

[inherited]

Release the data from management by this proctor.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector

(

)

[inherited]

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector

(

const ALLOCATOR &

basicAllocator

)

[explicit, inherited]

Create an empty vector. Optionally specify a basicAllocator used to supply memory. If basicAllocator is not specified, a default-constructed object of the (template parameter) type ALLOCATOR is used. If the type ALLOCATOR is bsl::allocator and basicAllocator is not supplied, the currently installed default allocator is used. Note that a bslma::Allocator * can be supplied for basicAllocator if the type ALLOCATOR is bsl::allocator (the default).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector	(	size_type	initialSize,
		const ALLOCATOR &	basicAllocator = ALLOCATOR()
	)			[explicit, inherited]

Create a vector of the specified initialSize whose every element is a default-constructed object of the (template parameter) type VALUE_TYPE. Optionally specify a basicAllocator used to supply memory. If basicAllocator is not specified, a default-constructed object of the (template parameter) type ALLOCATOR is used. If the type ALLOCATOR is bsl::allocator and basicAllocator is not supplied, the currently installed default allocator is used. Throw std::length_error if initialSize > max_size(). This method requires that the type VALUE_TYPE be default-insertable into this vector (see Requirements on VALUE_TYPE). Note that a bslma::Allocator * can be supplied for basicAllocator if the type ALLOCATOR is bsl::allocator (the default).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector	(	size_type	initialSize,
		const VALUE_TYPE &	value,
		const ALLOCATOR &	basicAllocator = ALLOCATOR()
	)			[inherited]

Create a vector of the specified initialSize whose every element is a copy of the specified value. Optionally specify a basicAllocator used to supply memory. If basicAllocator is not specified, a default-constructed object of the (template parameter) type ALLOCATOR is used. If the type ALLOCATOR is bsl::allocator and basicAllocator is not supplied, the currently installed default allocator is used. Throw std::length_error if initialSize > max_size(). This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE). Note that a bslma::Allocator * can be supplied for basicAllocator if the type ALLOCATOR is bsl::allocator (the default).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

template<class INPUT_ITER >

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector	(	INPUT_ITER	first,
		INPUT_ITER	last,
		const ALLOCATOR &	basicAllocator = ALLOCATOR()
	)			[inherited]

Create a vector, and insert (in order) each VALUE_TYPE object in the range starting at the specified first element, and ending immediately before the specified last element. Optionally specify a basicAllocator used to supply memory. If basicAllocator is not specified, a default-constructed object of the (template parameter) type ALLOCATOR is used. If the type ALLOCATOR is bsl::allocator and basicAllocator is not supplied, the currently installed default allocator is used. Throw std::length_error if the number of elements in [first .. last) exceeds the value returned by the method max_size. The (template parameter) type INPUT_ITER shall meet the requirements of an input iterator defined in the C++11 standard [24.2.3] providing access to values of a type convertible to value_type, and value_type must be emplace-constructible from *i into this vector, where i is a dereferenceable iterator in the range [first .. last) (see Requirements on VALUE_TYPE). The behavior is undefined unless first and last refer to a range of valid values where first is at a position at or before last. Note that a bslma::Allocator * can be supplied for basicAllocator if the type ALLOCATOR is bsl::allocator (the default).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector

(

const vector< VALUE_TYPE, ALLOCATOR > &

original

)

[inherited]

Create a vector having the same value as the specified original object. Use the allocator returned by 'bslallocator_traits<ALLOCATOR>:: select_on_container_copy_construction(original.get_allocator())' to allocate memory. This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector

(

BloombergLP::bslmf::MovableRef< vector< VALUE_TYPE, ALLOCATOR > >

original

)

[inherited]

IMPLICIT: Create a vector having the same value as the specified original object by moving (in constant time) the contents of original to the new vector. The allocator associated with original is propagated for use in the newly-created vector. original is left in a valid but unspecified state.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector	(	const vector< VALUE_TYPE, ALLOCATOR > &	original,
		const typename type_identity< ALLOCATOR >::type &	basicAllocator
	)			[inherited]

Create a vector having the same value as the specified original object that uses the specified basicAllocator to supply memory. This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE). Note that a bslma::Allocator * can be supplied for basicAllocator if the (template parameter) type ALLOCATOR is bsl::allocator (the default).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector	(	BloombergLP::bslmf::MovableRef< vector< VALUE_TYPE, ALLOCATOR > >	original,
		const typename type_identity< ALLOCATOR >::type &	basicAllocator
	)			[inherited]

Create a vector having the same value as the specified original object that uses the specified basicAllocator to supply memory. The contents of original are moved (in constant time) to the new vector if basicAllocator == original.get_allocator(), and are move-inserted (in linear time) using basicAllocator otherwise. original is left in a valid but unspecified state. This method requires that the (template parameter) type VALUE_TYPE be move-insertable into this vector (see Requirements on VALUE_TYPE). Note that a bslma::Allocator * can be supplied for basicAllocator if the (template parameter) type ALLOCATOR is bsl::allocator (the default).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::vector	(	std::initializer_list< VALUE_TYPE >	values,
		const ALLOCATOR &	basicAllocator = ALLOCATOR()
	)			[inherited]

IMPLICIT: Create a vector and insert (in order) each VALUE_TYPE object in the specified values initializer list. Optionally specify a basicAllocator used to supply memory. If basicAllocator is not specified, a default-constructed object of the (template parameter) type ALLOCATOR is used. If the type ALLOCATOR is bsl::allocator and basicAllocator is not supplied, the currently installed default allocator is used. This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE). Note that a bslma::Allocator * can be supplied for basicAllocator if the type ALLOCATOR is bsl::allocator (the default).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

bsl::vector< VALUE_TYPE, ALLOCATOR >::~vector

(

)

[inherited]

Destroy this vector.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

vector& bsl::vector< VALUE_TYPE, ALLOCATOR >::operator=

(

const vector< VALUE_TYPE, ALLOCATOR > &

rhs

)

[inherited]

Assign to this object the value of the specified rhs object, propagate to this object the allocator of rhs if the ALLOCATOR type has trait propagate_on_container_copy_assignment, and return a reference providing modifiable access to this object. If an exception is thrown, *this is left in a valid but unspecified state. This method requires that the (template parameter) type VALUE_TYPE be copy-assignable and copy-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

vector& operator= ( bsl::vector< VALUE_TYPE, ALLOCATOR >::operator=

(

std::initializer_list< VALUE_TYPE >

values

)

[inherited]

< Assign to this object the value of the specified rhs object, propagate to this object the allocator of rhs if the ALLOCATOR type has trait propagate_on_container_move_assignment, and return a reference providing modifiable access to this object. The contents of rhs are moved (in constant time) to this vector if get_allocator() == rhs.get_allocator() (after accounting for the aforementioned trait); otherwise, all elements in this vector are either destroyed or move-assigned to and each additional element in rhs is move-inserted into this vector. rhs is left in a valid but unspecified state, and if an exception is thrown, *this is left in a valid but unspecified state. This method requires that the (template parameter) type VALUE_TYPE be move-assignable and move-insertable into this vector (see Requirements on VALUE_TYPE). Assign to this object the value resulting from first clearing this vector and then inserting (in order) each VALUE_TYPE object in the specified values initializer list, and return a reference providing modifiable access to this object. If an exception is thrown, *this is left in a valid but unspecified state. This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::assign

(

std::initializer_list< VALUE_TYPE >

values

)

[inherited]

Assign to this object the value resulting from first clearing this vector and then inserting (in order) each VALUE_TYPE object in the specified values initializer list. If an exception is thrown, *this is left in a valid but unspecified state. This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

template<class INPUT_ITER >

void bsl::vector< VALUE_TYPE, ALLOCATOR >::assign	(	INPUT_ITER	first,
		INPUT_ITER	last
	)			[inherited]

Assign to this object the value resulting from first clearing this vector and then inserting (in order) each value_type object in the range starting at the specified first element, and ending immediately before the specified last element. If an exception is thrown, *this is left in a valid but unspecified state. Throw std::length_error if distance(first,last) > max_size(). The (template parameter) type INPUT_ITER shall meet the requirements of an input iterator defined in the C++11 standard [24.2.3] providing access to values of a type convertible to value_type, and value_type must be emplace-constructible from *i into this vector, where i is a dereferenceable iterator in the range [first .. last) (see Requirements on VALUE_TYPE). The behavior is undefined unless first and last refer to a range of valid values where first is at a position at or before last.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::assign	(	size_type	numElements,
		const VALUE_TYPE &	value
	)			[inherited]

Assign to this object the value resulting from first clearing this vector and then inserting the specified numElements copies of the specified value. If an exception is thrown, *this is left in a valid but unspecified state. Throw std::length_error if numElements > max_size(). This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::resize

(

size_type

newSize

)

[inherited]

Change the size of this vector to the specified newSize. If newSize < size(), the elements in the range [newSize .. size()) are erased, and this function does not throw. If newSize > size(), the (newly created) elements in the range [size() .. newSize) are default-constructed value_type objects, and if an exception is thrown (other than by the move constructor of a non-copy-insertable value_type), *this is unaffected. Throw std::length_error if newSize > max_size(). This method requires that the (template parameter) type VALUE_TYPE be default-insertable and move-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::resize	(	size_type	newSize,
		const VALUE_TYPE &	value
	)			[inherited]

Change the size of this vector to the specified newSize, inserting newSize - size() copies of the specified value at the end of this vector if newSize > size(). If newSize < size(), the elements in the range [newSize .. size()) are erased, value is ignored, and this method does not throw. If newSize > size() and an exception is thrown, *this is unaffected. Throw std::length_error if newSize > max_size(). This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::reserve

(

size_type

newCapacity

)

[inherited]

Change the capacity of this vector to the specified newCapacity. If an exception is thrown (other than by the move constructor of a non-copy-insertable value_type), *this is unaffected. Throw bsl::length_error if newCapacity > max_size(). This method requires that the (template parameter) type VALUE_TYPE be move-insertable into this vector (see Requirements on VALUE_TYPE). Note that the capacity of this vector after this operation has completed may be greater than newCapacity.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::shrink_to_fit

(

)

[inherited]

Reduce the capacity of this vector to its size. If an exception is thrown (other than by the move constructor of a non-copy-insertable value_type), *this is unaffected. Note that this method has no effect if the capacity is equivalent to the size.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

template<class... Args>

VALUE_TYPE& bsl::vector< VALUE_TYPE, ALLOCATOR >::emplace_back

(

Args &&...

arguments

)

[inherited]

Append to the end of this vector a newly created value_type object, constructed by forwarding get_allocator() (if required) and the specified (variable number of) arguments to the corresponding constructor of value_type. Return a reference providing modifiable access to the inserted element. If an exception is thrown (other than by the move constructor of a non-copy-insertable value_type), *this is unaffected. This method requires that the (template parameter) type VALUE_TYPE be move-insertable into this vector and emplace-constructible from arguments (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::push_back

(

const VALUE_TYPE &

value

)

[inherited]

Append to the end of this vector a copy of the specified value. If an exception is thrown, *this is unaffected. Throw std::length_error if size() == max_size(). This method requires that the (template parameter) type VALUE_TYPE be copy-constructible (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::push_back

(

BloombergLP::bslmf::MovableRef< VALUE_TYPE >

value

)

[inherited]

Append to the end of this vector the specified move-insertable value. value is left in a valid but unspecified state. If an exception is thrown (other than by the move constructor of a non-copy-insertable value_type), *this is unaffected. Throw std::length_error if size() == max_size(). This method requires that the (template parameter) type VALUE_TYPE be move-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void bsl::vector< VALUE_TYPE, ALLOCATOR >::pop_back

(

)

[inherited]

Erase the last element from this vector. The behavior is undefined if this vector is empty.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

template<class... Args>

iterator bsl::vector< VALUE_TYPE, ALLOCATOR >::emplace	(	const_iterator	position,
		Args &&...	arguments
	)			[inline, inherited]

Parameters:

arguments

Insert at the specified position in this vector a newly created value_type object, constructed by forwarding get_allocator() (if required) and the specified (variable number of) arguments to the corresponding constructor of value_type, and return an iterator referring to the newly created and inserted element. If an exception is thrown (other than by the copy constructor, move constructor, assignment operator, or move assignment operator of value_type), *this is unaffected. Throw std::length_error if size() == max_size(). The behavior is undefined unless position is an iterator in the range [begin() .. end()] (both endpoints included). This method requires that the (template parameter) type VALUE_TYPE be move-insertable into this vector and emplace-constructible from arguments (see Requirements on VALUE_TYPE).

NOTE: This function has been implemented inline due to an issue with the Sun compiler.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

iterator bsl::vector< VALUE_TYPE, ALLOCATOR >::insert	(	const_iterator	position,
		const VALUE_TYPE &	value
	)			[inherited]

Insert at the specified position in this vector a copy of the specified value, and return an iterator referring to the newly inserted element. If an exception is thrown (other than by the copy constructor, move constructor, assignment operator, or move assignment operator of VALUE_TYPE), *this is unaffected. Throw std::length_error if size() == max_size(). The behavior is undefined unless position is an iterator in the range [begin() .. end()] (both endpoints included). This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

iterator bsl::vector< VALUE_TYPE, ALLOCATOR >::insert	(	const_iterator	position,
		BloombergLP::bslmf::MovableRef< VALUE_TYPE >	value
	)			[inherited]

Insert at the specified position in this vector the specified move-insertable value, and return an iterator referring to the newly inserted element. value is left in a valid but unspecified state. If an exception is thrown (other than by the copy constructor, move constructor, assignment operator, or move assignment operator of VALUE_TYPE), this is unaffected. Throw std::length_error if size() == max_size(). The behavior is undefined unless position is an iterator in the range [begin() .. end()] (both endpoints included). This method requires that the (template parameter) type VALUE_TYPE be move-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

iterator bsl::vector< VALUE_TYPE, ALLOCATOR >::insert	(	const_iterator	position,
		size_type	numElements,
		const VALUE_TYPE &	value
	)			[inherited]

Insert at the specified position in this vector the specified numElements copies of the specified value, and return an iterator referring to the first newly inserted element. If an exception is thrown (other than by the copy constructor, move constructor, assignment operator, or move assignment operator of VALUE_TYPE), *this is unaffected. Throw std::length_error if size() + numElements > max_size(). The behavior is undefined unless position is an iterator in the range [begin() .. end()] (both endpoints included). This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

template<class INPUT_ITER >

iterator bsl::vector< VALUE_TYPE, ALLOCATOR >::insert	(	const_iterator	position,
		INPUT_ITER	first,
		INPUT_ITER	last
	)			[inline, inherited]

Parameters:

last

Insert at the specified position in this vector the values in the range starting at the specified first element, and ending immediately before the specified last element. Return an iterator referring to the first newly inserted element. If an exception is thrown (other than by the copy constructor, move constructor, assignment operator, or move assignment operator of value_type), *this is unaffected. Throw std::length_error if size() + distance(first, last) > max_size(). The (template parameter) type INPUT_ITER shall meet the requirements of an input iterator defined in the C++11 standard [24.2.3] providing access to values of a type convertible to value_type, and value_type must be emplace-constructible from *i into this vector, where i is a dereferenceable iterator in the range [first .. last) (see Requirements on VALUE_TYPE). The behavior is undefined unless position is an iterator in the range [begin() .. end()] (both endpoints included), and first and last refer to a range of valid values where first is at a position at or before last.

NOTE: This function has been implemented inline due to an issue with the Sun compiler.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

iterator bsl::vector< VALUE_TYPE, ALLOCATOR >::insert	(	const_iterator	position,
		std::initializer_list< VALUE_TYPE >	values
	)			[inherited]

Insert at the specified position in this vector each VALUE_TYPE object in the specified values initializer list, and return an iterator referring to the first newly inserted element. If an exception is thrown (other than by the copy constructor, move constructor, assignment operator, and move assignment operator of VALUE_TYPE), *this is unaffected. Throw std::length_error if size() + values.size() > max_size(). The behavior is undefined unless position is an iterator in the range [begin() .. end()] (both endpoints included). This method requires that the (template parameter) type VALUE_TYPE be copy-insertable into this vector (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

iterator bsl::vector< VALUE_TYPE, ALLOCATOR >::erase

(

const_iterator

position

)

[inherited]

Remove from this vector the element at the specified position, and return an iterator providing modifiable access to the element immediately following the removed element, or the position returned by the method end if the removed element was the last in the sequence. The behavior is undefined unless position is an iterator in the range [cbegin() .. cend()).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

iterator bsl::vector< VALUE_TYPE, ALLOCATOR >::erase	(	const_iterator	first,
		const_iterator	last
	)			[inherited]

Remove from this vector the sequence of elements starting at the specified first position and ending before the specified last position, and return an iterator providing modifiable access to the element immediately following the last removed element, or the position returned by the method end if the removed elements were last in the sequence. The behavior is undefined unless first is an iterator in the range [cbegin() .. cend()] (both endpoints included) and last is an iterator in the range [first .. cend()] (both endpoints included).

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

allocator_type bsl::vector< VALUE_TYPE, ALLOCATOR >::get_allocator

(

)

const [inherited]

Return (a copy of) the allocator used for memory allocation by this vector.

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

size_type bsl::vector< VALUE_TYPE, ALLOCATOR >::max_size

(

)

const [inherited]

Return a theoretical upper bound on the largest number of elements that this vector could possibly hold. Note that there is no guarantee that the vector can successfully grow to the returned size, or even close to that size without running out of resources. Also note that requests to create a vector longer than this number of elements are guaranteed to raise a std::length_error exception.

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator==	(	const vector< VALUE_TYPE, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two vector objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE_TYPE be equality-comparable (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator!=	(	const vector< VALUE_TYPE, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two vector objects lhs and rhs do not have the same value if they do not have the same number of elements, or some element in the ordered sequence of elements of lhs does not have the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE_TYPE be equality-comparable (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator<	(	const vector< VALUE_TYPE, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE, ALLOCATOR > &	rhs
	)

Return true if the value of the specified lhs vector is lexicographically less than that of the specified rhs vector, and false otherwise. Given iterators i and j over the respective sequences [lhs.begin() .. lhs.end()) and [rhs.begin() .. rhs.end()), the value of vector lhs is lexicographically less than that of vector rhs if true == *i < *j for the first pair of corresponding iterator positions where *i < *j and *j < *i are not both false. If no such corresponding iterator position exists, the value of lhs is lexicographically less than that of rhs if lhs.size() < rhs.size(). This method requires that operator<, inducing a total order, be defined for value_type.

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator>	(	const vector< VALUE_TYPE, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE, ALLOCATOR > &	rhs
	)

Return true if the value of the specified lhs vector is lexicographically greater than that of the specified rhs vector, and false otherwise. The value of vector lhs is lexicographically greater than that of vector rhs if rhs is lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns rhs < lhs.

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator<=	(	const vector< VALUE_TYPE, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE, ALLOCATOR > &	rhs
	)

Return true if the value of the specified lhs vector is lexicographically less than or equal to that of the specified rhs vector, and false otherwise. The value of vector lhs is lexicographically less than or equal to that of vector rhs if rhs is not lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(rhs < lhs).

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator>=	(	const vector< VALUE_TYPE, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE, ALLOCATOR > &	rhs
	)

Return true if the value of the specified lhs vector is lexicographically greater than or equal to that of the specified rhs vector, and false otherwise. The value of vector lhs is lexicographically greater than or equal to that of vector rhs if lhs is not lexicographically less than rhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(lhs < rhs).

template<class VALUE_TYPE , class ALLOCATOR , class BDE_OTHER_TYPE >

vector<VALUE_TYPE, ALLOCATOR>::size_type bsl::erase	(	vector< VALUE_TYPE, ALLOCATOR > &	vec,
		const BDE_OTHER_TYPE &	value
	)

Erase all the elements in the specified vector vec that compare equal to the specified value. Return the number of elements erased.

template<class VALUE_TYPE , class ALLOCATOR , class PREDICATE >

vector<VALUE_TYPE, ALLOCATOR>::size_type bsl::erase_if	(	vector< VALUE_TYPE, ALLOCATOR > &	vec,
		PREDICATE	predicate
	)

Erase all the elements in the specified vector vec that satisfy the specified predicate predicate. Return the number of elements erased.

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::swap	(	vector< VALUE_TYPE, ALLOCATOR > &	a,
		vector< VALUE_TYPE, ALLOCATOR > &	b
	)

Exchange the value of the specified a object with that of the specified b object; also exchange the allocator of a with that of b if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This function provides the no-throw exception-safety guarantee. This operation has O[1] complexity if either a was created with the same allocator as b or ALLOCATOR has the propagate_on_container_swap trait; otherwise, it has O[n + m] complexity, where n and m are the number of elements in a and b, respectively. Note that this function's support for swapping objects created with different allocators when ALLOCATOR does not have the propagate_on_container_swap trait is a departure from the C++ Standard.

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector

(

const ALLOCATOR &

basicAllocator

)

[explicit, inherited]

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector	(	size_type	initialSize,
		const ALLOCATOR &	basicAllocator = ALLOCATOR()
	)			[explicit, inherited]

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector	(	size_type	initialSize,
		VALUE_TYPE *	value,
		const ALLOCATOR &	basicAllocator = ALLOCATOR()
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

template<class INPUT_ITER >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector	(	INPUT_ITER	first,
		INPUT_ITER	last,
		const ALLOCATOR &	basicAllocator = ALLOCATOR()
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector

(

const vector< VALUE_TYPE *, ALLOCATOR > &

original

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector

(

BloombergLP::bslmf::MovableRef< vector< VALUE_TYPE *, ALLOCATOR > >

original

)

[inherited]

IMPLICIT:

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector	(	const vector< VALUE_TYPE *, ALLOCATOR > &	original,
		const typename type_identity< ALLOCATOR >::type &	basicAllocator
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector	(	BloombergLP::bslmf::MovableRef< vector< VALUE_TYPE *, ALLOCATOR > >	original,
		const typename type_identity< ALLOCATOR >::type &	basicAllocator
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::vector	(	std::initializer_list< VALUE_TYPE * >	values,
		const ALLOCATOR &	basicAllocator = ALLOCATOR()
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

bsl::vector< VALUE_TYPE *, ALLOCATOR >::~vector

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

vector& bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator=

(

const vector< VALUE_TYPE *, ALLOCATOR > &

rhs

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

vector& bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator=

(

BloombergLP::bslmf::MovableRef< vector< VALUE_TYPE *, ALLOCATOR > >

rhs

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

vector& bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator=

(

std::initializer_list< VALUE_TYPE * >

values

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::assign

(

std::initializer_list< VALUE_TYPE * >

values

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

template<class INPUT_ITER >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::assign	(	INPUT_ITER	first,
		INPUT_ITER	last
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::assign	(	size_type	numElements,
		VALUE_TYPE *	value
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::begin

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::end

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

reverse_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::rbegin

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

reverse_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::rend

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

reference bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator[]

(

size_type

position

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

reference bsl::vector< VALUE_TYPE *, ALLOCATOR >::at

(

size_type

position

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

reference bsl::vector< VALUE_TYPE *, ALLOCATOR >::front

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

reference bsl::vector< VALUE_TYPE *, ALLOCATOR >::back

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

VALUE_TYPE** bsl::vector< VALUE_TYPE *, ALLOCATOR >::data

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::resize

(

size_type

newLength

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::resize	(	size_type	newLength,
		VALUE_TYPE *	value
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::reserve

(

size_type

newCapacity

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::shrink_to_fit

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

value_type& bsl::vector< VALUE_TYPE *, ALLOCATOR >::emplace_back

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

value_type& bsl::vector< VALUE_TYPE *, ALLOCATOR >::emplace_back

(

VALUE_TYPE *

ptr

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::push_back

(

VALUE_TYPE *

value

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::pop_back

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::emplace

(

const_iterator

position

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::emplace	(	const_iterator	position,
		VALUE_TYPE *	ptr
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::insert	(	const_iterator	position,
		VALUE_TYPE *	value
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::insert	(	const_iterator	position,
		size_type	numElements,
		VALUE_TYPE *	value
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

template<class INPUT_ITER >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::insert	(	const_iterator	position,
		INPUT_ITER	first,
		INPUT_ITER	last
	)			[inline, inherited]

template<class VALUE_TYPE , class ALLOCATOR >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::insert	(	const_iterator	position,
		std::initializer_list< VALUE_TYPE * >	values
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::erase

(

const_iterator

position

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::erase	(	const_iterator	first,
		const_iterator	last
	)			[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::swap

(

vector< VALUE_TYPE *, ALLOCATOR > &

other

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::vector< VALUE_TYPE *, ALLOCATOR >::clear

(

)

[inherited]

template<class VALUE_TYPE , class ALLOCATOR >

allocator_type bsl::vector< VALUE_TYPE *, ALLOCATOR >::get_allocator

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

size_type bsl::vector< VALUE_TYPE *, ALLOCATOR >::max_size

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::begin

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::cbegin

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::end

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::cend

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_reverse_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::rbegin

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_reverse_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::crbegin

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_reverse_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::rend

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_reverse_iterator bsl::vector< VALUE_TYPE *, ALLOCATOR >::crend

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

size_type bsl::vector< VALUE_TYPE *, ALLOCATOR >::size

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

size_type bsl::vector< VALUE_TYPE *, ALLOCATOR >::capacity

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::vector< VALUE_TYPE *, ALLOCATOR >::empty

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_reference bsl::vector< VALUE_TYPE *, ALLOCATOR >::operator[]

(

size_type

position

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_reference bsl::vector< VALUE_TYPE *, ALLOCATOR >::at

(

size_type

position

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_reference bsl::vector< VALUE_TYPE *, ALLOCATOR >::front

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

const_reference bsl::vector< VALUE_TYPE *, ALLOCATOR >::back

(

)

const [inherited]

template<class VALUE_TYPE , class ALLOCATOR >

VALUE_TYPE* const* bsl::vector< VALUE_TYPE *, ALLOCATOR >::data

(

)

const [inherited]

---

Variable Documentation

template<class VALUE_TYPE>

VALUE_TYPE* bsl::vectorBase< VALUE_TYPE >::d_dataBegin_p [protected, inherited]

beginning of data storage (owned)

Referenced by bsl::vector< ThreadUtil::Handle >::emplace().

template<class VALUE_TYPE>

VALUE_TYPE* bsl::vectorBase< VALUE_TYPE >::d_dataEnd_p [protected, inherited]

one past the end of data storage

Referenced by bsl::vector< ThreadUtil::Handle >::emplace().

template<class VALUE_TYPE>

std::size_t bsl::vectorBase< VALUE_TYPE >::d_capacity [protected, inherited]

capacity of data storage in # of elements

Referenced by bsl::vector< ThreadUtil::Handle >::emplace().

template<class VALUE_TYPE, class ALLOCATOR = allocator<VALUE_TYPE>>

void swap (vector& other) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION( AllocatorTraits void bsl::vector< VALUE_TYPE, ALLOCATOR >::clear() BSLS_KEYWORD_NOEXCEPT [inherited]

< Exchange the value of this object with that of the specified other object; also exchange the allocator of this object with that of other if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This method provides the no-throw exception-safety guarantee. This operation has O[1] complexity if either this object was created with the same allocator as other or ALLOCATOR has the propagate_on_container_swap trait; otherwise, it has O[n + m] complexity, where n and m are the number of elements in this object and other, respectively. Note that this method's support for swapping objects created with different allocators when ALLOCATOR does not have the propagate_on_container_swap trait is a departure from the C++ Standard. Remove all elements from this vector making its size 0. Note that although this vector is empty after this method returns, it preserves the same capacity it had before the method was called.

---

Friends

template<class VALUE_TYPE , class ALLOCATOR >

bool operator==	(	const vector< VALUE_TYPE *, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE *, ALLOCATOR > &	rhs
	)			[friend, inherited]

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two vector objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE_TYPE be equality-comparable (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE , class ALLOCATOR >

bool operator!=	(	const vector< VALUE_TYPE *, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE *, ALLOCATOR > &	rhs
	)			[friend, inherited]

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two vector objects lhs and rhs do not have the same value if they do not have the same number of elements, or some element in the ordered sequence of elements of lhs does not have the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE_TYPE be equality-comparable (see Requirements on VALUE_TYPE).

template<class VALUE_TYPE , class ALLOCATOR >

bool operator<	(	const vector< VALUE_TYPE *, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE *, ALLOCATOR > &	rhs
	)			[friend, inherited]

Return true if the value of the specified lhs vector is lexicographically less than that of the specified rhs vector, and false otherwise. Given iterators i and j over the respective sequences [lhs.begin() .. lhs.end()) and [rhs.begin() .. rhs.end()), the value of vector lhs is lexicographically less than that of vector rhs if true == *i < *j for the first pair of corresponding iterator positions where *i < *j and *j < *i are not both false. If no such corresponding iterator position exists, the value of lhs is lexicographically less than that of rhs if lhs.size() < rhs.size(). This method requires that operator<, inducing a total order, be defined for value_type.

template<class VALUE_TYPE , class ALLOCATOR >

bool operator>	(	const vector< VALUE_TYPE *, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE *, ALLOCATOR > &	rhs
	)			[friend, inherited]

Return true if the value of the specified lhs vector is lexicographically greater than that of the specified rhs vector, and false otherwise. The value of vector lhs is lexicographically greater than that of vector rhs if rhs is lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns rhs < lhs.

template<class VALUE_TYPE , class ALLOCATOR >

bool operator<=	(	const vector< VALUE_TYPE *, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE *, ALLOCATOR > &	rhs
	)			[friend, inherited]

Return true if the value of the specified lhs vector is lexicographically less than or equal to that of the specified rhs vector, and false otherwise. The value of vector lhs is lexicographically less than or equal to that of vector rhs if rhs is not lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(rhs < lhs).

template<class VALUE_TYPE , class ALLOCATOR >

bool operator>=	(	const vector< VALUE_TYPE *, ALLOCATOR > &	lhs,
		const vector< VALUE_TYPE *, ALLOCATOR > &	rhs
	)			[friend, inherited]

Return true if the value of the specified lhs vector is lexicographically greater than or equal to that of the specified rhs vector, and false otherwise. The value of vector lhs is lexicographically greater than or equal to that of vector rhs if lhs is not lexicographically less than rhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(lhs < rhs).

template<class VALUE_TYPE , class ALLOCATOR >

void swap	(	vector< VALUE_TYPE *, ALLOCATOR > &	a,
		vector< VALUE_TYPE *, ALLOCATOR > &	b
	)			[friend, inherited]

Exchange the value of the specified a object with that of the specified b object; also exchange the allocator of a with that of b if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This function provides the no-throw exception-safety guarantee. This operation has O[1] complexity if either a was created with the same allocator as b or ALLOCATOR has the propagate_on_container_swap trait; otherwise, it has O[n + m] complexity, where n and m are the number of elements in a and b, respectively. Note that this function's support for swapping objects created with different allocators when ALLOCATOR does not have the propagate_on_container_swap trait is a departure from the C++ Standard.