bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH > Struct Template Reference

#include <bslalg_dequeprimitives.h>

Public Types
typedef std::size_t	size_type
typedef DequeIterator< VALUE_TYPE, BLOCK_LENGTH >	Iterator

Static Public Member Functions
template<class ALLOCATOR >
static void	destruct (Iterator begin, Iterator end, ALLOCATOR allocator)
template<class ALLOCATOR >
static void	destruct (Iterator begin, Iterator end, ALLOCATOR allocator, bsl::integral_constant< int, NIL_TRAITS >)
template<class ALLOCATOR >
static void	destruct (Iterator begin, Iterator end, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >)
template<class ALLOCATOR >
static Iterator	erase (Iterator *toBegin, Iterator *toEnd, Iterator fromBegin, Iterator first, Iterator last, Iterator fromEnd, ALLOCATOR allocator)
template<class ALLOCATOR >
static Iterator	erase (Iterator *toBegin, Iterator *toEnd, Iterator fromBegin, Iterator first, Iterator last, Iterator fromEnd, ALLOCATOR allocator, bsl::integral_constant< int, NIL_TRAITS >)
template<class ALLOCATOR >
static Iterator	erase (Iterator *toBegin, Iterator *toEnd, Iterator fromBegin, Iterator first, Iterator last, Iterator fromEnd, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >)
template<class ALLOCATOR >
static void	insertAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator)
template<class ALLOCATOR >
static void	insertAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >)
template<class ALLOCATOR >
static void	insertAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >)
template<class ALLOCATOR >
static void	insertAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator, bsl::integral_constant< int, NIL_TRAITS >)
template<class FWD_ITER , class ALLOCATOR >
static void	insertAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, FWD_ITER first, FWD_ITER last, size_type numElements, ALLOCATOR allocator)
template<class ALLOCATOR >
static void	moveInsertAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator)
template<class ALLOCATOR >
static void	moveInsertAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >)
template<class ALLOCATOR >
static void	moveInsertAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >)
template<class ALLOCATOR >
static void	moveInsertAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator, bsl::integral_constant< int, NIL_TRAITS >)
template<class ALLOCATOR >
static void	insertAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator)
template<class ALLOCATOR >
static void	insertAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >)
template<class ALLOCATOR >
static void	insertAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >)
template<class ALLOCATOR >
static void	insertAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator, bsl::integral_constant< int, NIL_TRAITS >)
template<class FWD_ITER , class ALLOCATOR >
static void	insertAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, FWD_ITER first, FWD_ITER last, size_type numElements, ALLOCATOR allocator)
template<class ALLOCATOR >
static void	moveInsertAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator)
template<class ALLOCATOR >
static void	moveInsertAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >)
template<class ALLOCATOR >
static void	moveInsertAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >)
template<class ALLOCATOR >
static void	moveInsertAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator, bsl::integral_constant< int, NIL_TRAITS >)
template<class ALLOCATOR , class... Args>
static void	emplaceAndMoveToBack (Iterator *toEnd, Iterator fromEnd, Iterator position, ALLOCATOR allocator, Args &&... arguments)
template<class ALLOCATOR , class... Args>
static void	emplaceAndMoveToBackDispatch (Iterator *toEnd, Iterator fromEnd, Iterator position, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >, Args &&... arguments)
template<class ALLOCATOR , class... Args>
static void	emplaceAndMoveToBackDispatch (Iterator *toEnd, Iterator fromEnd, Iterator position, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >, Args &&... arguments)
template<class ALLOCATOR , class... Args>
static void	emplaceAndMoveToBackDispatch (Iterator *toEnd, Iterator fromEnd, Iterator position, ALLOCATOR allocator, bsl::integral_constant< int, NIL_TRAITS >, Args &&... arguments)
template<class ALLOCATOR , class... Args>
static void	emplaceAndMoveToFront (Iterator *toBegin, Iterator fromBegin, Iterator position, ALLOCATOR allocator, Args &&... arguments)
template<class ALLOCATOR , class... Args>
static void	emplaceAndMoveToFrontDispatch (Iterator *toBegin, Iterator fromBegin, Iterator position, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >, Args &&... arguments)
template<class ALLOCATOR , class... Args>
static void	emplaceAndMoveToFrontDispatch (Iterator *toBegin, Iterator fromBegin, Iterator position, ALLOCATOR allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >, Args &&... arguments)
template<class ALLOCATOR , class... Args>
static void	emplaceAndMoveToFrontDispatch (Iterator *toBegin, Iterator fromBegin, Iterator position, ALLOCATOR allocator, bsl::integral_constant< int, NIL_TRAITS >, Args &&... arguments)
static void	moveBack (Iterator *destination, Iterator *source, size_type numElements)
static void	moveFront (Iterator *destination, Iterator *source, size_type numElements)
template<class ALLOCATOR >
static void	uninitializedFillNBack (Iterator *toEnd, Iterator fromEnd, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator)
template<class ALLOCATOR >
static void	uninitializedFillNFront (Iterator *toBegin, Iterator fromBegin, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator)
template<class ALLOCATOR >
static void	valueInititalizeN (Iterator *toEnd, Iterator fromEnd, size_type numElements, ALLOCATOR allocator)

Detailed Description

template<class VALUE_TYPE, int BLOCK_LENGTH>
struct bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >

This struct provides a namespace for a suite of utility functions that operate on deques parameterized by the VALUE_TYPE and BLOCK_LENGTH. Depending on the traits of VALUE_TYPE, the default and copy constructors, destructor, assignment operators, etcetera may not be invoked, and instead the operation can be optimized using a no-op, bitwise move, or bitwise copy.

Member Typedef Documentation

Iterator

template<class VALUE_TYPE , int BLOCK_LENGTH>

typedef DequeIterator<VALUE_TYPE, BLOCK_LENGTH> bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::Iterator

size_type

template<class VALUE_TYPE , int BLOCK_LENGTH>

typedef std::size_t bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::size_type

Member Function Documentation

destruct() [1/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::destruct ( Iterator  begin, Iterator  end, ALLOCATOR  allocator  )

inlinestatic

TBD: fix comment Call the destructor on each of the elements of a deque of parameterized VALUE_TYPE in the specified range [begin .. end). The behavior is undefined unless begin <= end. Note that this does not deallocate any memory (except memory deallocated by the element destructor calls).

destruct() [2/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::destruct ( Iterator  begin, Iterator  end, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >    )

static

destruct() [3/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::destruct ( Iterator  begin, Iterator  end, ALLOCATOR  allocator, bsl::integral_constant< int, NIL_TRAITS >    )

static

Call the destructor on each of the elements of a deque of parameterized VALUE_TYPE in the specified range [begin .. end). The behavior is undefined unless begin <= end. Note that this does not deallocate any memory (except memory deallocated by the element destructor calls). Note that the last argument is for removing overload ambiguities and is not used.

emplaceAndMoveToBack()

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR , class... Args>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::emplaceAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, ALLOCATOR  allocator, Args &&...  arguments  )

inlinestatic

Insert at the specified position a newly created VALUE_TYPE object, constructed by forwarding the specified allocator (if required) and the specified (variable number of) arguments to the corresponding constructor of VALUE_TYPE, and move the elements in the range [position .. fromEnd) forward by 1 position. Load into the specified toEnd an iterator one past the inserted element (i.e., fromEnd + 1). The behavior is undefined unless fromEnd + 1 is a valid iterator (i.e., the block pointer array holds enough room after the fromEnd position to insert 1 element).

emplaceAndMoveToBackDispatch() [1/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR , class... Args>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::emplaceAndMoveToBackDispatch ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >  , Args &&...  arguments  )

static

Insert at the specified position a newly created VALUE_TYPE object, constructed by forwarding the specified allocator (if required) and the specified (variable number of) arguments to the corresponding constructor of VALUE_TYPE, and move the elements in the range [position .. fromEnd) forward by 1 position. Load into the specified toEnd an iterator one past the inserted element (i.e., fromEnd + 1). The behavior is undefined unless fromEnd + 1 is a valid iterator (i.e., the block pointer array holds enough room after the fromEnd position to insert 1 element). Note that the next to last argument is for removing overload ambiguities and is not used.

emplaceAndMoveToBackDispatch() [2/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR , class... Args>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::emplaceAndMoveToBackDispatch ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >  , Args &&...  arguments  )

static

emplaceAndMoveToBackDispatch() [3/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR , class... Args>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::emplaceAndMoveToBackDispatch ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, ALLOCATOR  allocator, bsl::integral_constant< int, NIL_TRAITS >  , Args &&...  arguments  )

static

emplaceAndMoveToFront()

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR , class... Args>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::emplaceAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, ALLOCATOR  allocator, Args &&...  arguments  )

inlinestatic

Insert at the specified position a newly created VALUE_TYPE object, constructed by forwarding the specified allocator (if required) and the specified (variable number of) arguments to the corresponding constructor of VALUE_TYPE, and move the elements in the range [fromBegin .. position) backward by 1 position. Load into the specified toBegin an iterator to the inserted element (i.e., fromBegin - 1). The behavior is undefined unless fromBegin - 1 is a valid iterator (i.e., the block pointer array holds enough room before the fromBegin position to insert 1 element).

emplaceAndMoveToFrontDispatch() [1/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR , class... Args>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::emplaceAndMoveToFrontDispatch ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >  , Args &&...  arguments  )

static

Insert at the specified position a newly created VALUE_TYPE object, constructed by forwarding the specified allocator (if required) and the specified (variable number of) arguments to the corresponding constructor of VALUE_TYPE, and move the elements in the range [fromBegin .. position) backward by 1 position. Load into the specified toBegin an iterator to the inserted element (i.e., fromBegin - 1). The behavior is undefined unless fromBegin - 1 is a valid iterator (i.e., the block pointer array holds enough room before the fromBegin position to insert 1 element). Note that the next to last argument is for removing overload ambiguities and is not used.

emplaceAndMoveToFrontDispatch() [2/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR , class... Args>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::emplaceAndMoveToFrontDispatch ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >  , Args &&...  arguments  )

static

emplaceAndMoveToFrontDispatch() [3/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR , class... Args>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::emplaceAndMoveToFrontDispatch ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, ALLOCATOR  allocator, bsl::integral_constant< int, NIL_TRAITS >  , Args &&...  arguments  )

static

erase() [1/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::Iterator bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::erase ( Iterator *  toBegin, Iterator *  toEnd, Iterator  fromBegin, Iterator  first, Iterator  last, Iterator  fromEnd, ALLOCATOR  allocator  )

inlinestatic

Call the destructor on each of the elements of a deque of parameterized VALUE_TYPE in the specified range [first .. last). Shift the elements to fill up the empty space after the erasure, using the smaller of the range defined by [fromBegin .. first) and [last .. fromEnd) after the erasure. Load in the specified toBegin and toEnd the new boundaries of the deque after erasure and return an iterator pointing to the element immediately following the removed elements. The behavior is undefined unless fromBegin <= first <= last <= fromEnd.

erase() [2/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::Iterator bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::erase ( Iterator *  toBegin, Iterator *  toEnd, Iterator  fromBegin, Iterator  first, Iterator  last, Iterator  fromEnd, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >    )

static

erase() [3/3]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::Iterator bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::erase ( Iterator *  toBegin, Iterator *  toEnd, Iterator  fromBegin, Iterator  first, Iterator  last, Iterator  fromEnd, ALLOCATOR  allocator, bsl::integral_constant< int, NIL_TRAITS >    )

static

Call the destructor on each of the elements of a deque of parameterized VALUE_TYPE in the specified range [first .. last). Shift the elements from the smaller of the specified range [fromBegin .. first) and [last .. fromEnd) to fill up the empty spaces after the erasure. Load in the specified toBegin and toEnd the new boundaries of the deque after erasure and return an iterator pointing to the element immediately following the removed elements. The behavior is undefined unless fromBegin <= first <= last <= fromEnd. Note that the last argument is for removing overload ambiguities and is not used.

insertAndMoveToBack() [1/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class FWD_ITER , class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, FWD_ITER  first, FWD_ITER  last, size_type  numElements, ALLOCATOR  allocator  )

static

Insert the specified numElements in the range [first .. last) at the specified position, by moving the elements in the range [position .. fromEnd) forward by numElements position. Pass the specified allocator to the copy constructor if appropriate. Load into the specified toEnd an iterator to the end of the data after insertion (i.e., fromEnd + numElements). The behavior is undefined unless fromEnd + numElements is a valid iterator (i.e., the block pointer array holds enough room after the fromEnd position to insert numElements).

insertAndMoveToBack() [2/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator  )

inlinestatic

Insert the specified numElements copies of the specified value at the specified position, by moving the elements in the range [position .. fromEnd) forward by numElements position. Pass the specified allocator to the copy constructor if appropriate. Load into the specified toEnd an iterator to the end of the deque after insertion (i.e., fromEnd + numElements). The behavior is undefined unless fromEnd + numElements is a valid iterator (i.e., the block pointer array holds enough room after the fromEnd position to insert numElements).

insertAndMoveToBack() [3/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >    )

static

Insert the specified numElements copies of the specified value at the specified position, by moving the elements in the range [position .. fromEnd) forward by numElements position. Pass the specified allocator to the copy constructor if appropriate. Load into the specified toEnd an iterator to the end of the deque after insertion (i.e., fromEnd + numElements). The behavior is undefined unless fromEnd + numElements is a valid iterator (i.e., the block pointer array holds enough room after the fromEnd position to insert numElements). Note that the last argument is for removing overload ambiguities and is not used.

insertAndMoveToBack() [4/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >    )

static

insertAndMoveToBack() [5/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator, bsl::integral_constant< int, NIL_TRAITS >    )

static

insertAndMoveToFront() [1/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class FWD_ITER , class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, FWD_ITER  first, FWD_ITER  last, size_type  numElements, ALLOCATOR  allocator  )

static

Insert the specified numElements in the range [first .. last) at the specified position, by moving the elements in the range [fromBegin .. position) backward by numElements position. Pass the specified allocator to the copy constructor if appropriate. Load into the specified toBegin an iterator to the end of the data after insertion (i.e., fromBegin - numElements). The behavior is undefined unless fromBegin - numElements is a valid iterator (i.e., the block pointer array holds enough room before the fromBefore position to insert numElements).

insertAndMoveToFront() [2/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator  )

inlinestatic

Insert the specified numElements copies of the specified value at the specified position, by moving the elements in the range [fromBegin .. position) backward by numElements position. Pass the specified allocator to the copy constructor if appropriate. Load into the specified toBegin an iterator to the beginning of the data after insertion (i.e., fromBegin - numElements). The behavior is undefined unless fromBegin - numElements is a valid iterator (i.e., the block pointer array holds enough room before the fromBegin position to insert numElements).

insertAndMoveToFront() [3/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >    )

static

Insert the specified numElements copies of the specified value at the specified position, by moving the elements in the range [fromBegin .. position) backward by numElements position. Pass the specified allocator to the copy constructor if appropriate. Load into the specified toBegin an iterator to the beginning of the data after insertion (i.e., fromBegin - numElements. The behavior is undefined unless fromBegin - numElements is a valid iterator (i.e., the block pointer array holds enough room before the fromBegin position to insert numElements). Note that the last argument is for removing overload ambiguities and is not used.

insertAndMoveToFront() [4/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >    )

static

insertAndMoveToFront() [5/5]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::insertAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator, bsl::integral_constant< int, NIL_TRAITS >    )

static

moveBack()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveBack ( Iterator *  destination, Iterator *  source, size_type  numElements  )

static

Move the specified numElements from the specified source to the specified destination using std::memmove. Also load into destination the value destination - numElements and source the value source - numElements. The behavior is undefined unless destination >= source.

moveFront()

template<class VALUE_TYPE , int BLOCK_LENGTH>

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveFront ( Iterator *  destination, Iterator *  source, size_type  numElements  )

static

Move the specified numElements from the specified source to the specified destination using std::memmove. Also load into destination the value destination + numElements and source the the value source + numElements. The behavior is undefined unless destination <= source.

moveInsertAndMoveToBack() [1/4]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveInsertAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, bslmf::MovableRef< VALUE_TYPE >  value, ALLOCATOR  allocator  )

inlinestatic

Insert the specified move-insertable value at the specified position by moving the elements in the range [position .. fromEnd) forward by 1 position; pass the specified allocator to the move constructor if appropriate. Load into the specified toEnd an iterator one past the inserted element (i.e., fromEnd + 1). The behavior is undefined unless fromEnd + 1 is a valid iterator (i.e., the block pointer array holds enough room after the fromEnd position to insert 1 element).

moveInsertAndMoveToBack() [2/4]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveInsertAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, bslmf::MovableRef< VALUE_TYPE >  value, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >    )

static

Insert the specified move-insertable value at the specified position by moving the elements in the range [position .. fromEnd) forward by 1 position; pass the specified allocator to the move constructor if appropriate. Load into the specified toEnd an iterator one past the inserted element (i.e., fromEnd + 1). The behavior is undefined unless fromEnd + 1 is a valid iterator (i.e., the block pointer array holds enough room after the fromEnd position to insert 1 element). Note that the last argument is for removing overload ambiguities and is not used.

moveInsertAndMoveToBack() [3/4]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveInsertAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, bslmf::MovableRef< VALUE_TYPE >  value, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >    )

static

moveInsertAndMoveToBack() [4/4]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveInsertAndMoveToBack ( Iterator *  toEnd, Iterator  fromEnd, Iterator  position, bslmf::MovableRef< VALUE_TYPE >  value, ALLOCATOR  allocator, bsl::integral_constant< int, NIL_TRAITS >    )

static

moveInsertAndMoveToFront() [1/4]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveInsertAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, bslmf::MovableRef< VALUE_TYPE >  value, ALLOCATOR  allocator  )

inlinestatic

Insert the specified move-insertable value at the specified position by moving the elements in the range [fromBegin .. position) backward by 1 position; pass the specified allocator to the move constructor if appropriate. Load into the specified toBegin an iterator to the inserted element (i.e., fromBegin - 1). The behavior is undefined unless fromBegin - 1 is a valid iterator (i.e., the block pointer array holds enough room before the fromBegin position to insert 1 element).

moveInsertAndMoveToFront() [2/4]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveInsertAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, bslmf::MovableRef< VALUE_TYPE >  value, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_COPYABLE_TRAITS >    )

static

Insert the specified move-insertable value at the specified position by moving the elements in the range [fromBegin .. position) backward by 1 position; pass the specified allocator to the move constructor if appropriate. Load into the specified toBegin an iterator to the inserted element (i.e., fromBegin - 1). The behavior is undefined unless fromBegin - 1 is a valid iterator (i.e., the block pointer array holds enough room before the fromBegin position to insert 1 element). Note that the last argument is for removing overload ambiguities and is not used.

moveInsertAndMoveToFront() [3/4]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveInsertAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, bslmf::MovableRef< VALUE_TYPE >  value, ALLOCATOR  allocator, bsl::integral_constant< int, BITWISE_MOVEABLE_TRAITS >    )

static

moveInsertAndMoveToFront() [4/4]

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::moveInsertAndMoveToFront ( Iterator *  toBegin, Iterator  fromBegin, Iterator  position, bslmf::MovableRef< VALUE_TYPE >  value, ALLOCATOR  allocator, bsl::integral_constant< int, NIL_TRAITS >    )

static

uninitializedFillNBack()

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::uninitializedFillNBack ( Iterator *  toEnd, Iterator  fromEnd, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator  )

static

Append the specified numElements copies of the specified value to the deque ending at the specified fromEnd iterator, passing the specified allocator through to the new elements, and load into the specified toEnd an iterator pointing to the end of the data after appending (i.e., fromEnd + numElements). The behavior is undefined unless fromEnd + numElements is a valid iterator (i.e., the block pointer array holds enough room after the fromEnd position to insert numElements).

uninitializedFillNFront()

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::uninitializedFillNFront ( Iterator *  toBegin, Iterator  fromBegin, size_type  numElements, const VALUE_TYPE &  value, ALLOCATOR  allocator  )

static

Prepend the specified numElements copies of the specified value to the deque starting at the specified fromBegin iterator, passing the specified allocator through to the new elements, and load into the specified toBegin an iterator pointing to the end of the data after prepending, i.e., fromBegin - numElements. The behavior is undefined unless fromBegin - numElements is a valid iterator (i.e., the block pointer array holds enough room before the fromBegin position to insert numElements).

valueInititalizeN()

template<class VALUE_TYPE , int BLOCK_LENGTH>

template<class ALLOCATOR >

void bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH >::valueInititalizeN ( Iterator *  toEnd, Iterator  fromEnd, size_type  numElements, ALLOCATOR  allocator  )

static

Append the specified numElements value-initialized objects to the deque ending at the specified fromEnd iterator, passing the specified allocator through to the new elements, and load into the specified toEnd an iterator pointing to the end of the data after appending (i.e., fromEnd + numElements). The behavior is undefined unless fromEnd + numElements is a valid iterator (i.e., the block pointer array holds enough room after the fromEnd position to insert numElements).

---

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

• bslalg_dequeprimitives.h