BDE 4.39.x Production Release
Loading...
Searching...
No Matches
bslalg_dequeprimitives_cpp03.h
Go to the documentation of this file.
1/// @file bslalg_dequeprimitives_cpp03.h
2///
3/// The content of this file has been pre-processed for Doxygen.
4///
5
6
7// bslalg_dequeprimitives_cpp03.h -*-C++-*-
8
9// Automatically generated file. **DO NOT EDIT**
10
11#ifndef INCLUDED_BSLALG_DEQUEPRIMITIVES_CPP03
12#define INCLUDED_BSLALG_DEQUEPRIMITIVES_CPP03
13
14/// @defgroup bslalg_dequeprimitives_cpp03 bslalg_dequeprimitives_cpp03
15/// @brief Provide C++03 implementation for bslalg_dequeprimitives.h
16/// @addtogroup bsl
17/// @{
18/// @addtogroup bslalg
19/// @{
20/// @addtogroup bslalg_dequeprimitives_cpp03
21/// @{
22///
23/// <h1> Outline </h1>
24/// * <a href="#bslalg_dequeprimitives_cpp03-purpose"> Purpose</a>
25/// * <a href="#bslalg_dequeprimitives_cpp03-classes"> Classes </a>
26/// * <a href="#bslalg_dequeprimitives_cpp03-description"> Description </a>
27///
28/// # Purpose {#bslalg_dequeprimitives_cpp03-purpose}
29/// Provide C++03 implementation for bslalg_dequeprimitives.h
30///
31/// # Classes {#bslalg_dequeprimitives_cpp03-classes}
32/// See bslalg_dequeprimitives.h for list of classes
33///
34/// @see bslalg_dequeprimitives
35///
36/// # Description {#bslalg_dequeprimitives_cpp03-description}
37/// This component is the C++03 translation of a C++11 component,
38/// generated by the 'sim_cpp11_features.pl' program. If the original header
39/// contains any specially delimited regions of C++11 code, then this generated
40/// file contains the C++03 equivalent, i.e., with variadic templates expanded
41/// and rvalue-references replaced by 'bslmf::MovableRef' objects. The header
42/// code in this file is designed to be '#include'd into the original header
43/// when compiling with a C++03 compiler. If there are no specially delimited
44/// regions of C++11 code, then this header contains no code and is not
45/// '#include'd in the original header.
46///
47/// Generated on Tue Feb 3 19:14:28 2026
48/// Command line: sim_cpp11_features.pl bslalg_dequeprimitives.h
49/// @}
50/** @} */
51/** @} */
52
53/** @addtogroup bsl
54 * @{
55 */
56/** @addtogroup bslalg
57 * @{
58 */
59/** @addtogroup bslalg_dequeprimitives_cpp03
60 * @{
61 */
62
63#ifdef COMPILING_BSLALG_DEQUEPRIMITIVES_H
64
65
66
67namespace bslalg {
68
69template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
70class DequePrimitives_DequeElementGuard;
71
72template <class VALUE_TYPE, int BLOCK_LENGTH>
73class DequePrimitives_DequeMoveGuard;
74
75template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
76class DequePrimitives_ExternalDequeElementGuard;
77
78template <class VALUE_TYPE, int BLOCK_LENGTH>
79class DequePrimitives_DequeEndpointProctor;
80
81/// These constants are used in the overloads below, when the last argument is
82/// of type 'bsl::integral_constant<int, N>', indicating that 'VALUE_TYPE' has
83/// the traits for which the enumerator equal to 'N' is named.
84/// Workaround for windows. The windows compiler refuses to recognize enum
85/// declarations within a class template.
86enum {
87 BSLALG_DEQUEPRIMITIVES_NIL_TRAITS = 0,
88 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS = 1,
89 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS = 2,
90 BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS = 3
91};
92
93 // ======================
94 // struct DequePrimitives
95 // ======================
96
97/// This `struct` provides a namespace for a suite of utility functions that
98/// operate on deques parameterized by the `VALUE_TYPE` and `BLOCK_LENGTH`.
99/// Depending on the traits of `VALUE_TYPE`, the default and copy
100/// constructors, destructor, assignment operators, etcetera may not be
101/// invoked, and instead the operation can be optimized using a no-op,
102/// bitwise move, or bitwise copy.
103///
104/// See @ref bslalg_dequeprimitives_cpp03
105template <class VALUE_TYPE, int BLOCK_LENGTH>
106struct DequePrimitives {
107
108 // PUBLIC TYPES
109 typedef std::size_t size_type;
110 typedef DequeIterator<VALUE_TYPE, BLOCK_LENGTH> Iterator;
111
112 private:
113 // PRIVATE TYPES
114 typedef DequeImpUtil<VALUE_TYPE, BLOCK_LENGTH> ImpUtil;
115 typedef DequePrimitives_DequeMoveGuard<VALUE_TYPE, BLOCK_LENGTH> MoveGuard;
116 typedef bslmf::MovableRefUtil MoveUtil;
117
118 public:
119 // CLASS METHODS
120
121 /// TBD: fix comment
122 /// Call the destructor on each of the elements of a deque of
123 /// parameterized `VALUE_TYPE` in the specified range `[begin .. end)`.
124 ///
125 /// \pre The behavior is undefined unless `begin <= end`.
126 /// \note Note that this
127 /// does not deallocate any memory (except memory deallocated by the
128 /// element destructor calls).
129 template <class ALLOCATOR>
130 static void destruct(Iterator begin, Iterator end, ALLOCATOR allocator);
131
132 /// Call the destructor on each of the elements of a deque of
133 /// parameterized `VALUE_TYPE` in the specified range `[begin .. end)`.
134 ///
135 /// \pre The behavior is undefined unless `begin <= end`.
136 /// \note Note that this
137 /// does not deallocate any memory (except memory deallocated by the element destructor calls).
138 ///
139 /// \note Note that the last argument is for
140 /// removing overload ambiguities and is not used.
141 template <class ALLOCATOR>
142 static void destruct(
143 Iterator begin,
144 Iterator end,
145 ALLOCATOR allocator,
146 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
147 template <class ALLOCATOR>
148 static void destruct(Iterator begin,
149 Iterator end,
150 ALLOCATOR allocator,
151 bsl::integral_constant<
152 int,
153 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>);
154
155 /// Call the destructor on each of the elements of a deque of
156 /// parameterized `VALUE_TYPE` in the specified range `[first .. last)`.
157 /// Shift the elements to fill up the empty space after the erasure,
158 /// using the smaller of the range defined by `[fromBegin .. first)` and
159 /// `[last .. fromEnd)` after the erasure. Load in the specified
160 /// `toBegin` and `toEnd` the new boundaries of the deque after erasure
161 /// and return an iterator pointing to the element immediately following the removed elements.
162 ///
163 /// \pre The behavior is undefined unless
164 /// `fromBegin <= first <= last <= fromEnd`.
165 template <class ALLOCATOR>
166 static Iterator erase(Iterator *toBegin,
167 Iterator *toEnd,
168 Iterator fromBegin,
169 Iterator first,
170 Iterator last,
171 Iterator fromEnd,
172 ALLOCATOR allocator);
173
174 /// Call the destructor on each of the elements of a deque of
175 /// parameterized `VALUE_TYPE` in the specified range `[first .. last)`.
176 /// Shift the elements from the smaller of the specified range
177 /// `[fromBegin .. first)` and `[last .. fromEnd)` to fill up the empty
178 /// spaces after the erasure. Load in the specified `toBegin` and
179 /// `toEnd` the new boundaries of the deque after erasure and return an
180 /// iterator pointing to the element immediately following the removed elements.
181 ///
182 /// \pre The behavior is undefined unless `fromBegin <= first <= last <= fromEnd`.
183 ///
184 /// \note Note that the last
185 /// argument is for removing overload ambiguities and is not used.
186 template <class ALLOCATOR>
187 static Iterator erase(
188 Iterator *toBegin,
189 Iterator *toEnd,
190 Iterator fromBegin,
191 Iterator first,
192 Iterator last,
193 Iterator fromEnd,
194 ALLOCATOR allocator,
195 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
196 template <class ALLOCATOR>
197 static Iterator erase(Iterator *toBegin,
198 Iterator *toEnd,
199 Iterator fromBegin,
200 Iterator first,
201 Iterator last,
202 Iterator fromEnd,
203 ALLOCATOR allocator,
204 bsl::integral_constant<
205 int,
206 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>);
207
208 /// Insert the specified `numElements` copies of the specified `value`
209 /// at the specified `position`, by moving the elements in the range
210 /// `[position .. fromEnd)` forward by `numElements` position. Pass the
211 /// specified `allocator` to the copy constructor if appropriate. Load
212 /// into the specified `toEnd` an iterator to the end of the deque after
213 /// insertion (i.e., `fromEnd + numElements`).
214 ///
215 /// \pre The behavior is undefined unless `fromEnd + numElements` is a valid iterator (i.e.,
216 /// the block pointer array holds enough room after the `fromEnd`
217 /// position to insert `numElements`).
218 template <class ALLOCATOR>
219 static void insertAndMoveToBack(Iterator *toEnd,
220 Iterator fromEnd,
221 Iterator position,
222 size_type numElements,
223 const VALUE_TYPE& value,
224 ALLOCATOR allocator);
225
226 /// Insert the specified `numElements` copies of the specified `value`
227 /// at the specified `position`, by moving the elements in the range
228 /// `[position .. fromEnd)` forward by `numElements` position. Pass the
229 /// specified `allocator` to the copy constructor if appropriate. Load
230 /// into the specified `toEnd` an iterator to the end of the deque after
231 /// insertion (i.e., `fromEnd + numElements`).
232 ///
233 /// \pre The behavior is undefined unless `fromEnd + numElements` is a valid iterator (i.e.,
234 /// the block pointer array holds enough room after the `fromEnd` position to insert `numElements`).
235 ///
236 /// \note Note that the last argument is
237 /// for removing overload ambiguities and is not used.
238 template <class ALLOCATOR>
239 static void
240 insertAndMoveToBack(Iterator *toEnd,
241 Iterator fromEnd,
242 Iterator position,
243 size_type numElements,
244 const VALUE_TYPE& value,
245 ALLOCATOR allocator,
246 bsl::integral_constant<
247 int,
248 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>);
249 template <class ALLOCATOR>
250 static void
251 insertAndMoveToBack(Iterator *toEnd,
252 Iterator fromEnd,
253 Iterator position,
254 size_type numElements,
255 const VALUE_TYPE& value,
256 ALLOCATOR allocator,
257 bsl::integral_constant<
258 int,
259 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>);
260 template <class ALLOCATOR>
261 static void insertAndMoveToBack(
262 Iterator *toEnd,
263 Iterator fromEnd,
264 Iterator position,
265 size_type numElements,
266 const VALUE_TYPE& value,
267 ALLOCATOR allocator,
268 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
269
270 /// Insert the specified `numElements` in the range `[first .. last)` at
271 /// the specified `position`, by moving the elements in the range
272 /// `[position .. fromEnd)` forward by `numElements` position. Pass the
273 /// specified `allocator` to the copy constructor if appropriate. Load
274 /// into the specified `toEnd` an iterator to the end of the data after
275 /// insertion (i.e., `fromEnd + numElements`).
276 ///
277 /// \pre The behavior is undefined unless `fromEnd + numElements` is a valid iterator (i.e.,
278 /// the block pointer array holds enough room after the `fromEnd`
279 /// position to insert `numElements`).
280 template <class FWD_ITER, class SENTINEL, class ALLOCATOR>
281 static void insertAndMoveToBack(Iterator *toEnd,
282 Iterator fromEnd,
283 Iterator position,
284 FWD_ITER first,
285 SENTINEL last,
286 size_type numElements,
287 ALLOCATOR allocator);
288
289 /// Insert the specified move-insertable `value` at the specified
290 /// `position` by moving the elements in the range
291 /// `[position .. fromEnd)` forward by 1 position; pass the specified
292 /// `allocator` to the move constructor if appropriate. Load into the
293 /// specified `toEnd` an iterator one past the inserted element (i.e., `fromEnd + 1`).
294 ///
295 /// \pre The behavior is undefined unless `fromEnd + 1` is a
296 /// valid iterator (i.e., the block pointer array holds enough room
297 /// after the `fromEnd` position to insert 1 element).
298 template <class ALLOCATOR>
299 static void moveInsertAndMoveToBack(
300 Iterator *toEnd,
301 Iterator fromEnd,
302 Iterator position,
303 bslmf::MovableRef<VALUE_TYPE> value,
304 ALLOCATOR allocator);
305
306 /// Insert the specified move-insertable `value` at the specified
307 /// `position` by moving the elements in the range
308 /// `[position .. fromEnd)` forward by 1 position; pass the specified
309 /// `allocator` to the move constructor if appropriate. Load into the
310 /// specified `toEnd` an iterator one past the inserted element (i.e., `fromEnd + 1`).
311 ///
312 /// \pre The behavior is undefined unless `fromEnd + 1` is a
313 /// valid iterator (i.e., the block pointer array holds enough room after the `fromEnd` position to insert 1 element).
314 ///
315 /// \note Note that the
316 /// last argument is for removing overload ambiguities and is not used.
317 template <class ALLOCATOR>
318 static void moveInsertAndMoveToBack(
319 Iterator *toEnd,
320 Iterator fromEnd,
321 Iterator position,
322 bslmf::MovableRef<VALUE_TYPE> value,
323 ALLOCATOR allocator,
324 bsl::integral_constant<
325 int,
326 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>);
327 template <class ALLOCATOR>
328 static void moveInsertAndMoveToBack(
329 Iterator *toEnd,
330 Iterator fromEnd,
331 Iterator position,
332 bslmf::MovableRef<VALUE_TYPE> value,
333 ALLOCATOR allocator,
334 bsl::integral_constant<
335 int,
336 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>);
337 template <class ALLOCATOR>
338 static void moveInsertAndMoveToBack(
339 Iterator *toEnd,
340 Iterator fromEnd,
341 Iterator position,
342 bslmf::MovableRef<VALUE_TYPE> value,
343 ALLOCATOR allocator,
344 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
345
346 /// Insert the specified `numElements` copies of the specified `value`
347 /// at the specified `position`, by moving the elements in the range
348 /// `[fromBegin .. position)` backward by `numElements` position. Pass
349 /// the specified `allocator` to the copy constructor if appropriate.
350 /// Load into the specified `toBegin` an iterator to the beginning of
351 /// the data after insertion (i.e., `fromBegin - numElements`).
352 ///
353 /// \pre The behavior is undefined unless `fromBegin - numElements` is a valid
354 /// iterator (i.e., the block pointer array holds enough room before the
355 /// `fromBegin` position to insert `numElements`).
356 template <class ALLOCATOR>
357 static void insertAndMoveToFront(Iterator *toBegin,
358 Iterator fromBegin,
359 Iterator position,
360 size_type numElements,
361 const VALUE_TYPE& value,
362 ALLOCATOR allocator);
363
364 /// Insert the specified `numElements` copies of the specified `value`
365 /// at the specified `position`, by moving the elements in the range
366 /// `[fromBegin .. position)` backward by `numElements` position. Pass
367 /// the specified `allocator` to the copy constructor if appropriate.
368 /// Load into the specified `toBegin` an iterator to the beginning of
369 /// the data after insertion (i.e., `fromBegin - numElements`.
370 ///
371 /// \pre The behavior is undefined unless `fromBegin - numElements` is a valid
372 /// iterator (i.e., the block pointer array holds enough room before the `fromBegin` position to insert `numElements`).
373 ///
374 /// \note Note that the last
375 /// argument is for removing overload ambiguities and is not used.
376 template <class ALLOCATOR>
377 static void
378 insertAndMoveToFront(Iterator *toBegin,
379 Iterator fromBegin,
380 Iterator position,
381 size_type numElements,
382 const VALUE_TYPE& value,
383 ALLOCATOR allocator,
384 bsl::integral_constant<
385 int,
386 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>);
387 template <class ALLOCATOR>
388 static void
389 insertAndMoveToFront(Iterator *toBegin,
390 Iterator fromBegin,
391 Iterator position,
392 size_type numElements,
393 const VALUE_TYPE& value,
394 ALLOCATOR allocator,
395 bsl::integral_constant<
396 int,
397 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>);
398 template <class ALLOCATOR>
399 static void insertAndMoveToFront(
400 Iterator *toBegin,
401 Iterator fromBegin,
402 Iterator position,
403 size_type numElements,
404 const VALUE_TYPE& value,
405 ALLOCATOR allocator,
406 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
407
408 /// Insert the specified `numElements` in the range `[first .. last)` at
409 /// the specified `position`, by moving the elements in the range
410 /// `[fromBegin .. position)` backward by `numElements` position. Pass
411 /// the specified `allocator` to the copy constructor if appropriate.
412 /// Load into the specified `toBegin` an iterator to the end of the data
413 /// after insertion (i.e., `fromBegin - numElements`).
414 ///
415 /// \pre The behavior is undefined unless `fromBegin - numElements` is a valid iterator
416 /// (i.e., the block pointer array holds enough room before the
417 /// `fromBefore` position to insert `numElements`).
418 template <class FWD_ITER, class SENTINEL, class ALLOCATOR>
419 static void insertAndMoveToFront(Iterator *toBegin,
420 Iterator fromBegin,
421 Iterator position,
422 FWD_ITER first,
423 SENTINEL last,
424 size_type numElements,
425 ALLOCATOR allocator);
426
427 /// Insert the specified move-insertable `value` at the specified
428 /// `position` by moving the elements in the range
429 /// `[fromBegin .. position)` backward by 1 position; pass the specified
430 /// `allocator` to the move constructor if appropriate. Load into the
431 /// specified `toBegin` an iterator to the inserted element (i.e., `fromBegin - 1`).
432 ///
433 /// \pre The behavior is undefined unless
434 /// `fromBegin - 1` is a valid iterator (i.e., the block pointer array
435 /// holds enough room before the `fromBegin` position to insert 1
436 /// element).
437 template <class ALLOCATOR>
438 static void moveInsertAndMoveToFront(
439 Iterator *toBegin,
440 Iterator fromBegin,
441 Iterator position,
442 bslmf::MovableRef<VALUE_TYPE> value,
443 ALLOCATOR allocator);
444
445 /// Insert the specified move-insertable `value` at the specified
446 /// `position` by moving the elements in the range
447 /// `[fromBegin .. position)` backward by 1 position; pass the specified
448 /// `allocator` to the move constructor if appropriate. Load into the
449 /// specified `toBegin` an iterator to the inserted element (i.e., `fromBegin - 1`).
450 ///
451 /// \pre The behavior is undefined unless
452 /// `fromBegin - 1` is a valid iterator (i.e., the block pointer array
453 /// holds enough room before the `fromBegin` position to insert 1 element).
454 ///
455 /// \note Note that the last argument is for removing overload
456 /// ambiguities and is not used.
457 template <class ALLOCATOR>
458 static void moveInsertAndMoveToFront(
459 Iterator *toBegin,
460 Iterator fromBegin,
461 Iterator position,
462 bslmf::MovableRef<VALUE_TYPE> value,
463 ALLOCATOR allocator,
464 bsl::integral_constant<
465 int,
466 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>);
467 template <class ALLOCATOR>
468 static void moveInsertAndMoveToFront(
469 Iterator *toBegin,
470 Iterator fromBegin,
471 Iterator position,
472 bslmf::MovableRef<VALUE_TYPE> value,
473 ALLOCATOR allocator,
474 bsl::integral_constant<
475 int,
476 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>);
477 template <class ALLOCATOR>
478 static void moveInsertAndMoveToFront(
479 Iterator *toBegin,
480 Iterator fromBegin,
481 Iterator position,
482 bslmf::MovableRef<VALUE_TYPE> value,
483 ALLOCATOR allocator,
484 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
485
486#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
487// {{{ BEGIN GENERATED CODE
488// Command line: sim_cpp11_features.pl bslalg_dequeprimitives.h
489#ifndef BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT
490#define BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT 10
491#endif
492#ifndef BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A
493#define BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT
494#endif
495#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
496 template <class ALLOCATOR>
497 static void emplaceAndMoveToBack(Iterator *toEnd,
498 Iterator fromEnd,
499 Iterator position,
500 ALLOCATOR allocator);
501#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
502
503#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
504 template <class ALLOCATOR, class Args_01>
505 static void emplaceAndMoveToBack(Iterator *toEnd,
506 Iterator fromEnd,
507 Iterator position,
508 ALLOCATOR allocator,
509 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
510#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
511
512#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
513 template <class ALLOCATOR, class Args_01,
514 class Args_02>
515 static void emplaceAndMoveToBack(Iterator *toEnd,
516 Iterator fromEnd,
517 Iterator position,
518 ALLOCATOR allocator,
519 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
520 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
521#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
522
523#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
524 template <class ALLOCATOR, class Args_01,
525 class Args_02,
526 class Args_03>
527 static void emplaceAndMoveToBack(Iterator *toEnd,
528 Iterator fromEnd,
529 Iterator position,
530 ALLOCATOR allocator,
531 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
532 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
533 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
534#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
535
536#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
537 template <class ALLOCATOR, class Args_01,
538 class Args_02,
539 class Args_03,
540 class Args_04>
541 static void emplaceAndMoveToBack(Iterator *toEnd,
542 Iterator fromEnd,
543 Iterator position,
544 ALLOCATOR allocator,
545 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
546 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
547 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
548 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
549#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
550
551#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
552 template <class ALLOCATOR, class Args_01,
553 class Args_02,
554 class Args_03,
555 class Args_04,
556 class Args_05>
557 static void emplaceAndMoveToBack(Iterator *toEnd,
558 Iterator fromEnd,
559 Iterator position,
560 ALLOCATOR allocator,
561 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
562 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
563 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
564 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
565 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
566#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
567
568#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
569 template <class ALLOCATOR, class Args_01,
570 class Args_02,
571 class Args_03,
572 class Args_04,
573 class Args_05,
574 class Args_06>
575 static void emplaceAndMoveToBack(Iterator *toEnd,
576 Iterator fromEnd,
577 Iterator position,
578 ALLOCATOR allocator,
579 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
580 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
581 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
582 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
583 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
584 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
585#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
586
587#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
588 template <class ALLOCATOR, class Args_01,
589 class Args_02,
590 class Args_03,
591 class Args_04,
592 class Args_05,
593 class Args_06,
594 class Args_07>
595 static void emplaceAndMoveToBack(Iterator *toEnd,
596 Iterator fromEnd,
597 Iterator position,
598 ALLOCATOR allocator,
599 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
600 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
601 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
602 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
603 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
604 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
605 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
606#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
607
608#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
609 template <class ALLOCATOR, class Args_01,
610 class Args_02,
611 class Args_03,
612 class Args_04,
613 class Args_05,
614 class Args_06,
615 class Args_07,
616 class Args_08>
617 static void emplaceAndMoveToBack(Iterator *toEnd,
618 Iterator fromEnd,
619 Iterator position,
620 ALLOCATOR allocator,
621 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
622 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
623 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
624 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
625 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
626 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
627 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
628 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
629#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
630
631#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
632 template <class ALLOCATOR, class Args_01,
633 class Args_02,
634 class Args_03,
635 class Args_04,
636 class Args_05,
637 class Args_06,
638 class Args_07,
639 class Args_08,
640 class Args_09>
641 static void emplaceAndMoveToBack(Iterator *toEnd,
642 Iterator fromEnd,
643 Iterator position,
644 ALLOCATOR allocator,
645 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
646 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
647 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
648 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
649 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
650 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
651 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
652 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
653 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
654#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
655
656#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
657 template <class ALLOCATOR, class Args_01,
658 class Args_02,
659 class Args_03,
660 class Args_04,
661 class Args_05,
662 class Args_06,
663 class Args_07,
664 class Args_08,
665 class Args_09,
666 class Args_10>
667 static void emplaceAndMoveToBack(Iterator *toEnd,
668 Iterator fromEnd,
669 Iterator position,
670 ALLOCATOR allocator,
671 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
672 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
673 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
674 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
675 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
676 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
677 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
678 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
679 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
680 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
681#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
682
683
684#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
685 template <class ALLOCATOR>
686 static void emplaceAndMoveToBackDispatch(
687 Iterator *toEnd,
688 Iterator fromEnd,
689 Iterator position,
690 ALLOCATOR allocator,
691 bsl::integral_constant<int,
692 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>);
693#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
694
695#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
696 template <class ALLOCATOR, class Args_01>
697 static void emplaceAndMoveToBackDispatch(
698 Iterator *toEnd,
699 Iterator fromEnd,
700 Iterator position,
701 ALLOCATOR allocator,
702 bsl::integral_constant<int,
703 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
704 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
705#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
706
707#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
708 template <class ALLOCATOR, class Args_01,
709 class Args_02>
710 static void emplaceAndMoveToBackDispatch(
711 Iterator *toEnd,
712 Iterator fromEnd,
713 Iterator position,
714 ALLOCATOR allocator,
715 bsl::integral_constant<int,
716 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
717 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
718 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
719#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
720
721#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
722 template <class ALLOCATOR, class Args_01,
723 class Args_02,
724 class Args_03>
725 static void emplaceAndMoveToBackDispatch(
726 Iterator *toEnd,
727 Iterator fromEnd,
728 Iterator position,
729 ALLOCATOR allocator,
730 bsl::integral_constant<int,
731 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
732 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
733 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
734 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
735#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
736
737#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
738 template <class ALLOCATOR, class Args_01,
739 class Args_02,
740 class Args_03,
741 class Args_04>
742 static void emplaceAndMoveToBackDispatch(
743 Iterator *toEnd,
744 Iterator fromEnd,
745 Iterator position,
746 ALLOCATOR allocator,
747 bsl::integral_constant<int,
748 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
749 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
750 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
751 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
752 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
753#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
754
755#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
756 template <class ALLOCATOR, class Args_01,
757 class Args_02,
758 class Args_03,
759 class Args_04,
760 class Args_05>
761 static void emplaceAndMoveToBackDispatch(
762 Iterator *toEnd,
763 Iterator fromEnd,
764 Iterator position,
765 ALLOCATOR allocator,
766 bsl::integral_constant<int,
767 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
768 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
769 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
770 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
771 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
772 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
773#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
774
775#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
776 template <class ALLOCATOR, class Args_01,
777 class Args_02,
778 class Args_03,
779 class Args_04,
780 class Args_05,
781 class Args_06>
782 static void emplaceAndMoveToBackDispatch(
783 Iterator *toEnd,
784 Iterator fromEnd,
785 Iterator position,
786 ALLOCATOR allocator,
787 bsl::integral_constant<int,
788 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
789 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
790 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
791 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
792 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
793 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
794 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
795#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
796
797#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
798 template <class ALLOCATOR, class Args_01,
799 class Args_02,
800 class Args_03,
801 class Args_04,
802 class Args_05,
803 class Args_06,
804 class Args_07>
805 static void emplaceAndMoveToBackDispatch(
806 Iterator *toEnd,
807 Iterator fromEnd,
808 Iterator position,
809 ALLOCATOR allocator,
810 bsl::integral_constant<int,
811 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
812 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
813 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
814 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
815 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
816 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
817 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
818 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
819#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
820
821#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
822 template <class ALLOCATOR, class Args_01,
823 class Args_02,
824 class Args_03,
825 class Args_04,
826 class Args_05,
827 class Args_06,
828 class Args_07,
829 class Args_08>
830 static void emplaceAndMoveToBackDispatch(
831 Iterator *toEnd,
832 Iterator fromEnd,
833 Iterator position,
834 ALLOCATOR allocator,
835 bsl::integral_constant<int,
836 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
837 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
838 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
839 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
840 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
841 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
842 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
843 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
844 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
845#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
846
847#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
848 template <class ALLOCATOR, class Args_01,
849 class Args_02,
850 class Args_03,
851 class Args_04,
852 class Args_05,
853 class Args_06,
854 class Args_07,
855 class Args_08,
856 class Args_09>
857 static void emplaceAndMoveToBackDispatch(
858 Iterator *toEnd,
859 Iterator fromEnd,
860 Iterator position,
861 ALLOCATOR allocator,
862 bsl::integral_constant<int,
863 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
864 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
865 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
866 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
867 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
868 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
869 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
870 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
871 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
872 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
873#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
874
875#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
876 template <class ALLOCATOR, class Args_01,
877 class Args_02,
878 class Args_03,
879 class Args_04,
880 class Args_05,
881 class Args_06,
882 class Args_07,
883 class Args_08,
884 class Args_09,
885 class Args_10>
886 static void emplaceAndMoveToBackDispatch(
887 Iterator *toEnd,
888 Iterator fromEnd,
889 Iterator position,
890 ALLOCATOR allocator,
891 bsl::integral_constant<int,
892 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
893 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
894 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
895 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
896 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
897 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
898 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
899 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
900 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
901 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
902 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
903#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
904
905#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
906 template <class ALLOCATOR>
907 static void emplaceAndMoveToBackDispatch(
908 Iterator *toEnd,
909 Iterator fromEnd,
910 Iterator position,
911 ALLOCATOR allocator,
912 bsl::integral_constant<int,
913 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>);
914#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
915
916#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
917 template <class ALLOCATOR, class Args_01>
918 static void emplaceAndMoveToBackDispatch(
919 Iterator *toEnd,
920 Iterator fromEnd,
921 Iterator position,
922 ALLOCATOR allocator,
923 bsl::integral_constant<int,
924 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
925 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
926#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
927
928#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
929 template <class ALLOCATOR, class Args_01,
930 class Args_02>
931 static void emplaceAndMoveToBackDispatch(
932 Iterator *toEnd,
933 Iterator fromEnd,
934 Iterator position,
935 ALLOCATOR allocator,
936 bsl::integral_constant<int,
937 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
938 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
939 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
940#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
941
942#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
943 template <class ALLOCATOR, class Args_01,
944 class Args_02,
945 class Args_03>
946 static void emplaceAndMoveToBackDispatch(
947 Iterator *toEnd,
948 Iterator fromEnd,
949 Iterator position,
950 ALLOCATOR allocator,
951 bsl::integral_constant<int,
952 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
953 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
954 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
955 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
956#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
957
958#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
959 template <class ALLOCATOR, class Args_01,
960 class Args_02,
961 class Args_03,
962 class Args_04>
963 static void emplaceAndMoveToBackDispatch(
964 Iterator *toEnd,
965 Iterator fromEnd,
966 Iterator position,
967 ALLOCATOR allocator,
968 bsl::integral_constant<int,
969 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
970 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
971 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
972 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
973 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
974#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
975
976#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
977 template <class ALLOCATOR, class Args_01,
978 class Args_02,
979 class Args_03,
980 class Args_04,
981 class Args_05>
982 static void emplaceAndMoveToBackDispatch(
983 Iterator *toEnd,
984 Iterator fromEnd,
985 Iterator position,
986 ALLOCATOR allocator,
987 bsl::integral_constant<int,
988 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
989 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
990 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
991 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
992 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
993 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
994#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
995
996#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
997 template <class ALLOCATOR, class Args_01,
998 class Args_02,
999 class Args_03,
1000 class Args_04,
1001 class Args_05,
1002 class Args_06>
1003 static void emplaceAndMoveToBackDispatch(
1004 Iterator *toEnd,
1005 Iterator fromEnd,
1006 Iterator position,
1007 ALLOCATOR allocator,
1008 bsl::integral_constant<int,
1009 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1010 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1011 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1012 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1013 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1014 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1015 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
1016#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
1017
1018#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1019 template <class ALLOCATOR, class Args_01,
1020 class Args_02,
1021 class Args_03,
1022 class Args_04,
1023 class Args_05,
1024 class Args_06,
1025 class Args_07>
1026 static void emplaceAndMoveToBackDispatch(
1027 Iterator *toEnd,
1028 Iterator fromEnd,
1029 Iterator position,
1030 ALLOCATOR allocator,
1031 bsl::integral_constant<int,
1032 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1033 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1034 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1035 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1036 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1037 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1038 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1039 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
1040#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1041
1042#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1043 template <class ALLOCATOR, class Args_01,
1044 class Args_02,
1045 class Args_03,
1046 class Args_04,
1047 class Args_05,
1048 class Args_06,
1049 class Args_07,
1050 class Args_08>
1051 static void emplaceAndMoveToBackDispatch(
1052 Iterator *toEnd,
1053 Iterator fromEnd,
1054 Iterator position,
1055 ALLOCATOR allocator,
1056 bsl::integral_constant<int,
1057 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1058 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1059 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1060 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1061 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1062 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1063 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1064 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1065 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
1066#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1067
1068#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1069 template <class ALLOCATOR, class Args_01,
1070 class Args_02,
1071 class Args_03,
1072 class Args_04,
1073 class Args_05,
1074 class Args_06,
1075 class Args_07,
1076 class Args_08,
1077 class Args_09>
1078 static void emplaceAndMoveToBackDispatch(
1079 Iterator *toEnd,
1080 Iterator fromEnd,
1081 Iterator position,
1082 ALLOCATOR allocator,
1083 bsl::integral_constant<int,
1084 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1085 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1086 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1087 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1088 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1089 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1090 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1091 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1092 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1093 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
1094#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1095
1096#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1097 template <class ALLOCATOR, class Args_01,
1098 class Args_02,
1099 class Args_03,
1100 class Args_04,
1101 class Args_05,
1102 class Args_06,
1103 class Args_07,
1104 class Args_08,
1105 class Args_09,
1106 class Args_10>
1107 static void emplaceAndMoveToBackDispatch(
1108 Iterator *toEnd,
1109 Iterator fromEnd,
1110 Iterator position,
1111 ALLOCATOR allocator,
1112 bsl::integral_constant<int,
1113 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1114 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1115 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1116 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1117 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1118 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1119 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1120 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1121 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1122 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1123 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
1124#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1125
1126#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1127 template <class ALLOCATOR>
1128 static void emplaceAndMoveToBackDispatch(
1129 Iterator *toEnd,
1130 Iterator fromEnd,
1131 Iterator position,
1132 ALLOCATOR allocator,
1133 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
1134#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1135
1136#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1137 template <class ALLOCATOR, class Args_01>
1138 static void emplaceAndMoveToBackDispatch(
1139 Iterator *toEnd,
1140 Iterator fromEnd,
1141 Iterator position,
1142 ALLOCATOR allocator,
1143 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1144 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
1145#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1146
1147#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
1148 template <class ALLOCATOR, class Args_01,
1149 class Args_02>
1150 static void emplaceAndMoveToBackDispatch(
1151 Iterator *toEnd,
1152 Iterator fromEnd,
1153 Iterator position,
1154 ALLOCATOR allocator,
1155 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1156 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1157 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
1158#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
1159
1160#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
1161 template <class ALLOCATOR, class Args_01,
1162 class Args_02,
1163 class Args_03>
1164 static void emplaceAndMoveToBackDispatch(
1165 Iterator *toEnd,
1166 Iterator fromEnd,
1167 Iterator position,
1168 ALLOCATOR allocator,
1169 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1170 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1171 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1172 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
1173#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
1174
1175#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
1176 template <class ALLOCATOR, class Args_01,
1177 class Args_02,
1178 class Args_03,
1179 class Args_04>
1180 static void emplaceAndMoveToBackDispatch(
1181 Iterator *toEnd,
1182 Iterator fromEnd,
1183 Iterator position,
1184 ALLOCATOR allocator,
1185 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1186 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1187 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1188 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1189 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
1190#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
1191
1192#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
1193 template <class ALLOCATOR, class Args_01,
1194 class Args_02,
1195 class Args_03,
1196 class Args_04,
1197 class Args_05>
1198 static void emplaceAndMoveToBackDispatch(
1199 Iterator *toEnd,
1200 Iterator fromEnd,
1201 Iterator position,
1202 ALLOCATOR allocator,
1203 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1204 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1205 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1206 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1207 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1208 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
1209#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
1210
1211#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
1212 template <class ALLOCATOR, class Args_01,
1213 class Args_02,
1214 class Args_03,
1215 class Args_04,
1216 class Args_05,
1217 class Args_06>
1218 static void emplaceAndMoveToBackDispatch(
1219 Iterator *toEnd,
1220 Iterator fromEnd,
1221 Iterator position,
1222 ALLOCATOR allocator,
1223 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1224 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1225 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1226 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1227 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1228 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1229 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
1230#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
1231
1232#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1233 template <class ALLOCATOR, class Args_01,
1234 class Args_02,
1235 class Args_03,
1236 class Args_04,
1237 class Args_05,
1238 class Args_06,
1239 class Args_07>
1240 static void emplaceAndMoveToBackDispatch(
1241 Iterator *toEnd,
1242 Iterator fromEnd,
1243 Iterator position,
1244 ALLOCATOR allocator,
1245 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1246 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1247 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1248 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1249 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1250 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1251 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1252 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
1253#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1254
1255#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1256 template <class ALLOCATOR, class Args_01,
1257 class Args_02,
1258 class Args_03,
1259 class Args_04,
1260 class Args_05,
1261 class Args_06,
1262 class Args_07,
1263 class Args_08>
1264 static void emplaceAndMoveToBackDispatch(
1265 Iterator *toEnd,
1266 Iterator fromEnd,
1267 Iterator position,
1268 ALLOCATOR allocator,
1269 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1270 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1271 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1272 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1273 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1274 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1275 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1276 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1277 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
1278#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1279
1280#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1281 template <class ALLOCATOR, class Args_01,
1282 class Args_02,
1283 class Args_03,
1284 class Args_04,
1285 class Args_05,
1286 class Args_06,
1287 class Args_07,
1288 class Args_08,
1289 class Args_09>
1290 static void emplaceAndMoveToBackDispatch(
1291 Iterator *toEnd,
1292 Iterator fromEnd,
1293 Iterator position,
1294 ALLOCATOR allocator,
1295 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1296 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1297 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1298 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1299 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1300 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1301 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1302 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1303 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1304 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
1305#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1306
1307#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1308 template <class ALLOCATOR, class Args_01,
1309 class Args_02,
1310 class Args_03,
1311 class Args_04,
1312 class Args_05,
1313 class Args_06,
1314 class Args_07,
1315 class Args_08,
1316 class Args_09,
1317 class Args_10>
1318 static void emplaceAndMoveToBackDispatch(
1319 Iterator *toEnd,
1320 Iterator fromEnd,
1321 Iterator position,
1322 ALLOCATOR allocator,
1323 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1324 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1325 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1326 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1327 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1328 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1329 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1330 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1331 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1332 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1333 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
1334#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1335
1336
1337#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1338 template <class ALLOCATOR>
1339 static void emplaceAndMoveToFront(Iterator *toBegin,
1340 Iterator fromBegin,
1341 Iterator position,
1342 ALLOCATOR allocator);
1343#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1344
1345#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1346 template <class ALLOCATOR, class Args_01>
1347 static void emplaceAndMoveToFront(Iterator *toBegin,
1348 Iterator fromBegin,
1349 Iterator position,
1350 ALLOCATOR allocator,
1351 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
1352#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1353
1354#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
1355 template <class ALLOCATOR, class Args_01,
1356 class Args_02>
1357 static void emplaceAndMoveToFront(Iterator *toBegin,
1358 Iterator fromBegin,
1359 Iterator position,
1360 ALLOCATOR allocator,
1361 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1362 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
1363#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
1364
1365#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
1366 template <class ALLOCATOR, class Args_01,
1367 class Args_02,
1368 class Args_03>
1369 static void emplaceAndMoveToFront(Iterator *toBegin,
1370 Iterator fromBegin,
1371 Iterator position,
1372 ALLOCATOR allocator,
1373 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1374 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1375 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
1376#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
1377
1378#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
1379 template <class ALLOCATOR, class Args_01,
1380 class Args_02,
1381 class Args_03,
1382 class Args_04>
1383 static void emplaceAndMoveToFront(Iterator *toBegin,
1384 Iterator fromBegin,
1385 Iterator position,
1386 ALLOCATOR allocator,
1387 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1388 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1389 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1390 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
1391#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
1392
1393#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
1394 template <class ALLOCATOR, class Args_01,
1395 class Args_02,
1396 class Args_03,
1397 class Args_04,
1398 class Args_05>
1399 static void emplaceAndMoveToFront(Iterator *toBegin,
1400 Iterator fromBegin,
1401 Iterator position,
1402 ALLOCATOR allocator,
1403 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1404 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1405 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1406 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1407 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
1408#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
1409
1410#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
1411 template <class ALLOCATOR, class Args_01,
1412 class Args_02,
1413 class Args_03,
1414 class Args_04,
1415 class Args_05,
1416 class Args_06>
1417 static void emplaceAndMoveToFront(Iterator *toBegin,
1418 Iterator fromBegin,
1419 Iterator position,
1420 ALLOCATOR allocator,
1421 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1422 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1423 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1424 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1425 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1426 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
1427#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
1428
1429#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1430 template <class ALLOCATOR, class Args_01,
1431 class Args_02,
1432 class Args_03,
1433 class Args_04,
1434 class Args_05,
1435 class Args_06,
1436 class Args_07>
1437 static void emplaceAndMoveToFront(Iterator *toBegin,
1438 Iterator fromBegin,
1439 Iterator position,
1440 ALLOCATOR allocator,
1441 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1442 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1443 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1444 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1445 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1446 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1447 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
1448#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1449
1450#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1451 template <class ALLOCATOR, class Args_01,
1452 class Args_02,
1453 class Args_03,
1454 class Args_04,
1455 class Args_05,
1456 class Args_06,
1457 class Args_07,
1458 class Args_08>
1459 static void emplaceAndMoveToFront(Iterator *toBegin,
1460 Iterator fromBegin,
1461 Iterator position,
1462 ALLOCATOR allocator,
1463 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1464 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1465 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1466 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1467 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1468 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1469 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1470 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
1471#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1472
1473#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1474 template <class ALLOCATOR, class Args_01,
1475 class Args_02,
1476 class Args_03,
1477 class Args_04,
1478 class Args_05,
1479 class Args_06,
1480 class Args_07,
1481 class Args_08,
1482 class Args_09>
1483 static void emplaceAndMoveToFront(Iterator *toBegin,
1484 Iterator fromBegin,
1485 Iterator position,
1486 ALLOCATOR allocator,
1487 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1488 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1489 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1490 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1491 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1492 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1493 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1494 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1495 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
1496#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1497
1498#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1499 template <class ALLOCATOR, class Args_01,
1500 class Args_02,
1501 class Args_03,
1502 class Args_04,
1503 class Args_05,
1504 class Args_06,
1505 class Args_07,
1506 class Args_08,
1507 class Args_09,
1508 class Args_10>
1509 static void emplaceAndMoveToFront(Iterator *toBegin,
1510 Iterator fromBegin,
1511 Iterator position,
1512 ALLOCATOR allocator,
1513 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1514 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1515 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1516 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1517 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1518 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1519 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1520 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1521 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1522 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
1523#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1524
1525
1526#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1527 template <class ALLOCATOR>
1528 static void emplaceAndMoveToFrontDispatch(
1529 Iterator *toBegin,
1530 Iterator fromBegin,
1531 Iterator position,
1532 ALLOCATOR allocator,
1533 bsl::integral_constant<int,
1534 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>);
1535#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1536
1537#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1538 template <class ALLOCATOR, class Args_01>
1539 static void emplaceAndMoveToFrontDispatch(
1540 Iterator *toBegin,
1541 Iterator fromBegin,
1542 Iterator position,
1543 ALLOCATOR allocator,
1544 bsl::integral_constant<int,
1545 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1546 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
1547#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1548
1549#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
1550 template <class ALLOCATOR, class Args_01,
1551 class Args_02>
1552 static void emplaceAndMoveToFrontDispatch(
1553 Iterator *toBegin,
1554 Iterator fromBegin,
1555 Iterator position,
1556 ALLOCATOR allocator,
1557 bsl::integral_constant<int,
1558 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1559 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1560 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
1561#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
1562
1563#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
1564 template <class ALLOCATOR, class Args_01,
1565 class Args_02,
1566 class Args_03>
1567 static void emplaceAndMoveToFrontDispatch(
1568 Iterator *toBegin,
1569 Iterator fromBegin,
1570 Iterator position,
1571 ALLOCATOR allocator,
1572 bsl::integral_constant<int,
1573 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1574 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1575 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1576 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
1577#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
1578
1579#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
1580 template <class ALLOCATOR, class Args_01,
1581 class Args_02,
1582 class Args_03,
1583 class Args_04>
1584 static void emplaceAndMoveToFrontDispatch(
1585 Iterator *toBegin,
1586 Iterator fromBegin,
1587 Iterator position,
1588 ALLOCATOR allocator,
1589 bsl::integral_constant<int,
1590 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1591 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1592 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1593 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1594 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
1595#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
1596
1597#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
1598 template <class ALLOCATOR, class Args_01,
1599 class Args_02,
1600 class Args_03,
1601 class Args_04,
1602 class Args_05>
1603 static void emplaceAndMoveToFrontDispatch(
1604 Iterator *toBegin,
1605 Iterator fromBegin,
1606 Iterator position,
1607 ALLOCATOR allocator,
1608 bsl::integral_constant<int,
1609 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1610 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1611 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1612 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1613 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1614 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
1615#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
1616
1617#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
1618 template <class ALLOCATOR, class Args_01,
1619 class Args_02,
1620 class Args_03,
1621 class Args_04,
1622 class Args_05,
1623 class Args_06>
1624 static void emplaceAndMoveToFrontDispatch(
1625 Iterator *toBegin,
1626 Iterator fromBegin,
1627 Iterator position,
1628 ALLOCATOR allocator,
1629 bsl::integral_constant<int,
1630 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1631 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1632 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1633 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1634 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1635 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1636 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
1637#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
1638
1639#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1640 template <class ALLOCATOR, class Args_01,
1641 class Args_02,
1642 class Args_03,
1643 class Args_04,
1644 class Args_05,
1645 class Args_06,
1646 class Args_07>
1647 static void emplaceAndMoveToFrontDispatch(
1648 Iterator *toBegin,
1649 Iterator fromBegin,
1650 Iterator position,
1651 ALLOCATOR allocator,
1652 bsl::integral_constant<int,
1653 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1654 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1655 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1656 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1657 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1658 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1659 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1660 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
1661#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1662
1663#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1664 template <class ALLOCATOR, class Args_01,
1665 class Args_02,
1666 class Args_03,
1667 class Args_04,
1668 class Args_05,
1669 class Args_06,
1670 class Args_07,
1671 class Args_08>
1672 static void emplaceAndMoveToFrontDispatch(
1673 Iterator *toBegin,
1674 Iterator fromBegin,
1675 Iterator position,
1676 ALLOCATOR allocator,
1677 bsl::integral_constant<int,
1678 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1679 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1680 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1681 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1682 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1683 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1684 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1685 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1686 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
1687#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1688
1689#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1690 template <class ALLOCATOR, class Args_01,
1691 class Args_02,
1692 class Args_03,
1693 class Args_04,
1694 class Args_05,
1695 class Args_06,
1696 class Args_07,
1697 class Args_08,
1698 class Args_09>
1699 static void emplaceAndMoveToFrontDispatch(
1700 Iterator *toBegin,
1701 Iterator fromBegin,
1702 Iterator position,
1703 ALLOCATOR allocator,
1704 bsl::integral_constant<int,
1705 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1706 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1707 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1708 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1709 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1710 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1711 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1712 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1713 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1714 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
1715#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1716
1717#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1718 template <class ALLOCATOR, class Args_01,
1719 class Args_02,
1720 class Args_03,
1721 class Args_04,
1722 class Args_05,
1723 class Args_06,
1724 class Args_07,
1725 class Args_08,
1726 class Args_09,
1727 class Args_10>
1728 static void emplaceAndMoveToFrontDispatch(
1729 Iterator *toBegin,
1730 Iterator fromBegin,
1731 Iterator position,
1732 ALLOCATOR allocator,
1733 bsl::integral_constant<int,
1734 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
1735 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1736 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1737 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1738 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1739 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1740 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1741 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1742 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1743 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1744 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
1745#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1746
1747#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1748 template <class ALLOCATOR>
1749 static void emplaceAndMoveToFrontDispatch(
1750 Iterator *toBegin,
1751 Iterator fromBegin,
1752 Iterator position,
1753 ALLOCATOR allocator,
1754 bsl::integral_constant<int,
1755 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>);
1756#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1757
1758#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1759 template <class ALLOCATOR, class Args_01>
1760 static void emplaceAndMoveToFrontDispatch(
1761 Iterator *toBegin,
1762 Iterator fromBegin,
1763 Iterator position,
1764 ALLOCATOR allocator,
1765 bsl::integral_constant<int,
1766 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1767 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
1768#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1769
1770#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
1771 template <class ALLOCATOR, class Args_01,
1772 class Args_02>
1773 static void emplaceAndMoveToFrontDispatch(
1774 Iterator *toBegin,
1775 Iterator fromBegin,
1776 Iterator position,
1777 ALLOCATOR allocator,
1778 bsl::integral_constant<int,
1779 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1780 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1781 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
1782#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
1783
1784#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
1785 template <class ALLOCATOR, class Args_01,
1786 class Args_02,
1787 class Args_03>
1788 static void emplaceAndMoveToFrontDispatch(
1789 Iterator *toBegin,
1790 Iterator fromBegin,
1791 Iterator position,
1792 ALLOCATOR allocator,
1793 bsl::integral_constant<int,
1794 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1795 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1796 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1797 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
1798#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
1799
1800#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
1801 template <class ALLOCATOR, class Args_01,
1802 class Args_02,
1803 class Args_03,
1804 class Args_04>
1805 static void emplaceAndMoveToFrontDispatch(
1806 Iterator *toBegin,
1807 Iterator fromBegin,
1808 Iterator position,
1809 ALLOCATOR allocator,
1810 bsl::integral_constant<int,
1811 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1812 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1813 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1814 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1815 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
1816#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
1817
1818#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
1819 template <class ALLOCATOR, class Args_01,
1820 class Args_02,
1821 class Args_03,
1822 class Args_04,
1823 class Args_05>
1824 static void emplaceAndMoveToFrontDispatch(
1825 Iterator *toBegin,
1826 Iterator fromBegin,
1827 Iterator position,
1828 ALLOCATOR allocator,
1829 bsl::integral_constant<int,
1830 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1831 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1832 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1833 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1834 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1835 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
1836#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
1837
1838#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
1839 template <class ALLOCATOR, class Args_01,
1840 class Args_02,
1841 class Args_03,
1842 class Args_04,
1843 class Args_05,
1844 class Args_06>
1845 static void emplaceAndMoveToFrontDispatch(
1846 Iterator *toBegin,
1847 Iterator fromBegin,
1848 Iterator position,
1849 ALLOCATOR allocator,
1850 bsl::integral_constant<int,
1851 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1852 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1853 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1854 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1855 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1856 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1857 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
1858#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
1859
1860#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1861 template <class ALLOCATOR, class Args_01,
1862 class Args_02,
1863 class Args_03,
1864 class Args_04,
1865 class Args_05,
1866 class Args_06,
1867 class Args_07>
1868 static void emplaceAndMoveToFrontDispatch(
1869 Iterator *toBegin,
1870 Iterator fromBegin,
1871 Iterator position,
1872 ALLOCATOR allocator,
1873 bsl::integral_constant<int,
1874 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1875 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1876 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1877 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1878 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1879 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1880 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1881 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
1882#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
1883
1884#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1885 template <class ALLOCATOR, class Args_01,
1886 class Args_02,
1887 class Args_03,
1888 class Args_04,
1889 class Args_05,
1890 class Args_06,
1891 class Args_07,
1892 class Args_08>
1893 static void emplaceAndMoveToFrontDispatch(
1894 Iterator *toBegin,
1895 Iterator fromBegin,
1896 Iterator position,
1897 ALLOCATOR allocator,
1898 bsl::integral_constant<int,
1899 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1900 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1901 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1902 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1903 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1904 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1905 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1906 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1907 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
1908#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
1909
1910#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1911 template <class ALLOCATOR, class Args_01,
1912 class Args_02,
1913 class Args_03,
1914 class Args_04,
1915 class Args_05,
1916 class Args_06,
1917 class Args_07,
1918 class Args_08,
1919 class Args_09>
1920 static void emplaceAndMoveToFrontDispatch(
1921 Iterator *toBegin,
1922 Iterator fromBegin,
1923 Iterator position,
1924 ALLOCATOR allocator,
1925 bsl::integral_constant<int,
1926 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1927 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1928 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1929 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1930 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1931 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1932 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1933 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1934 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1935 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
1936#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
1937
1938#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1939 template <class ALLOCATOR, class Args_01,
1940 class Args_02,
1941 class Args_03,
1942 class Args_04,
1943 class Args_05,
1944 class Args_06,
1945 class Args_07,
1946 class Args_08,
1947 class Args_09,
1948 class Args_10>
1949 static void emplaceAndMoveToFrontDispatch(
1950 Iterator *toBegin,
1951 Iterator fromBegin,
1952 Iterator position,
1953 ALLOCATOR allocator,
1954 bsl::integral_constant<int,
1955 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
1956 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1957 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1958 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1959 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1960 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1961 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1962 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1963 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1964 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1965 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
1966#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
1967
1968#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1969 template <class ALLOCATOR>
1970 static void emplaceAndMoveToFrontDispatch(
1971 Iterator *toBegin,
1972 Iterator fromBegin,
1973 Iterator position,
1974 ALLOCATOR allocator,
1975 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
1976#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 0
1977
1978#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1979 template <class ALLOCATOR, class Args_01>
1980 static void emplaceAndMoveToFrontDispatch(
1981 Iterator *toBegin,
1982 Iterator fromBegin,
1983 Iterator position,
1984 ALLOCATOR allocator,
1985 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1986 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
1987#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 1
1988
1989#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
1990 template <class ALLOCATOR, class Args_01,
1991 class Args_02>
1992 static void emplaceAndMoveToFrontDispatch(
1993 Iterator *toBegin,
1994 Iterator fromBegin,
1995 Iterator position,
1996 ALLOCATOR allocator,
1997 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
1998 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1999 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
2000#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 2
2001
2002#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
2003 template <class ALLOCATOR, class Args_01,
2004 class Args_02,
2005 class Args_03>
2006 static void emplaceAndMoveToFrontDispatch(
2007 Iterator *toBegin,
2008 Iterator fromBegin,
2009 Iterator position,
2010 ALLOCATOR allocator,
2011 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2012 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2013 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2014 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
2015#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 3
2016
2017#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
2018 template <class ALLOCATOR, class Args_01,
2019 class Args_02,
2020 class Args_03,
2021 class Args_04>
2022 static void emplaceAndMoveToFrontDispatch(
2023 Iterator *toBegin,
2024 Iterator fromBegin,
2025 Iterator position,
2026 ALLOCATOR allocator,
2027 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2028 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2029 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2030 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2031 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
2032#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 4
2033
2034#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
2035 template <class ALLOCATOR, class Args_01,
2036 class Args_02,
2037 class Args_03,
2038 class Args_04,
2039 class Args_05>
2040 static void emplaceAndMoveToFrontDispatch(
2041 Iterator *toBegin,
2042 Iterator fromBegin,
2043 Iterator position,
2044 ALLOCATOR allocator,
2045 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2046 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2047 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2048 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2049 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2050 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
2051#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 5
2052
2053#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
2054 template <class ALLOCATOR, class Args_01,
2055 class Args_02,
2056 class Args_03,
2057 class Args_04,
2058 class Args_05,
2059 class Args_06>
2060 static void emplaceAndMoveToFrontDispatch(
2061 Iterator *toBegin,
2062 Iterator fromBegin,
2063 Iterator position,
2064 ALLOCATOR allocator,
2065 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2066 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2067 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2068 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2069 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2070 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2071 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
2072#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 6
2073
2074#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
2075 template <class ALLOCATOR, class Args_01,
2076 class Args_02,
2077 class Args_03,
2078 class Args_04,
2079 class Args_05,
2080 class Args_06,
2081 class Args_07>
2082 static void emplaceAndMoveToFrontDispatch(
2083 Iterator *toBegin,
2084 Iterator fromBegin,
2085 Iterator position,
2086 ALLOCATOR allocator,
2087 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2088 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2089 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2090 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2091 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2092 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2093 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2094 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
2095#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 7
2096
2097#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
2098 template <class ALLOCATOR, class Args_01,
2099 class Args_02,
2100 class Args_03,
2101 class Args_04,
2102 class Args_05,
2103 class Args_06,
2104 class Args_07,
2105 class Args_08>
2106 static void emplaceAndMoveToFrontDispatch(
2107 Iterator *toBegin,
2108 Iterator fromBegin,
2109 Iterator position,
2110 ALLOCATOR allocator,
2111 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2112 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2113 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2114 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2115 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2116 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2117 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2118 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2119 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
2120#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 8
2121
2122#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
2123 template <class ALLOCATOR, class Args_01,
2124 class Args_02,
2125 class Args_03,
2126 class Args_04,
2127 class Args_05,
2128 class Args_06,
2129 class Args_07,
2130 class Args_08,
2131 class Args_09>
2132 static void emplaceAndMoveToFrontDispatch(
2133 Iterator *toBegin,
2134 Iterator fromBegin,
2135 Iterator position,
2136 ALLOCATOR allocator,
2137 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2138 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2139 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2140 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2141 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2142 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2143 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2144 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2145 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2146 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
2147#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 9
2148
2149#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
2150 template <class ALLOCATOR, class Args_01,
2151 class Args_02,
2152 class Args_03,
2153 class Args_04,
2154 class Args_05,
2155 class Args_06,
2156 class Args_07,
2157 class Args_08,
2158 class Args_09,
2159 class Args_10>
2160 static void emplaceAndMoveToFrontDispatch(
2161 Iterator *toBegin,
2162 Iterator fromBegin,
2163 Iterator position,
2164 ALLOCATOR allocator,
2165 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2166 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2167 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2168 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2169 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2170 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2171 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2172 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2173 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2174 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2175 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
2176#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_A >= 10
2177
2178#else
2179// The generated code below is a workaround for the absence of perfect
2180// forwarding in some compilers.
2181 template <class ALLOCATOR, class... Args>
2182 static void emplaceAndMoveToBack(Iterator *toEnd,
2183 Iterator fromEnd,
2184 Iterator position,
2185 ALLOCATOR allocator,
2186 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
2187
2188 template <class ALLOCATOR, class... Args>
2189 static void emplaceAndMoveToBackDispatch(
2190 Iterator *toEnd,
2191 Iterator fromEnd,
2192 Iterator position,
2193 ALLOCATOR allocator,
2194 bsl::integral_constant<int,
2195 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
2196 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
2197 template <class ALLOCATOR, class... Args>
2198 static void emplaceAndMoveToBackDispatch(
2199 Iterator *toEnd,
2200 Iterator fromEnd,
2201 Iterator position,
2202 ALLOCATOR allocator,
2203 bsl::integral_constant<int,
2204 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
2205 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
2206 template <class ALLOCATOR, class... Args>
2207 static void emplaceAndMoveToBackDispatch(
2208 Iterator *toEnd,
2209 Iterator fromEnd,
2210 Iterator position,
2211 ALLOCATOR allocator,
2212 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2213 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
2214
2215 template <class ALLOCATOR, class... Args>
2216 static void emplaceAndMoveToFront(Iterator *toBegin,
2217 Iterator fromBegin,
2218 Iterator position,
2219 ALLOCATOR allocator,
2220 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
2221
2222 template <class ALLOCATOR, class... Args>
2223 static void emplaceAndMoveToFrontDispatch(
2224 Iterator *toBegin,
2225 Iterator fromBegin,
2226 Iterator position,
2227 ALLOCATOR allocator,
2228 bsl::integral_constant<int,
2229 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
2230 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
2231 template <class ALLOCATOR, class... Args>
2232 static void emplaceAndMoveToFrontDispatch(
2233 Iterator *toBegin,
2234 Iterator fromBegin,
2235 Iterator position,
2236 ALLOCATOR allocator,
2237 bsl::integral_constant<int,
2238 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
2239 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
2240 template <class ALLOCATOR, class... Args>
2241 static void emplaceAndMoveToFrontDispatch(
2242 Iterator *toBegin,
2243 Iterator fromBegin,
2244 Iterator position,
2245 ALLOCATOR allocator,
2246 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
2247 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
2248// }}} END GENERATED CODE
2249#endif
2250
2251 /// Move the specified `numElements` from the specified `source` to the
2252 /// specified `destination` using `std::memmove`. Also load into
2253 /// `destination` the value `destination - numElements` and `source` the value `source - numElements`.
2254 ///
2255 /// \pre The behavior is undefined unless
2256 /// `destination >= source`.
2257 static void moveBack(Iterator *destination,
2258 Iterator *source,
2259 size_type numElements);
2260
2261 /// Move the specified `numElements` from the specified `source` to the
2262 /// specified `destination` using `std::memmove`. Also load into
2263 /// `destination` the value `destination + numElements` and `source` the the value `source + numElements`.
2264 ///
2265 /// \pre The behavior is undefined unless
2266 /// `destination <= source`.
2267 static void moveFront(Iterator *destination,
2268 Iterator *source,
2269 size_type numElements);
2270
2271 /// Append the specified `numElements` copies of the specified `value`
2272 /// to the deque ending at the specified `fromEnd` iterator, passing the
2273 /// specified `allocator` through to the new elements, and load into the
2274 /// specified `toEnd` an iterator pointing to the end of the data after
2275 /// appending (i.e., `fromEnd + numElements`).
2276 ///
2277 /// \pre The behavior is undefined unless `fromEnd + numElements` is a valid iterator (i.e.,
2278 /// the block pointer array holds enough room after the `fromEnd`
2279 /// position to insert `numElements`).
2280 template <class ALLOCATOR>
2281 static void uninitializedFillNBack(Iterator *toEnd,
2282 Iterator fromEnd,
2283 size_type numElements,
2284 const VALUE_TYPE& value,
2285 ALLOCATOR allocator);
2286
2287 /// Prepend the specified `numElements` copies of the specified `value`
2288 /// to the deque starting at the specified `fromBegin` iterator, passing
2289 /// the specified `allocator` through to the new elements, and load into
2290 /// the specified `toBegin` an iterator pointing to the end of the data
2291 /// after prepending, i.e., `fromBegin - numElements`.
2292 ///
2293 /// \pre The behavior is undefined unless `fromBegin - numElements` is a valid iterator
2294 /// (i.e., the block pointer array holds enough room before the
2295 /// `fromBegin` position to insert `numElements`).
2296 template <class ALLOCATOR>
2297 static void uninitializedFillNFront(Iterator *toBegin,
2298 Iterator fromBegin,
2299 size_type numElements,
2300 const VALUE_TYPE& value,
2301 ALLOCATOR allocator);
2302
2303 /// Append the specified `numElements` value-initialized objects to the
2304 /// deque ending at the specified `fromEnd` iterator, passing the
2305 /// specified `allocator` through to the new elements, and load into the
2306 /// specified `toEnd` an iterator pointing to the end of the data after
2307 /// appending (i.e., `fromEnd + numElements`).
2308 ///
2309 /// \pre The behavior is undefined unless `fromEnd + numElements` is a valid iterator (i.e.,
2310 /// the block pointer array holds enough room after the `fromEnd`
2311 /// position to insert `numElements`).
2312 template <class ALLOCATOR>
2313 static void valueInititalizeN(Iterator *toEnd,
2314 Iterator fromEnd,
2315 size_type numElements,
2316 ALLOCATOR allocator);
2317};
2318
2319// PARTIAL SPECIALIZATION
2320
2321/// This is a partial specialization of `DequePrimitives` for the case when
2322/// there is a single element per block.
2323template <class VALUE_TYPE>
2324struct DequePrimitives<VALUE_TYPE, 1> {
2325
2326 // PUBLIC TYPES
2327 typedef std::size_t size_type;
2328 typedef DequeImpUtil<VALUE_TYPE, 1> ImpUtil;
2329 typedef DequeIterator<VALUE_TYPE, 1> Iterator;
2330
2331 // CLASS METHODS
2332 template <class ALLOCATOR>
2333 static void destruct(Iterator begin, Iterator end, ALLOCATOR allocator);
2334
2335 template <class ALLOCATOR>
2336 static Iterator erase(Iterator *toBegin,
2337 Iterator *toEnd,
2338 Iterator fromBegin,
2339 Iterator first,
2340 Iterator last,
2341 Iterator fromEnd,
2342 ALLOCATOR allocator);
2343
2344 template <class ALLOCATOR>
2345 static void insertAndMoveToBack(Iterator *toEnd,
2346 Iterator fromEnd,
2347 Iterator position,
2348 size_type numElements,
2349 const VALUE_TYPE& value,
2350 ALLOCATOR allocator);
2351
2352 template <class FWD_ITER, class SENTINEL, class ALLOCATOR>
2353 static void insertAndMoveToBack(Iterator *toEnd,
2354 Iterator fromEnd,
2355 Iterator position,
2356 FWD_ITER first,
2357 SENTINEL last,
2358 size_type numElements,
2359 ALLOCATOR allocator);
2360
2361 template <class ALLOCATOR>
2362 static void insertAndMoveToFront(Iterator *toBegin,
2363 Iterator fromBegin,
2364 Iterator position,
2365 size_type numElements,
2366 const VALUE_TYPE& value,
2367 ALLOCATOR allocator);
2368
2369 template <class FWD_ITER, class SENTINEL, class ALLOCATOR>
2370 static void insertAndMoveToFront(Iterator *toBegin,
2371 Iterator fromBegin,
2372 Iterator position,
2373 FWD_ITER first,
2374 SENTINEL last,
2375 size_type numElements,
2376 ALLOCATOR allocator);
2377
2378 template <class ALLOCATOR>
2379 static void uninitializedFillNBack(Iterator *toEnd,
2380 Iterator fromEnd,
2381 size_type numElements,
2382 const VALUE_TYPE& value,
2383 ALLOCATOR allocator);
2384 template <class ALLOCATOR>
2385 static void uninitializedFillNBack(
2386 Iterator *toEnd,
2387 Iterator fromEnd,
2388 size_type numElements,
2389 const VALUE_TYPE& value,
2390 ALLOCATOR allocator,
2391 bsl::integral_constant<int,
2392 BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
2393 template <class ALLOCATOR>
2394 static void uninitializedFillNBack(
2395 Iterator *toEnd,
2396 Iterator fromEnd,
2397 size_type numElements,
2398 const VALUE_TYPE& value,
2399 ALLOCATOR allocator,
2400 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS>);
2401
2402 template <class ALLOCATOR>
2403 static void uninitializedFillNFront(Iterator *toBegin,
2404 Iterator fromBegin,
2405 size_type numElements,
2406 const VALUE_TYPE& value,
2407 ALLOCATOR allocator);
2408 template <class ALLOCATOR>
2409 static void uninitializedFillNFront(
2410 Iterator *toBegin,
2411 Iterator fromBegin,
2412 size_type numElements,
2413 const VALUE_TYPE& value,
2414 ALLOCATOR allocator,
2415 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
2416 template <class ALLOCATOR>
2417 static void uninitializedFillNFront(
2418 Iterator *toBegin,
2419 Iterator fromBegin,
2420 size_type numElements,
2421 const VALUE_TYPE& value,
2422 ALLOCATOR allocator,
2423 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS>);
2424
2425 template <class ALLOCATOR>
2426 static void valueInititalizeN(Iterator *toEnd,
2427 Iterator fromEnd,
2428 size_type numElements,
2429 ALLOCATOR allocator);
2430
2431 template <class ALLOCATOR>
2432 static void valueInititalizeN(
2433 Iterator *toEnd,
2434 Iterator fromEnd,
2435 size_type numElements,
2436 ALLOCATOR allocator,
2437 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>);
2438
2439 template <class ALLOCATOR>
2440 static void valueInititalizeN(
2441 Iterator *toEnd,
2442 Iterator fromEnd,
2443 size_type numElements,
2444 ALLOCATOR allocator,
2445 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS>);
2446};
2447
2448 // =======================================
2449 // class DequePrimitives_DequeElementGuard
2450 // =======================================
2451
2452/// This `class` provides a specialized proctor object that, upon
2453/// destruction and unless the `release` method has been called, destroys
2454/// the elements in a segment of a deque of parameterized `VALUE_TYPE`. The
2455/// elements destroyed are delimited by the "guarded" range
2456/// `[d_begin .. d_end)`.
2457///
2458/// See @ref bslalg_dequeprimitives_cpp03
2459template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
2460class DequePrimitives_DequeElementGuard {
2461
2462 public:
2463 // PUBLIC TYPES
2464 typedef DequeIterator<VALUE_TYPE, BLOCK_LENGTH> Iterator;
2465
2466 private:
2467 // DATA
2468 Iterator d_begin; // iterator of first element in guarded range
2469 Iterator d_end; // iterator beyond last element in guarded range
2470 ALLOCATOR d_allocator;
2471
2472 private:
2473 // NOT IMPLEMENTED
2474 DequePrimitives_DequeElementGuard(
2475 const DequePrimitives_DequeElementGuard&);
2476 DequePrimitives_DequeElementGuard& operator=(
2477 const DequePrimitives_DequeElementGuard&);
2478
2479 public:
2480 // CREATORS
2481
2482 /// Create a deque exception guard object for the sequence of elements
2483 /// of the parameterized `VALUE_TYPE` delimited by the specified range `[begin .. end)`.
2484 ///
2485 /// \pre The behavior is undefined unless `begin <= end`
2486 /// and unless each element in the range `[begin .. end)` has been
2487 /// initialized.
2488 DequePrimitives_DequeElementGuard(const Iterator& begin,
2489 const Iterator& end,
2490 ALLOCATOR allocator);
2491
2492 /// Call the destructor on each of the elements of the parameterized
2493 /// `VALUE_TYPE` delimited by the range `[begin .. end)` and destroy
2494 /// this array exception guard.
2495 ~DequePrimitives_DequeElementGuard();
2496
2497 // MANIPULATORS
2498
2499 /// Move the begin iterator by the specified `offset`, and return the
2500 /// new begin iterator.
2501 Iterator& moveBegin(std::ptrdiff_t offset = -1);
2502
2503 /// Move the end pointer by the specified `offset`, and return the new
2504 /// end pointer.
2505 Iterator& moveEnd(std::ptrdiff_t offset = 1);
2506
2507 /// Set the range of elements guarded by this object to be empty.
2508 ///
2509 /// \note Note that `d_begin == d_end` following this operation, but the specific
2510 /// value is unspecified.
2511 void release();
2512};
2513
2514 // ===============================================
2515 // class DequePrimitives_ExternalDequeElementGuard
2516 // ===============================================
2517
2518/// This `class` provides a specialized proctor object that, upon
2519/// destruction and unless the `release` method has been called, destroys
2520/// the elements in a segment of a `bsl::deque` of parameterized type
2521/// `VALUE_TYPE`. The elements destroyed are delimited by the "guarded" range `[*d_begin .. *d_end)`.
2522///
2523/// \note Note that the range guarded by this
2524/// `class` is dynamic and can be changed outside of this `class`.
2525///
2526/// See @ref bslalg_dequeprimitives_cpp03
2527template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
2528class DequePrimitives_ExternalDequeElementGuard {
2529
2530 public:
2531 // PUBLIC TYPES
2532 typedef DequeIterator<VALUE_TYPE, BLOCK_LENGTH> Iterator;
2533
2534 private:
2535 // DATA
2536 Iterator *d_begin_p; // pointer to iterator of first element in guarded
2537 // range
2538
2539 Iterator *d_end_p; // pointer to iterator beyond last element in
2540 // guarded range
2541 ALLOCATOR d_allocator;
2542
2543 private:
2544 // NOT IMPLEMENTED
2545 DequePrimitives_ExternalDequeElementGuard(
2546 const DequePrimitives_ExternalDequeElementGuard&);
2547 DequePrimitives_ExternalDequeElementGuard& operator=(
2548 const DequePrimitives_ExternalDequeElementGuard&);
2549
2550 public:
2551 // CREATORS
2552
2553 /// Create a deque exception guard object for the sequence of elements
2554 /// of the parameterized `VALUE_TYPE` delimited by the specified range `[*begin .. *end)`.
2555 ///
2556 /// \pre The behavior is undefined unless `*begin` <=
2557 /// `*end` and unless each element in the range `[*begin .. *end)` has
2558 /// been initialized.
2559 DequePrimitives_ExternalDequeElementGuard(Iterator *begin,
2560 Iterator *end,
2561 ALLOCATOR allocator);
2562
2563 /// Call the destructor on each of the elements of the parameterized
2564 /// `VALUE_TYPE` delimited by the range `[*d_begin_p .. *d_end_p)` and
2565 /// destroy this array exception guard.
2566 ~DequePrimitives_ExternalDequeElementGuard();
2567
2568 // MANIPULATORS
2569
2570 /// Set the range of elements guarded by this object to be empty.
2571 ///
2572 /// \note Note that `d_begin_p == d_end_p == 0` following this operation.
2573 void release();
2574};
2575
2576 // ====================================
2577 // class DequePrimitives_DequeMoveGuard
2578 // ====================================
2579
2580/// This `class` provides a guard object that, upon destruction and unless
2581/// the `release` method has been called, uses `moveBack` or `moveFront` to
2582/// move the "guarded" range `[d_source_p .. d_source_p + d_size - 1]`
2583/// back to `[d_destination_p .. d_destination_p + d_size -1]`.
2584///
2585/// See @ref bslalg_dequeprimitives_cpp03
2586template <class VALUE_TYPE, int BLOCK_LENGTH>
2587class DequePrimitives_DequeMoveGuard {
2588
2589 public:
2590 // PUBLIC TYPES
2591 typedef DequeIterator<VALUE_TYPE, BLOCK_LENGTH> Iterator;
2592 typedef bslalg::DequePrimitives<VALUE_TYPE, BLOCK_LENGTH> DequePrimitives;
2593
2594 private:
2595 // DATA
2596 Iterator d_destination_p; // destination of the move
2597 Iterator d_source_p; // source of the move
2598 std::size_t d_size; // size of the range being guarded
2599 bool d_front; // whether to use 'moveFront'
2600
2601 private:
2602 // NOT IMPLEMENTED
2603 DequePrimitives_DequeMoveGuard(const DequePrimitives_DequeMoveGuard&);
2604 DequePrimitives_DequeMoveGuard& operator=(
2605 const DequePrimitives_DequeMoveGuard&);
2606
2607 public:
2608 // CREATORS
2609
2610 /// Create a guard object that will call `moveBack` or `moveFront`,
2611 /// depending on the specified `isFront`, on the specified `size`
2612 /// elements from `src` to `dest` upon destruction unless `release` has
2613 /// been called.
2614 DequePrimitives_DequeMoveGuard(Iterator dest,
2615 Iterator src,
2616 std::size_t size,
2617 bool isFront);
2618
2619 /// Call either `moveBack` or `moveFront` depending on `d_front` upon
2620 /// destruction unless `release` has been called before this.
2621 ~DequePrimitives_DequeMoveGuard();
2622
2623 // MANIPULATORS
2624
2625 /// Set the size of the range guarded by this object to be zero.
2626 void release();
2627};
2628
2629 // ==========================================
2630 // class DequePrimitives_DequeEndpointProctor
2631 // ==========================================
2632
2633/// This class implements a proctor that, upon destruction and unless its
2634/// `release` method has previously been invoked, sets a deque endpoint
2635/// (i.e., "start" or "finish" iterator) to a position within the deque.
2636/// Both the endpoint and position are supplied at construction. See
2637/// `emplaceAndMoveToBack` and `emplaceAndMoveToFront` for use cases.
2638///
2639/// See @ref bslalg_dequeprimitives_cpp03
2640template <class VALUE_TYPE, int BLOCK_LENGTH>
2641class DequePrimitives_DequeEndpointProctor {
2642
2643 public:
2644 // PUBLIC TYPES
2645 typedef DequeIterator<VALUE_TYPE, BLOCK_LENGTH> Iterator;
2646
2647 private:
2648 // DATA
2649 Iterator *d_endpoint_p; // proctored endpoint of a deque
2650 Iterator d_position; // set endpoint to this upon destruction
2651
2652 private:
2653 // NOT IMPLEMENTED
2654 DequePrimitives_DequeEndpointProctor(
2655 const DequePrimitives_DequeEndpointProctor&);
2656 DequePrimitives_DequeEndpointProctor& operator=(
2657 const DequePrimitives_DequeEndpointProctor&);
2658
2659 public:
2660 // CREATORS
2661
2662 /// Create a deque endpoint proctor that conditionally manages the
2663 /// specified `endpoint` (if non-zero) by setting `*endpoint` to the
2664 /// specified `position` (if not released -- see `release`) upon
2665 /// destruction.
2666 DequePrimitives_DequeEndpointProctor(Iterator *endpoint,
2667 Iterator position);
2668
2669 /// Destroy this endpoint proctor, and set the deque endpoint it manages
2670 /// (if any) to the position supplied at construction. If no endpoint
2671 /// is currently being managed, this method has no effect.
2672 ~DequePrimitives_DequeEndpointProctor();
2673
2674 // MANIPULATORS
2675
2676 /// Release from management the deque endpoint currently managed by this
2677 /// proctor. If no endpoint is currently being managed, this method has
2678 /// no effect.
2679 void release();
2680};
2681
2682// ============================================================================
2683// INLINE FUNCTION DEFINITIONS
2684// ============================================================================
2685
2686 // ---------------------
2687 // class DequePrimitives
2688 // ---------------------
2689
2690// CLASS METHODS
2691template <class VALUE_TYPE, int BLOCK_LENGTH>
2692template <class ALLOCATOR>
2693inline
2694void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::destruct(Iterator begin,
2695 Iterator end,
2696 ALLOCATOR allocator)
2697{
2698 enum {
2699 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
2700
2701 VALUE = IS_BITWISECOPYABLE
2702 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
2703 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
2704 };
2705
2706 return destruct(begin,
2707 end,
2708 allocator,
2709 bsl::integral_constant<int, VALUE>());
2710}
2711
2712template <class VALUE_TYPE, int BLOCK_LENGTH>
2713template <class ALLOCATOR>
2714void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::destruct(
2715 Iterator,
2716 Iterator,
2717 ALLOCATOR,
2718 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>)
2719{
2720 // No-op.
2721}
2722
2723template <class VALUE_TYPE, int BLOCK_LENGTH>
2724template <class ALLOCATOR>
2725void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::destruct(
2726 Iterator begin,
2727 Iterator end,
2728 ALLOCATOR allocator,
2729 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
2730{
2731 for (; !(begin == end); ++begin) {
2732 bsl::allocator_traits<ALLOCATOR>::destroy(allocator,
2733 begin.valuePtr());
2734 }
2735}
2736
2737template <class VALUE_TYPE, int BLOCK_LENGTH>
2738template <class ALLOCATOR>
2739inline
2740typename
2741DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::Iterator
2742DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::erase(Iterator *toBegin,
2743 Iterator *toEnd,
2744 Iterator fromBegin,
2745 Iterator first,
2746 Iterator last,
2747 Iterator fromEnd,
2748 ALLOCATOR allocator)
2749{
2750 enum {
2751 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
2752
2753 VALUE = IS_BITWISECOPYABLE
2754 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
2755 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
2756 };
2757
2758 return erase(toBegin,
2759 toEnd,
2760 fromBegin,
2761 first,
2762 last,
2763 fromEnd,
2764 allocator,
2765 bsl::integral_constant<int, VALUE>());
2766}
2767
2768template <class VALUE_TYPE, int BLOCK_LENGTH>
2769template <class ALLOCATOR>
2770typename DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::Iterator
2771DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::erase(
2772 Iterator *toBegin,
2773 Iterator *toEnd,
2774 Iterator fromBegin,
2775 Iterator first,
2776 Iterator last,
2777 Iterator fromEnd,
2778 ALLOCATOR allocator,
2779 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
2780{
2781 if (first == last) { // Nothing to delete, bail out fast
2782 *toBegin = fromBegin;
2783 *toEnd = fromEnd;
2784 return first; // RETURN
2785 }
2786
2787 size_type frontSize = first - fromBegin;
2788 size_type backSize = fromEnd - last;
2789 Iterator ret;
2790
2791 if (frontSize < backSize) {
2792 ret = last;
2793 for (; 0 < frontSize; --frontSize) {
2794 --last;
2795 --first;
2796 *last = MoveUtil::move(*first);
2797 }
2798 *toBegin = last;
2799 *toEnd = fromEnd;
2800 }
2801 else {
2802 ret = first;
2803 for (; 0 < backSize; --backSize, ++first, ++last) {
2804 *first = MoveUtil::move(*last);
2805 }
2806 *toBegin = fromBegin;
2807 *toEnd = first;
2808 }
2809 destruct(first, last, allocator);
2810 return ret;
2811}
2812
2813template <class VALUE_TYPE, int BLOCK_LENGTH>
2814template <class ALLOCATOR>
2815typename DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::Iterator
2816DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::erase(
2817 Iterator *toBegin,
2818 Iterator *toEnd,
2819 Iterator fromBegin,
2820 Iterator first,
2821 Iterator last,
2822 Iterator fromEnd,
2823 ALLOCATOR,
2824 bsl::integral_constant<int,
2825 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>)
2826{
2827 size_type frontSize = first - fromBegin;
2828 size_type backSize = fromEnd - last;
2829 Iterator ret;
2830
2831 if (frontSize < backSize) {
2832 ret = last;
2833 moveBack(&last, &first, frontSize);
2834 *toBegin = last;
2835 *toEnd = fromEnd;
2836 }
2837 else {
2838 ret = first;
2839 moveFront(&first, &last, backSize);
2840 *toBegin = fromBegin;
2841 *toEnd = first;
2842 }
2843 // 'destruct' is no-op for types with 'BITWISE_COPYABLE_TRAITS'.
2844 return ret;
2845}
2846
2847template <class VALUE_TYPE, int BLOCK_LENGTH>
2848template <class ALLOCATOR>
2849inline
2850void
2851DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>
2852 ::insertAndMoveToBack(Iterator *toEnd,
2853 Iterator fromEnd,
2854 Iterator position,
2855 size_type numElements,
2856 const VALUE_TYPE& value,
2857 ALLOCATOR allocator)
2858{
2859 enum {
2860 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
2861 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
2862
2863 VALUE = IS_BITWISECOPYABLE
2864 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
2865 : IS_BITWISEMOVEABLE
2866 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
2867 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
2868 };
2869
2870 insertAndMoveToBack(toEnd,
2871 fromEnd,
2872 position,
2873 numElements,
2874 value,
2875 allocator,
2876 bsl::integral_constant<int, VALUE>());
2877}
2878
2879template <class VALUE_TYPE, int BLOCK_LENGTH>
2880template <class ALLOCATOR>
2881void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::insertAndMoveToBack(
2882 Iterator *toEnd,
2883 Iterator fromEnd,
2884 Iterator position,
2885 size_type numElements,
2886 const VALUE_TYPE& value,
2887 ALLOCATOR allocator,
2888 bsl::integral_constant<int,
2889 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>)
2890{
2891 size_type backSize = fromEnd - position;
2892 Iterator end = fromEnd;
2893 Iterator dest = end + numElements;
2894
2895 bsls::ObjectBuffer<VALUE_TYPE> space;
2896 bslma::ConstructionUtil::construct(
2897 BSLS_UTIL_ADDRESSOF(space.object()),
2898 bslma::Default::allocator(),
2899 value);
2900 bslma::DestructorProctor<VALUE_TYPE>
2901 temp(BSLS_UTIL_ADDRESSOF(space.object()));
2902
2903 // TBD: this does the same thing as the old code - don't like that we
2904 // circumvent the whole allocator thing, but for now, let's keep it
2905 // consistent.
2906 // ConstructorProxy<VALUE_TYPE>
2907 // tempValue(value, bslma::Default::allocator());
2908
2909 // No guard needed since all the operations won't throw due to the
2910 // bitwise-copyable trait
2911 moveBack(&dest, &end, backSize);
2912 uninitializedFillNFront(&dest, dest, numElements, space.object(),
2913 allocator);
2914
2915 *toEnd = fromEnd + numElements;
2916}
2917
2918template <class VALUE_TYPE, int BLOCK_LENGTH>
2919template <class ALLOCATOR>
2920void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::insertAndMoveToBack(
2921 Iterator *toEnd,
2922 Iterator fromEnd,
2923 Iterator position,
2924 size_type numElements,
2925 const VALUE_TYPE& value,
2926 ALLOCATOR allocator,
2927 bsl::integral_constant<int,
2928 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>)
2929{
2930 typedef DequePrimitives_ExternalDequeElementGuard<VALUE_TYPE,
2931 BLOCK_LENGTH,
2932 ALLOCATOR> ExtGuard;
2933
2934
2935 size_type backSize = fromEnd - position;
2936 Iterator end = fromEnd;
2937 Iterator dest = end + numElements;
2938
2939 // In case of aliasing, make a copy of the value.
2940 bsls::ObjectBuffer<VALUE_TYPE> space;
2941 bslma::ConstructionUtil::construct(
2942 BSLS_UTIL_ADDRESSOF(space.object()),
2943 bslma::Default::allocator(),
2944 value);
2945 bslma::DestructorProctor<VALUE_TYPE>
2946 temp(BSLS_UTIL_ADDRESSOF(space.object()));
2947
2948 // TBD: this does the same thing as the old code - don't like that we
2949 // circumvent the whole allocator thing, but for now, let's keep it
2950 // consistent.
2951 // ConstructorProxy<VALUE_TYPE>
2952 // tempValue(value, bslma::Default::allocator());
2953
2954 // Setup a reverse guard that will reverse the moveBack operation in case
2955 // of an exception.
2956 MoveGuard guard(end, dest, backSize, false);
2957
2958 moveBack(&dest, &end, backSize);
2959
2960 // Create a guard for 'uninitializedFillNBack' because it can throw under
2961 // 'bitwisemoveable' trait. Need to use this special guard because
2962 // uninitializedFillNFront is not exception safe.
2963 Iterator dest2(dest);
2964 ExtGuard eguard(&dest, &dest2, allocator);
2965
2966 uninitializedFillNFront(&dest, dest, numElements, space.object(),
2967 allocator);
2968 eguard.release();
2969 guard.release();
2970 *toEnd = fromEnd + numElements;
2971}
2972
2973template <class VALUE_TYPE, int BLOCK_LENGTH>
2974template <class ALLOCATOR>
2975void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::insertAndMoveToBack(
2976 Iterator *toEnd,
2977 Iterator fromEnd,
2978 Iterator position,
2979 size_type numElements,
2980 const VALUE_TYPE& value,
2981 ALLOCATOR allocator,
2982 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
2983{
2984 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
2985 BLOCK_LENGTH,
2986 ALLOCATOR> ElementGuard;
2987
2988 size_type backSize = fromEnd - position;
2989 Iterator end = fromEnd;
2990 Iterator dest = end + numElements;
2991 size_type numDest;
2992
2993 // In case of aliasing, make a copy of the value.
2994
2995 bsls::ObjectBuffer<VALUE_TYPE> space;
2996 bslma::ConstructionUtil::construct(BSLS_UTIL_ADDRESSOF(space.object()),
2997 bslma::Default::allocator(),
2998 value);
2999 bslma::DestructorProctor<VALUE_TYPE>
3000 temp(BSLS_UTIL_ADDRESSOF(space.object()));
3001
3002 // TBD: this does the same thing as the old code - don't like that we
3003 // circumvent the whole allocator thing, but for now, let's keep it
3004 // consistent.
3005 // ConstructorProxy<VALUE_TYPE> tempValue(value,
3006 // bslma::Default::allocator());
3007
3008 ElementGuard guard(dest, dest, allocator);
3009 if (backSize >= numElements) {
3010 for (numDest = numElements; 0 < numDest; --numDest) {
3011 --dest;
3012 --end;
3013 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3014 dest.valuePtr(),
3015 *end);
3016 guard.moveBegin(-1);
3017 }
3018 for (backSize -= numElements; 0 < backSize; --backSize) {
3019 --dest;
3020 --end;
3021 *dest = *end;
3022 }
3023 for (numDest = numElements; 0 < numDest; --numDest, ++position) {
3024 *position = space.object();
3025 }
3026 } else {
3027 for (numDest = backSize; 0 < numDest; --numDest) {
3028 --dest;
3029 --end;
3030 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3031 dest.valuePtr(),
3032 *end);
3033 guard.moveBegin(-1);
3034 }
3035 for (numDest = numElements; backSize < numDest; --numDest) {
3036 --dest;
3037 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3038 dest.valuePtr(),
3039 space.object());
3040
3041 guard.moveBegin(-1);
3042 }
3043 for (; 0 < numDest; --numDest, ++position) {
3044 *position = space.object();
3045 }
3046 }
3047 guard.release();
3048
3049 *toEnd = fromEnd + numElements;
3050}
3051
3052template <class VALUE_TYPE, int BLOCK_LENGTH>
3053template <class FWD_ITER, class SENTINEL, class ALLOCATOR>
3054void
3055DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>
3056 ::insertAndMoveToBack(Iterator *toEnd,
3057 Iterator fromEnd,
3058 Iterator position,
3059 FWD_ITER first,
3060 SENTINEL /*last*/,
3061 size_type numElements,
3062 ALLOCATOR allocator)
3063{
3064 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
3065 BLOCK_LENGTH,
3066 ALLOCATOR> ElementGuard;
3067
3068 size_type backSize = fromEnd - position;
3069 Iterator end = fromEnd;
3070 Iterator dest = end + numElements;
3071 size_type numDest;
3072
3073 ElementGuard guard(dest, dest, allocator);
3074 if (backSize >= numElements) {
3075 for (numDest = numElements; 0 < numDest; --numDest) {
3076 --dest;
3077 --end;
3078 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3079 dest.valuePtr(),
3080 *end);
3081 guard.moveBegin(-1);
3082 }
3083 for (numDest = backSize; numElements < numDest; --numDest) {
3084 --dest;
3085 --end;
3086 *dest = *end;
3087 }
3088 for (; 0 < numDest; ++first, ++position, --numDest) {
3089 *position = *first;
3090 }
3091 } else {
3092 for (numDest = backSize; 0 < numDest; --numDest) {
3093 --dest;
3094 --end;
3095 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3096 dest.valuePtr(),
3097 *end);
3098 guard.moveBegin(-1);
3099 }
3100 for (numDest = backSize; 0 < numDest; --numDest, ++position, ++first) {
3101 *position = *first;
3102 }
3103 // Second guard needed because we're guarding from a different range.
3104 ElementGuard guard2(position, position, allocator);
3105 for (numDest = numElements; backSize < numDest; ++first, ++position,
3106 --numDest) {
3107 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3108 position.valuePtr(),
3109 *first);
3110 guard2.moveEnd(1);
3111 }
3112 guard2.release();
3113 }
3114 guard.release();
3115 *toEnd = fromEnd + numElements;
3116}
3117
3118template <class VALUE_TYPE, int BLOCK_LENGTH>
3119template <class ALLOCATOR>
3120inline
3121void
3122DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::moveInsertAndMoveToBack(
3123 Iterator *toEnd,
3124 Iterator fromEnd,
3125 Iterator position,
3126 bslmf::MovableRef<VALUE_TYPE> value,
3127 ALLOCATOR allocator)
3128{
3129 enum {
3130 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3131 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3132
3133 VALUE = IS_BITWISECOPYABLE
3134 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3135 : IS_BITWISEMOVEABLE
3136 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3137 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3138 };
3139
3140 VALUE_TYPE& lvalue = value;
3141
3142 moveInsertAndMoveToBack(toEnd,
3143 fromEnd,
3144 position,
3145 MoveUtil::move(lvalue),
3146 allocator,
3147 bsl::integral_constant<int, VALUE>());
3148}
3149
3150template <class VALUE_TYPE, int BLOCK_LENGTH>
3151template <class ALLOCATOR>
3152void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::moveInsertAndMoveToBack(
3153 Iterator *toEnd,
3154 Iterator fromEnd,
3155 Iterator position,
3156 bslmf::MovableRef<VALUE_TYPE> value,
3157 ALLOCATOR allocator,
3158 bsl::integral_constant<int,
3159 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>)
3160{
3161 const size_type backSize = fromEnd - position;
3162 Iterator end = fromEnd;
3163 Iterator dest = end + 1;
3164
3165 // No guard needed since no operations will throw with
3166 // 'BITWISE_COPYABLE_TRAITS'.
3167
3168 moveBack(&dest, &end, backSize);
3169 --dest;
3170
3171 VALUE_TYPE& lvalue = value;
3172 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3173 dest.valuePtr(),
3174 MoveUtil::move(lvalue));
3175
3176 *toEnd = fromEnd + 1;
3177}
3178
3179template <class VALUE_TYPE, int BLOCK_LENGTH>
3180template <class ALLOCATOR>
3181void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::moveInsertAndMoveToBack(
3182 Iterator *toEnd,
3183 Iterator fromEnd,
3184 Iterator position,
3185 bslmf::MovableRef<VALUE_TYPE> value,
3186 ALLOCATOR allocator,
3187 bsl::integral_constant<int,
3188 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>)
3189{
3190 const size_type backSize = fromEnd - position;
3191 Iterator end = fromEnd;
3192 Iterator dest = end + 1;
3193
3194 // Create a reverse guard that will undo the 'moveBack' operation in case
3195 // of an exception.
3196
3197 MoveGuard guard(end, dest, backSize, false);
3198
3199 moveBack(&dest, &end, backSize);
3200 --dest;
3201
3202 VALUE_TYPE& lvalue = value;
3203 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3204 dest.valuePtr(),
3205 MoveUtil::move(lvalue));
3206
3207 guard.release();
3208
3209 *toEnd = fromEnd + 1;
3210}
3211
3212template <class VALUE_TYPE, int BLOCK_LENGTH>
3213template <class ALLOCATOR>
3214void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::moveInsertAndMoveToBack(
3215 Iterator *toEnd,
3216 Iterator fromEnd,
3217 Iterator position,
3218 bslmf::MovableRef<VALUE_TYPE> value,
3219 ALLOCATOR allocator,
3220 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
3221{
3222 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
3223 BLOCK_LENGTH,
3224 ALLOCATOR> ElementGuard;
3225
3226 size_type backSize = fromEnd - position;
3227 Iterator end = fromEnd;
3228 Iterator dest = end + 1;
3229
3230 BSLS_ASSERT_SAFE(backSize >= 1);
3231
3232 ElementGuard guard(dest, dest, allocator);
3233
3234 // 1. move-construct back-most element being bumped 1 slot
3235
3236 --dest;
3237 --end;
3238 bsl::allocator_traits<ALLOCATOR>::construct(
3239 allocator,
3240 dest.valuePtr(),
3241 MoveUtil::move_if_noexcept(*end));
3242 guard.moveBegin(-1);
3243
3244 // 2. move-assign other existing elements being bumped back 1 slot
3245
3246 for (backSize -= 1; 0 < backSize; --backSize) {
3247 --dest;
3248 --end;
3249 *dest = MoveUtil::move_if_noexcept(*end);
3250 }
3251
3252 // 3. move-assign new element
3253
3254 VALUE_TYPE& lvalue = value;
3255 *position = MoveUtil::move(lvalue);
3256
3257 guard.release();
3258
3259 *toEnd = fromEnd + 1;
3260}
3261
3262template <class VALUE_TYPE, int BLOCK_LENGTH>
3263template <class ALLOCATOR>
3264inline
3265void
3266DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>
3267 ::insertAndMoveToFront(Iterator *toBegin,
3268 Iterator fromBegin,
3269 Iterator position,
3270 size_type numElements,
3271 const VALUE_TYPE& value,
3272 ALLOCATOR allocator)
3273{
3274 enum {
3275 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3276 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3277
3278 VALUE = IS_BITWISECOPYABLE
3279 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3280 : IS_BITWISEMOVEABLE
3281 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3282 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3283 };
3284
3285 insertAndMoveToFront(toBegin,
3286 fromBegin,
3287 position,
3288 numElements,
3289 value,
3290 allocator,
3291 bsl::integral_constant<int, VALUE>());
3292}
3293
3294template <class VALUE_TYPE, int BLOCK_LENGTH>
3295template <class ALLOCATOR>
3296void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::insertAndMoveToFront(
3297 Iterator *toBegin,
3298 Iterator fromBegin,
3299 Iterator position,
3300 size_type numElements,
3301 const VALUE_TYPE& value,
3302 ALLOCATOR allocator,
3303 bsl::integral_constant<int,
3304 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>)
3305{
3306 size_type frontSize = position - fromBegin;
3307 Iterator begin = fromBegin;
3308 Iterator dest = begin - numElements;
3309
3310 // In case of aliasing, make a copy of the value.
3311 bsls::ObjectBuffer<VALUE_TYPE> space;
3312 bslma::ConstructionUtil::construct(BSLS_UTIL_ADDRESSOF(space.object()),
3313 bslma::Default::allocator(),
3314 value);
3315 bslma::DestructorProctor<VALUE_TYPE>
3316 temp(BSLS_UTIL_ADDRESSOF(space.object()));
3317
3318 // TBD: this does the same thing as the old code - don't like that we
3319 // circumvent the whole allocator thing, but for now, let's keep it
3320 // consistent.
3321 // ConstructorProxy<VALUE_TYPE>
3322 // tempValue(value, bslma::Default::allocator());
3323
3324 // No guard needed since all the operations won't throw due to the
3325 // bitwise-copyable trait
3326 moveFront(&dest, &begin, frontSize);
3327 uninitializedFillNBack(&dest, dest, numElements, space.object(),
3328 allocator);
3329
3330 *toBegin = fromBegin - numElements;
3331}
3332
3333template <class VALUE_TYPE, int BLOCK_LENGTH>
3334template <class ALLOCATOR>
3335void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::insertAndMoveToFront(
3336 Iterator *toBegin,
3337 Iterator fromBegin,
3338 Iterator position,
3339 size_type numElements,
3340 const VALUE_TYPE& value,
3341 ALLOCATOR allocator,
3342 bsl::integral_constant<int,
3343 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>)
3344{
3345 typedef DequePrimitives_ExternalDequeElementGuard<VALUE_TYPE,
3346 BLOCK_LENGTH,
3347 ALLOCATOR> ExtGuard;
3348 size_type frontSize = position - fromBegin;
3349 Iterator begin = fromBegin;
3350 Iterator dest = begin - numElements;
3351
3352 // In case of aliasing, make a copy of the value.
3353 bsls::ObjectBuffer<VALUE_TYPE> space;
3354 bslma::ConstructionUtil::construct(BSLS_UTIL_ADDRESSOF(space.object()),
3355 bslma::Default::allocator(),
3356 value);
3357 bslma::DestructorProctor<VALUE_TYPE>
3358 temp(BSLS_UTIL_ADDRESSOF(space.object()));
3359
3360 // TBD: this does the same thing as the old code - don't like that we
3361 // circumvent the whole allocator thing, but for now, let's keep it
3362 // consistent.
3363 // ConstructorProxy<VALUE_TYPE>
3364 // tempValue(value, bslma::Default::allocator());
3365
3366 // Create a reverse guard that will reverse the moveFront operation in case
3367 // of an exception.
3368 MoveGuard guard(begin, dest, frontSize, true);
3369
3370 moveFront(&dest, &begin, frontSize);
3371
3372 // Create a guard for 'uninitializedFillNBack' because it can throw under
3373 // 'bitwisemoveable' trait. Need to use this special guard because
3374 // uninitializedFillNBack is not exception safe.
3375 Iterator dest2(dest);
3376 ExtGuard eguard(&dest2, &dest, allocator);
3377
3378 uninitializedFillNBack(&dest, dest, numElements, space.object(),
3379 allocator);
3380
3381 eguard.release();
3382 guard.release();
3383 *toBegin = fromBegin - numElements;
3384}
3385
3386template <class VALUE_TYPE, int BLOCK_LENGTH>
3387template <class ALLOCATOR>
3388void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::insertAndMoveToFront(
3389 Iterator *toBegin,
3390 Iterator fromBegin,
3391 Iterator position,
3392 size_type numElements,
3393 const VALUE_TYPE& value,
3394 ALLOCATOR allocator,
3395 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
3396{
3397 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
3398 BLOCK_LENGTH,
3399 ALLOCATOR> ElementGuard;
3400
3401 size_type frontSize = position - fromBegin;
3402 Iterator begin = fromBegin;
3403 Iterator dest = begin - numElements;
3404 size_type numDest;
3405
3406 // In case of aliasing, make a copy of the value.
3407 bsls::ObjectBuffer<VALUE_TYPE> space;
3408 bslma::ConstructionUtil::construct(BSLS_UTIL_ADDRESSOF(space.object()),
3409 bslma::Default::allocator(),
3410 value);
3411 bslma::DestructorProctor<VALUE_TYPE>
3412 temp(BSLS_UTIL_ADDRESSOF(space.object()));
3413
3414 // TBD: this does the same thing as the old code - don't like that we
3415 // circumvent the whole allocator thing, but for now, let's keep it
3416 // consistent.
3417 // ConstructorProxy<VALUE_TYPE>
3418 // tempValue(value, bslma::Default::allocator());
3419
3420 ElementGuard guard(dest, dest, allocator);
3421 if (frontSize >= numElements) {
3422 for (numDest = numElements; 0 < numDest; --numDest, ++dest, ++begin) {
3423 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3424 dest.valuePtr(),
3425 *begin);
3426 guard.moveEnd(1);
3427 }
3428 for (frontSize -= numElements; 0 < frontSize;
3429 --frontSize, ++dest, ++begin) {
3430 *dest = *begin;
3431 }
3432 for (numDest = numElements; 0 < numDest; --numDest, ++dest) {
3433 *dest = space.object();
3434 }
3435 } else {
3436 for (numDest = frontSize; 0 < numDest; --numDest, ++dest, ++begin) {
3437 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3438 dest.valuePtr(),
3439 *begin);
3440 guard.moveEnd(1);
3441 }
3442 for (numDest = numElements; frontSize < numDest; --numDest, ++dest) {
3443 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3444 dest.valuePtr(),
3445 space.object());
3446 guard.moveEnd(1);
3447 }
3448 for (; 0 < numDest; --numDest, ++dest) {
3449 *dest = space.object();
3450 }
3451 }
3452 guard.release();
3453 *toBegin = fromBegin - numElements;
3454}
3455
3456template <class VALUE_TYPE, int BLOCK_LENGTH>
3457template <class FWD_ITER, class SENTINEL, class ALLOCATOR>
3458void
3459DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>
3460 ::insertAndMoveToFront(Iterator *toBegin,
3461 Iterator fromBegin,
3462 Iterator position,
3463 FWD_ITER first,
3464 SENTINEL /*last*/,
3465 size_type numElements,
3466 ALLOCATOR allocator)
3467{
3468 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
3469 BLOCK_LENGTH,
3470 ALLOCATOR> ElementGuard;
3471
3472 size_type frontSize = position - fromBegin;
3473 Iterator begin = fromBegin;
3474 Iterator dest = begin - numElements;
3475 size_type numDest;
3476
3477 ElementGuard guard(dest, dest, allocator);
3478 if (frontSize >= numElements) {
3479 for (numDest = numElements; 0 < numDest; --numDest, ++dest, ++begin) {
3480 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3481 dest.valuePtr(),
3482 *begin);
3483 guard.moveEnd(1);
3484 }
3485 for (frontSize -= numElements; 0 < frontSize;
3486 --frontSize, ++dest, ++begin) {
3487 *dest = *begin;
3488 }
3489 for (numDest = numElements; 0 < numDest; --numDest, ++dest, ++first) {
3490 *dest = *first;
3491 }
3492 } else {
3493 for (numDest = frontSize; 0 < numDest; --numDest, ++dest, ++begin) {
3494 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3495 dest.valuePtr(),
3496 *begin);
3497 guard.moveEnd(1);
3498 }
3499 for (numDest = numElements; frontSize < numDest;
3500 --numDest, ++dest, ++first) {
3501 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3502 dest.valuePtr(),
3503 *first);
3504 guard.moveEnd(1);
3505 }
3506 for (; 0 < numDest; --numDest, ++dest, ++first) {
3507 *dest = *first;
3508 }
3509 }
3510 guard.release();
3511 *toBegin = fromBegin - numElements;
3512}
3513
3514template <class VALUE_TYPE, int BLOCK_LENGTH>
3515template <class ALLOCATOR>
3516inline
3517void
3518DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::moveInsertAndMoveToFront(
3519 Iterator *toBegin,
3520 Iterator fromBegin,
3521 Iterator position,
3522 bslmf::MovableRef<VALUE_TYPE> value,
3523 ALLOCATOR allocator)
3524{
3525 enum {
3526 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3527 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3528
3529 VALUE = IS_BITWISECOPYABLE
3530 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3531 : IS_BITWISEMOVEABLE
3532 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3533 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3534 };
3535
3536 VALUE_TYPE& lvalue = value;
3537
3538 moveInsertAndMoveToFront(toBegin,
3539 fromBegin,
3540 position,
3541 MoveUtil::move(lvalue),
3542 allocator,
3543 bsl::integral_constant<int, VALUE>());
3544}
3545
3546template <class VALUE_TYPE, int BLOCK_LENGTH>
3547template <class ALLOCATOR>
3548void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::moveInsertAndMoveToFront(
3549 Iterator *toBegin,
3550 Iterator fromBegin,
3551 Iterator position,
3552 bslmf::MovableRef<VALUE_TYPE> value,
3553 ALLOCATOR allocator,
3554 bsl::integral_constant<int,
3555 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>)
3556{
3557 const size_type frontSize = position - fromBegin;
3558 Iterator begin = fromBegin;
3559 Iterator dest = begin - 1;
3560
3561 // No guard needed since no operations will throw with
3562 // 'BITWISE_COPYABLE_TRAITS'.
3563
3564 moveFront(&dest, &begin, frontSize);
3565
3566 VALUE_TYPE& lvalue = value;
3567 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3568 dest.valuePtr(),
3569 MoveUtil::move(lvalue));
3570
3571 *toBegin = fromBegin - 1;
3572}
3573
3574template <class VALUE_TYPE, int BLOCK_LENGTH>
3575template <class ALLOCATOR>
3576void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::moveInsertAndMoveToFront(
3577 Iterator *toBegin,
3578 Iterator fromBegin,
3579 Iterator position,
3580 bslmf::MovableRef<VALUE_TYPE> value,
3581 ALLOCATOR allocator,
3582 bsl::integral_constant<int,
3583 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>)
3584{
3585 const size_type frontSize = position - fromBegin;
3586 Iterator begin = fromBegin;
3587 Iterator dest = begin - 1;
3588
3589 // Create a reverse guard that will undo the 'moveFront' operation in case
3590 // of an exception.
3591
3592 MoveGuard guard(begin, dest, frontSize, true);
3593
3594 moveFront(&dest, &begin, frontSize);
3595
3596 VALUE_TYPE& lvalue = value;
3597 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
3598 dest.valuePtr(),
3599 MoveUtil::move(lvalue));
3600
3601 guard.release();
3602
3603 *toBegin = fromBegin - 1;
3604}
3605
3606template <class VALUE_TYPE, int BLOCK_LENGTH>
3607template <class ALLOCATOR>
3608void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::moveInsertAndMoveToFront(
3609 Iterator *toBegin,
3610 Iterator fromBegin,
3611 Iterator position,
3612 bslmf::MovableRef<VALUE_TYPE> value,
3613 ALLOCATOR allocator,
3614 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
3615{
3616 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
3617 BLOCK_LENGTH,
3618 ALLOCATOR> ElementGuard;
3619
3620 size_type frontSize = position - fromBegin;
3621 Iterator begin = fromBegin;
3622 Iterator dest = begin - 1;
3623
3624 BSLS_ASSERT_SAFE(frontSize >= 1);
3625
3626 ElementGuard guard(dest, dest, allocator);
3627
3628 // 1. move-construct front-most element being bumped 1 slot
3629
3630 bsl::allocator_traits<ALLOCATOR>::construct(
3631 allocator,
3632 dest.valuePtr(),
3633 MoveUtil::move_if_noexcept(*begin));
3634 guard.moveEnd(1);
3635 ++dest;
3636 ++begin;
3637
3638 // 2. move-assign other existing elements being bumped forward 1 slot
3639
3640 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
3641 *dest = MoveUtil::move_if_noexcept(*begin);
3642 }
3643
3644 // 3. move-assign the new element
3645
3646 VALUE_TYPE& lvalue = value;
3647 *dest = MoveUtil::move(lvalue);
3648
3649 guard.release();
3650
3651 *toBegin = fromBegin - 1;
3652}
3653
3654#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
3655// {{{ BEGIN GENERATED CODE
3656// Command line: sim_cpp11_features.pl bslalg_dequeprimitives.h
3657#ifndef BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT
3658#define BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT 10
3659#endif
3660#ifndef BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B
3661#define BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT
3662#endif
3663#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
3664template <class VALUE_TYPE, int BLOCK_LENGTH>
3665template <class ALLOCATOR>
3666inline
3667void
3668DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
3669 Iterator *toEnd,
3670 Iterator fromEnd,
3671 Iterator position,
3672 ALLOCATOR allocator)
3673{
3674 enum {
3675 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3676 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3677
3678 VALUE = IS_BITWISECOPYABLE
3679 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3680 : IS_BITWISEMOVEABLE
3681 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3682 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3683 };
3684
3685 emplaceAndMoveToBackDispatch(
3686 toEnd,
3687 fromEnd,
3688 position,
3689 allocator,
3690 bsl::integral_constant<int, VALUE>());
3691}
3692#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
3693
3694#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
3695template <class VALUE_TYPE, int BLOCK_LENGTH>
3696template <class ALLOCATOR, class Args_01>
3697inline
3698void
3699DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
3700 Iterator *toEnd,
3701 Iterator fromEnd,
3702 Iterator position,
3703 ALLOCATOR allocator,
3704 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
3705{
3706 enum {
3707 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3708 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3709
3710 VALUE = IS_BITWISECOPYABLE
3711 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3712 : IS_BITWISEMOVEABLE
3713 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3714 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3715 };
3716
3717 emplaceAndMoveToBackDispatch(
3718 toEnd,
3719 fromEnd,
3720 position,
3721 allocator,
3722 bsl::integral_constant<int, VALUE>(),
3723 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
3724}
3725#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
3726
3727#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
3728template <class VALUE_TYPE, int BLOCK_LENGTH>
3729template <class ALLOCATOR, class Args_01,
3730 class Args_02>
3731inline
3732void
3733DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
3734 Iterator *toEnd,
3735 Iterator fromEnd,
3736 Iterator position,
3737 ALLOCATOR allocator,
3738 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
3739 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
3740{
3741 enum {
3742 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3743 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3744
3745 VALUE = IS_BITWISECOPYABLE
3746 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3747 : IS_BITWISEMOVEABLE
3748 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3749 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3750 };
3751
3752 emplaceAndMoveToBackDispatch(
3753 toEnd,
3754 fromEnd,
3755 position,
3756 allocator,
3757 bsl::integral_constant<int, VALUE>(),
3758 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
3759 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
3760}
3761#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
3762
3763#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
3764template <class VALUE_TYPE, int BLOCK_LENGTH>
3765template <class ALLOCATOR, class Args_01,
3766 class Args_02,
3767 class Args_03>
3768inline
3769void
3770DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
3771 Iterator *toEnd,
3772 Iterator fromEnd,
3773 Iterator position,
3774 ALLOCATOR allocator,
3775 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
3776 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
3777 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
3778{
3779 enum {
3780 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3781 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3782
3783 VALUE = IS_BITWISECOPYABLE
3784 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3785 : IS_BITWISEMOVEABLE
3786 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3787 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3788 };
3789
3790 emplaceAndMoveToBackDispatch(
3791 toEnd,
3792 fromEnd,
3793 position,
3794 allocator,
3795 bsl::integral_constant<int, VALUE>(),
3796 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
3797 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
3798 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
3799}
3800#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
3801
3802#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
3803template <class VALUE_TYPE, int BLOCK_LENGTH>
3804template <class ALLOCATOR, class Args_01,
3805 class Args_02,
3806 class Args_03,
3807 class Args_04>
3808inline
3809void
3810DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
3811 Iterator *toEnd,
3812 Iterator fromEnd,
3813 Iterator position,
3814 ALLOCATOR allocator,
3815 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
3816 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
3817 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
3818 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
3819{
3820 enum {
3821 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3822 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3823
3824 VALUE = IS_BITWISECOPYABLE
3825 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3826 : IS_BITWISEMOVEABLE
3827 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3828 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3829 };
3830
3831 emplaceAndMoveToBackDispatch(
3832 toEnd,
3833 fromEnd,
3834 position,
3835 allocator,
3836 bsl::integral_constant<int, VALUE>(),
3837 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
3838 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
3839 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
3840 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
3841}
3842#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
3843
3844#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
3845template <class VALUE_TYPE, int BLOCK_LENGTH>
3846template <class ALLOCATOR, class Args_01,
3847 class Args_02,
3848 class Args_03,
3849 class Args_04,
3850 class Args_05>
3851inline
3852void
3853DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
3854 Iterator *toEnd,
3855 Iterator fromEnd,
3856 Iterator position,
3857 ALLOCATOR allocator,
3858 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
3859 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
3860 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
3861 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
3862 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
3863{
3864 enum {
3865 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3866 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3867
3868 VALUE = IS_BITWISECOPYABLE
3869 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3870 : IS_BITWISEMOVEABLE
3871 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3872 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3873 };
3874
3875 emplaceAndMoveToBackDispatch(
3876 toEnd,
3877 fromEnd,
3878 position,
3879 allocator,
3880 bsl::integral_constant<int, VALUE>(),
3881 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
3882 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
3883 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
3884 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
3885 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
3886}
3887#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
3888
3889#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
3890template <class VALUE_TYPE, int BLOCK_LENGTH>
3891template <class ALLOCATOR, class Args_01,
3892 class Args_02,
3893 class Args_03,
3894 class Args_04,
3895 class Args_05,
3896 class Args_06>
3897inline
3898void
3899DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
3900 Iterator *toEnd,
3901 Iterator fromEnd,
3902 Iterator position,
3903 ALLOCATOR allocator,
3904 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
3905 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
3906 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
3907 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
3908 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
3909 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
3910{
3911 enum {
3912 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3913 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3914
3915 VALUE = IS_BITWISECOPYABLE
3916 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3917 : IS_BITWISEMOVEABLE
3918 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3919 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3920 };
3921
3922 emplaceAndMoveToBackDispatch(
3923 toEnd,
3924 fromEnd,
3925 position,
3926 allocator,
3927 bsl::integral_constant<int, VALUE>(),
3928 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
3929 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
3930 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
3931 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
3932 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
3933 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
3934}
3935#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
3936
3937#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
3938template <class VALUE_TYPE, int BLOCK_LENGTH>
3939template <class ALLOCATOR, class Args_01,
3940 class Args_02,
3941 class Args_03,
3942 class Args_04,
3943 class Args_05,
3944 class Args_06,
3945 class Args_07>
3946inline
3947void
3948DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
3949 Iterator *toEnd,
3950 Iterator fromEnd,
3951 Iterator position,
3952 ALLOCATOR allocator,
3953 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
3954 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
3955 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
3956 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
3957 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
3958 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
3959 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
3960{
3961 enum {
3962 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
3963 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
3964
3965 VALUE = IS_BITWISECOPYABLE
3966 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
3967 : IS_BITWISEMOVEABLE
3968 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
3969 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
3970 };
3971
3972 emplaceAndMoveToBackDispatch(
3973 toEnd,
3974 fromEnd,
3975 position,
3976 allocator,
3977 bsl::integral_constant<int, VALUE>(),
3978 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
3979 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
3980 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
3981 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
3982 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
3983 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
3984 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
3985}
3986#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
3987
3988#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
3989template <class VALUE_TYPE, int BLOCK_LENGTH>
3990template <class ALLOCATOR, class Args_01,
3991 class Args_02,
3992 class Args_03,
3993 class Args_04,
3994 class Args_05,
3995 class Args_06,
3996 class Args_07,
3997 class Args_08>
3998inline
3999void
4000DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
4001 Iterator *toEnd,
4002 Iterator fromEnd,
4003 Iterator position,
4004 ALLOCATOR allocator,
4005 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4006 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4007 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4008 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4009 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4010 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
4011 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
4012 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
4013{
4014 enum {
4015 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
4016 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
4017
4018 VALUE = IS_BITWISECOPYABLE
4019 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
4020 : IS_BITWISEMOVEABLE
4021 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
4022 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
4023 };
4024
4025 emplaceAndMoveToBackDispatch(
4026 toEnd,
4027 fromEnd,
4028 position,
4029 allocator,
4030 bsl::integral_constant<int, VALUE>(),
4031 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4032 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4033 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4034 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4035 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4036 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
4037 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
4038 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
4039}
4040#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
4041
4042#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
4043template <class VALUE_TYPE, int BLOCK_LENGTH>
4044template <class ALLOCATOR, class Args_01,
4045 class Args_02,
4046 class Args_03,
4047 class Args_04,
4048 class Args_05,
4049 class Args_06,
4050 class Args_07,
4051 class Args_08,
4052 class Args_09>
4053inline
4054void
4055DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
4056 Iterator *toEnd,
4057 Iterator fromEnd,
4058 Iterator position,
4059 ALLOCATOR allocator,
4060 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4061 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4062 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4063 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4064 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4065 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
4066 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
4067 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
4068 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
4069{
4070 enum {
4071 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
4072 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
4073
4074 VALUE = IS_BITWISECOPYABLE
4075 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
4076 : IS_BITWISEMOVEABLE
4077 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
4078 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
4079 };
4080
4081 emplaceAndMoveToBackDispatch(
4082 toEnd,
4083 fromEnd,
4084 position,
4085 allocator,
4086 bsl::integral_constant<int, VALUE>(),
4087 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4088 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4089 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4090 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4091 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4092 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
4093 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
4094 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
4095 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
4096}
4097#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
4098
4099#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
4100template <class VALUE_TYPE, int BLOCK_LENGTH>
4101template <class ALLOCATOR, class Args_01,
4102 class Args_02,
4103 class Args_03,
4104 class Args_04,
4105 class Args_05,
4106 class Args_06,
4107 class Args_07,
4108 class Args_08,
4109 class Args_09,
4110 class Args_10>
4111inline
4112void
4113DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
4114 Iterator *toEnd,
4115 Iterator fromEnd,
4116 Iterator position,
4117 ALLOCATOR allocator,
4118 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4119 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4120 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4121 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4122 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4123 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
4124 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
4125 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
4126 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
4127 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
4128{
4129 enum {
4130 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
4131 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
4132
4133 VALUE = IS_BITWISECOPYABLE
4134 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
4135 : IS_BITWISEMOVEABLE
4136 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
4137 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
4138 };
4139
4140 emplaceAndMoveToBackDispatch(
4141 toEnd,
4142 fromEnd,
4143 position,
4144 allocator,
4145 bsl::integral_constant<int, VALUE>(),
4146 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4147 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4148 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4149 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4150 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4151 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
4152 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
4153 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
4154 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
4155 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
4156}
4157#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
4158
4159
4160#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
4161template <class VALUE_TYPE, int BLOCK_LENGTH>
4162template <class ALLOCATOR>
4163void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4164 Iterator *toEnd,
4165 Iterator fromEnd,
4166 Iterator position,
4167 ALLOCATOR allocator,
4168 bsl::integral_constant<int,
4169 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>)
4170{
4171 const size_type backSize = fromEnd - position;
4172 Iterator end = fromEnd;
4173 Iterator dest = end + 1;
4174
4175
4176 moveBack(&dest, &end, backSize);
4177 --dest;
4178
4179 bsl::allocator_traits<ALLOCATOR>::construct(
4180 allocator,
4181 dest.valuePtr());
4182
4183 *toEnd = fromEnd + 1;
4184}
4185#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
4186
4187#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
4188template <class VALUE_TYPE, int BLOCK_LENGTH>
4189template <class ALLOCATOR, class Args_01>
4190void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4191 Iterator *toEnd,
4192 Iterator fromEnd,
4193 Iterator position,
4194 ALLOCATOR allocator,
4195 bsl::integral_constant<int,
4196 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4197 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
4198{
4199 const size_type backSize = fromEnd - position;
4200 Iterator end = fromEnd;
4201 Iterator dest = end + 1;
4202
4203
4204 moveBack(&dest, &end, backSize);
4205 --dest;
4206
4207 bsl::allocator_traits<ALLOCATOR>::construct(
4208 allocator,
4209 dest.valuePtr(),
4210 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
4211
4212 *toEnd = fromEnd + 1;
4213}
4214#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
4215
4216#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
4217template <class VALUE_TYPE, int BLOCK_LENGTH>
4218template <class ALLOCATOR, class Args_01,
4219 class Args_02>
4220void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4221 Iterator *toEnd,
4222 Iterator fromEnd,
4223 Iterator position,
4224 ALLOCATOR allocator,
4225 bsl::integral_constant<int,
4226 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4227 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4228 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
4229{
4230 const size_type backSize = fromEnd - position;
4231 Iterator end = fromEnd;
4232 Iterator dest = end + 1;
4233
4234
4235 moveBack(&dest, &end, backSize);
4236 --dest;
4237
4238 bsl::allocator_traits<ALLOCATOR>::construct(
4239 allocator,
4240 dest.valuePtr(),
4241 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4242 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
4243
4244 *toEnd = fromEnd + 1;
4245}
4246#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
4247
4248#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
4249template <class VALUE_TYPE, int BLOCK_LENGTH>
4250template <class ALLOCATOR, class Args_01,
4251 class Args_02,
4252 class Args_03>
4253void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4254 Iterator *toEnd,
4255 Iterator fromEnd,
4256 Iterator position,
4257 ALLOCATOR allocator,
4258 bsl::integral_constant<int,
4259 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4260 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4261 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4262 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
4263{
4264 const size_type backSize = fromEnd - position;
4265 Iterator end = fromEnd;
4266 Iterator dest = end + 1;
4267
4268
4269 moveBack(&dest, &end, backSize);
4270 --dest;
4271
4272 bsl::allocator_traits<ALLOCATOR>::construct(
4273 allocator,
4274 dest.valuePtr(),
4275 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4276 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4277 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
4278
4279 *toEnd = fromEnd + 1;
4280}
4281#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
4282
4283#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
4284template <class VALUE_TYPE, int BLOCK_LENGTH>
4285template <class ALLOCATOR, class Args_01,
4286 class Args_02,
4287 class Args_03,
4288 class Args_04>
4289void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4290 Iterator *toEnd,
4291 Iterator fromEnd,
4292 Iterator position,
4293 ALLOCATOR allocator,
4294 bsl::integral_constant<int,
4295 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4296 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4297 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4298 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4299 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
4300{
4301 const size_type backSize = fromEnd - position;
4302 Iterator end = fromEnd;
4303 Iterator dest = end + 1;
4304
4305
4306 moveBack(&dest, &end, backSize);
4307 --dest;
4308
4309 bsl::allocator_traits<ALLOCATOR>::construct(
4310 allocator,
4311 dest.valuePtr(),
4312 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4313 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4314 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4315 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
4316
4317 *toEnd = fromEnd + 1;
4318}
4319#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
4320
4321#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
4322template <class VALUE_TYPE, int BLOCK_LENGTH>
4323template <class ALLOCATOR, class Args_01,
4324 class Args_02,
4325 class Args_03,
4326 class Args_04,
4327 class Args_05>
4328void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4329 Iterator *toEnd,
4330 Iterator fromEnd,
4331 Iterator position,
4332 ALLOCATOR allocator,
4333 bsl::integral_constant<int,
4334 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4335 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4336 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4337 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4338 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4339 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
4340{
4341 const size_type backSize = fromEnd - position;
4342 Iterator end = fromEnd;
4343 Iterator dest = end + 1;
4344
4345
4346 moveBack(&dest, &end, backSize);
4347 --dest;
4348
4349 bsl::allocator_traits<ALLOCATOR>::construct(
4350 allocator,
4351 dest.valuePtr(),
4352 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4353 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4354 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4355 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4356 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
4357
4358 *toEnd = fromEnd + 1;
4359}
4360#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
4361
4362#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
4363template <class VALUE_TYPE, int BLOCK_LENGTH>
4364template <class ALLOCATOR, class Args_01,
4365 class Args_02,
4366 class Args_03,
4367 class Args_04,
4368 class Args_05,
4369 class Args_06>
4370void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4371 Iterator *toEnd,
4372 Iterator fromEnd,
4373 Iterator position,
4374 ALLOCATOR allocator,
4375 bsl::integral_constant<int,
4376 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4377 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4378 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4379 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4380 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4381 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4382 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
4383{
4384 const size_type backSize = fromEnd - position;
4385 Iterator end = fromEnd;
4386 Iterator dest = end + 1;
4387
4388
4389 moveBack(&dest, &end, backSize);
4390 --dest;
4391
4392 bsl::allocator_traits<ALLOCATOR>::construct(
4393 allocator,
4394 dest.valuePtr(),
4395 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4396 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4397 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4398 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4399 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4400 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
4401
4402 *toEnd = fromEnd + 1;
4403}
4404#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
4405
4406#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
4407template <class VALUE_TYPE, int BLOCK_LENGTH>
4408template <class ALLOCATOR, class Args_01,
4409 class Args_02,
4410 class Args_03,
4411 class Args_04,
4412 class Args_05,
4413 class Args_06,
4414 class Args_07>
4415void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4416 Iterator *toEnd,
4417 Iterator fromEnd,
4418 Iterator position,
4419 ALLOCATOR allocator,
4420 bsl::integral_constant<int,
4421 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4422 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4423 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4424 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4425 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4426 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4427 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
4428 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
4429{
4430 const size_type backSize = fromEnd - position;
4431 Iterator end = fromEnd;
4432 Iterator dest = end + 1;
4433
4434
4435 moveBack(&dest, &end, backSize);
4436 --dest;
4437
4438 bsl::allocator_traits<ALLOCATOR>::construct(
4439 allocator,
4440 dest.valuePtr(),
4441 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4442 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4443 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4444 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4445 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4446 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
4447 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
4448
4449 *toEnd = fromEnd + 1;
4450}
4451#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
4452
4453#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
4454template <class VALUE_TYPE, int BLOCK_LENGTH>
4455template <class ALLOCATOR, class Args_01,
4456 class Args_02,
4457 class Args_03,
4458 class Args_04,
4459 class Args_05,
4460 class Args_06,
4461 class Args_07,
4462 class Args_08>
4463void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4464 Iterator *toEnd,
4465 Iterator fromEnd,
4466 Iterator position,
4467 ALLOCATOR allocator,
4468 bsl::integral_constant<int,
4469 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4470 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4471 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4472 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4473 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4474 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4475 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
4476 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
4477 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
4478{
4479 const size_type backSize = fromEnd - position;
4480 Iterator end = fromEnd;
4481 Iterator dest = end + 1;
4482
4483
4484 moveBack(&dest, &end, backSize);
4485 --dest;
4486
4487 bsl::allocator_traits<ALLOCATOR>::construct(
4488 allocator,
4489 dest.valuePtr(),
4490 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4491 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4492 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4493 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4494 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4495 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
4496 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
4497 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
4498
4499 *toEnd = fromEnd + 1;
4500}
4501#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
4502
4503#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
4504template <class VALUE_TYPE, int BLOCK_LENGTH>
4505template <class ALLOCATOR, class Args_01,
4506 class Args_02,
4507 class Args_03,
4508 class Args_04,
4509 class Args_05,
4510 class Args_06,
4511 class Args_07,
4512 class Args_08,
4513 class Args_09>
4514void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4515 Iterator *toEnd,
4516 Iterator fromEnd,
4517 Iterator position,
4518 ALLOCATOR allocator,
4519 bsl::integral_constant<int,
4520 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4521 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4522 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4523 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4524 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4525 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4526 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
4527 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
4528 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
4529 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
4530{
4531 const size_type backSize = fromEnd - position;
4532 Iterator end = fromEnd;
4533 Iterator dest = end + 1;
4534
4535
4536 moveBack(&dest, &end, backSize);
4537 --dest;
4538
4539 bsl::allocator_traits<ALLOCATOR>::construct(
4540 allocator,
4541 dest.valuePtr(),
4542 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4543 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4544 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4545 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4546 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4547 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
4548 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
4549 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
4550 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
4551
4552 *toEnd = fromEnd + 1;
4553}
4554#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
4555
4556#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
4557template <class VALUE_TYPE, int BLOCK_LENGTH>
4558template <class ALLOCATOR, class Args_01,
4559 class Args_02,
4560 class Args_03,
4561 class Args_04,
4562 class Args_05,
4563 class Args_06,
4564 class Args_07,
4565 class Args_08,
4566 class Args_09,
4567 class Args_10>
4568void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4569 Iterator *toEnd,
4570 Iterator fromEnd,
4571 Iterator position,
4572 ALLOCATOR allocator,
4573 bsl::integral_constant<int,
4574 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
4575 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4576 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4577 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4578 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4579 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4580 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
4581 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
4582 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
4583 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
4584 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
4585{
4586 const size_type backSize = fromEnd - position;
4587 Iterator end = fromEnd;
4588 Iterator dest = end + 1;
4589
4590
4591 moveBack(&dest, &end, backSize);
4592 --dest;
4593
4594 bsl::allocator_traits<ALLOCATOR>::construct(
4595 allocator,
4596 dest.valuePtr(),
4597 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4598 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4599 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4600 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4601 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4602 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
4603 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
4604 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
4605 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
4606 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
4607
4608 *toEnd = fromEnd + 1;
4609}
4610#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
4611
4612
4613#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
4614template <class VALUE_TYPE, int BLOCK_LENGTH>
4615template <class ALLOCATOR>
4616void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4617 Iterator *toEnd,
4618 Iterator fromEnd,
4619 Iterator position,
4620 ALLOCATOR allocator,
4621 bsl::integral_constant<int,
4622 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>)
4623{
4624 const size_type backSize = fromEnd - position;
4625 Iterator end = fromEnd;
4626 Iterator dest = end + 1;
4627
4628
4629 MoveGuard guard(end, dest, backSize, false);
4630
4631 moveBack(&dest, &end, backSize);
4632 --dest;
4633
4634 bsl::allocator_traits<ALLOCATOR>::construct(
4635 allocator,
4636 dest.valuePtr());
4637
4638 guard.release();
4639
4640 *toEnd = fromEnd + 1;
4641}
4642#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
4643
4644#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
4645template <class VALUE_TYPE, int BLOCK_LENGTH>
4646template <class ALLOCATOR, class Args_01>
4647void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4648 Iterator *toEnd,
4649 Iterator fromEnd,
4650 Iterator position,
4651 ALLOCATOR allocator,
4652 bsl::integral_constant<int,
4653 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
4654 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
4655{
4656 const size_type backSize = fromEnd - position;
4657 Iterator end = fromEnd;
4658 Iterator dest = end + 1;
4659
4660
4661 MoveGuard guard(end, dest, backSize, false);
4662
4663 moveBack(&dest, &end, backSize);
4664 --dest;
4665
4666 bsl::allocator_traits<ALLOCATOR>::construct(
4667 allocator,
4668 dest.valuePtr(),
4669 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
4670
4671 guard.release();
4672
4673 *toEnd = fromEnd + 1;
4674}
4675#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
4676
4677#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
4678template <class VALUE_TYPE, int BLOCK_LENGTH>
4679template <class ALLOCATOR, class Args_01,
4680 class Args_02>
4681void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4682 Iterator *toEnd,
4683 Iterator fromEnd,
4684 Iterator position,
4685 ALLOCATOR allocator,
4686 bsl::integral_constant<int,
4687 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
4688 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4689 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
4690{
4691 const size_type backSize = fromEnd - position;
4692 Iterator end = fromEnd;
4693 Iterator dest = end + 1;
4694
4695
4696 MoveGuard guard(end, dest, backSize, false);
4697
4698 moveBack(&dest, &end, backSize);
4699 --dest;
4700
4701 bsl::allocator_traits<ALLOCATOR>::construct(
4702 allocator,
4703 dest.valuePtr(),
4704 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4705 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
4706
4707 guard.release();
4708
4709 *toEnd = fromEnd + 1;
4710}
4711#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
4712
4713#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
4714template <class VALUE_TYPE, int BLOCK_LENGTH>
4715template <class ALLOCATOR, class Args_01,
4716 class Args_02,
4717 class Args_03>
4718void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4719 Iterator *toEnd,
4720 Iterator fromEnd,
4721 Iterator position,
4722 ALLOCATOR allocator,
4723 bsl::integral_constant<int,
4724 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
4725 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4726 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4727 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
4728{
4729 const size_type backSize = fromEnd - position;
4730 Iterator end = fromEnd;
4731 Iterator dest = end + 1;
4732
4733
4734 MoveGuard guard(end, dest, backSize, false);
4735
4736 moveBack(&dest, &end, backSize);
4737 --dest;
4738
4739 bsl::allocator_traits<ALLOCATOR>::construct(
4740 allocator,
4741 dest.valuePtr(),
4742 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4743 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4744 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
4745
4746 guard.release();
4747
4748 *toEnd = fromEnd + 1;
4749}
4750#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
4751
4752#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
4753template <class VALUE_TYPE, int BLOCK_LENGTH>
4754template <class ALLOCATOR, class Args_01,
4755 class Args_02,
4756 class Args_03,
4757 class Args_04>
4758void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4759 Iterator *toEnd,
4760 Iterator fromEnd,
4761 Iterator position,
4762 ALLOCATOR allocator,
4763 bsl::integral_constant<int,
4764 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
4765 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4766 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4767 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4768 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
4769{
4770 const size_type backSize = fromEnd - position;
4771 Iterator end = fromEnd;
4772 Iterator dest = end + 1;
4773
4774
4775 MoveGuard guard(end, dest, backSize, false);
4776
4777 moveBack(&dest, &end, backSize);
4778 --dest;
4779
4780 bsl::allocator_traits<ALLOCATOR>::construct(
4781 allocator,
4782 dest.valuePtr(),
4783 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4784 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4785 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4786 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
4787
4788 guard.release();
4789
4790 *toEnd = fromEnd + 1;
4791}
4792#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
4793
4794#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
4795template <class VALUE_TYPE, int BLOCK_LENGTH>
4796template <class ALLOCATOR, class Args_01,
4797 class Args_02,
4798 class Args_03,
4799 class Args_04,
4800 class Args_05>
4801void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4802 Iterator *toEnd,
4803 Iterator fromEnd,
4804 Iterator position,
4805 ALLOCATOR allocator,
4806 bsl::integral_constant<int,
4807 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
4808 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4809 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4810 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4811 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4812 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
4813{
4814 const size_type backSize = fromEnd - position;
4815 Iterator end = fromEnd;
4816 Iterator dest = end + 1;
4817
4818
4819 MoveGuard guard(end, dest, backSize, false);
4820
4821 moveBack(&dest, &end, backSize);
4822 --dest;
4823
4824 bsl::allocator_traits<ALLOCATOR>::construct(
4825 allocator,
4826 dest.valuePtr(),
4827 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4828 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4829 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4830 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4831 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
4832
4833 guard.release();
4834
4835 *toEnd = fromEnd + 1;
4836}
4837#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
4838
4839#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
4840template <class VALUE_TYPE, int BLOCK_LENGTH>
4841template <class ALLOCATOR, class Args_01,
4842 class Args_02,
4843 class Args_03,
4844 class Args_04,
4845 class Args_05,
4846 class Args_06>
4847void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4848 Iterator *toEnd,
4849 Iterator fromEnd,
4850 Iterator position,
4851 ALLOCATOR allocator,
4852 bsl::integral_constant<int,
4853 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
4854 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4855 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4856 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4857 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4858 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4859 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
4860{
4861 const size_type backSize = fromEnd - position;
4862 Iterator end = fromEnd;
4863 Iterator dest = end + 1;
4864
4865
4866 MoveGuard guard(end, dest, backSize, false);
4867
4868 moveBack(&dest, &end, backSize);
4869 --dest;
4870
4871 bsl::allocator_traits<ALLOCATOR>::construct(
4872 allocator,
4873 dest.valuePtr(),
4874 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4875 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4876 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4877 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4878 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4879 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
4880
4881 guard.release();
4882
4883 *toEnd = fromEnd + 1;
4884}
4885#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
4886
4887#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
4888template <class VALUE_TYPE, int BLOCK_LENGTH>
4889template <class ALLOCATOR, class Args_01,
4890 class Args_02,
4891 class Args_03,
4892 class Args_04,
4893 class Args_05,
4894 class Args_06,
4895 class Args_07>
4896void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4897 Iterator *toEnd,
4898 Iterator fromEnd,
4899 Iterator position,
4900 ALLOCATOR allocator,
4901 bsl::integral_constant<int,
4902 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
4903 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4904 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4905 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4906 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4907 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4908 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
4909 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
4910{
4911 const size_type backSize = fromEnd - position;
4912 Iterator end = fromEnd;
4913 Iterator dest = end + 1;
4914
4915
4916 MoveGuard guard(end, dest, backSize, false);
4917
4918 moveBack(&dest, &end, backSize);
4919 --dest;
4920
4921 bsl::allocator_traits<ALLOCATOR>::construct(
4922 allocator,
4923 dest.valuePtr(),
4924 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4925 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4926 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4927 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4928 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4929 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
4930 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
4931
4932 guard.release();
4933
4934 *toEnd = fromEnd + 1;
4935}
4936#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
4937
4938#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
4939template <class VALUE_TYPE, int BLOCK_LENGTH>
4940template <class ALLOCATOR, class Args_01,
4941 class Args_02,
4942 class Args_03,
4943 class Args_04,
4944 class Args_05,
4945 class Args_06,
4946 class Args_07,
4947 class Args_08>
4948void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
4949 Iterator *toEnd,
4950 Iterator fromEnd,
4951 Iterator position,
4952 ALLOCATOR allocator,
4953 bsl::integral_constant<int,
4954 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
4955 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
4956 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
4957 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
4958 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
4959 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
4960 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
4961 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
4962 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
4963{
4964 const size_type backSize = fromEnd - position;
4965 Iterator end = fromEnd;
4966 Iterator dest = end + 1;
4967
4968
4969 MoveGuard guard(end, dest, backSize, false);
4970
4971 moveBack(&dest, &end, backSize);
4972 --dest;
4973
4974 bsl::allocator_traits<ALLOCATOR>::construct(
4975 allocator,
4976 dest.valuePtr(),
4977 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
4978 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
4979 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
4980 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
4981 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
4982 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
4983 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
4984 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
4985
4986 guard.release();
4987
4988 *toEnd = fromEnd + 1;
4989}
4990#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
4991
4992#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
4993template <class VALUE_TYPE, int BLOCK_LENGTH>
4994template <class ALLOCATOR, class Args_01,
4995 class Args_02,
4996 class Args_03,
4997 class Args_04,
4998 class Args_05,
4999 class Args_06,
5000 class Args_07,
5001 class Args_08,
5002 class Args_09>
5003void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5004 Iterator *toEnd,
5005 Iterator fromEnd,
5006 Iterator position,
5007 ALLOCATOR allocator,
5008 bsl::integral_constant<int,
5009 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
5010 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5011 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5012 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
5013 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
5014 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
5015 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
5016 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
5017 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
5018 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
5019{
5020 const size_type backSize = fromEnd - position;
5021 Iterator end = fromEnd;
5022 Iterator dest = end + 1;
5023
5024
5025 MoveGuard guard(end, dest, backSize, false);
5026
5027 moveBack(&dest, &end, backSize);
5028 --dest;
5029
5030 bsl::allocator_traits<ALLOCATOR>::construct(
5031 allocator,
5032 dest.valuePtr(),
5033 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5034 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5035 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
5036 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
5037 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
5038 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
5039 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
5040 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
5041 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
5042
5043 guard.release();
5044
5045 *toEnd = fromEnd + 1;
5046}
5047#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
5048
5049#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
5050template <class VALUE_TYPE, int BLOCK_LENGTH>
5051template <class ALLOCATOR, class Args_01,
5052 class Args_02,
5053 class Args_03,
5054 class Args_04,
5055 class Args_05,
5056 class Args_06,
5057 class Args_07,
5058 class Args_08,
5059 class Args_09,
5060 class Args_10>
5061void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5062 Iterator *toEnd,
5063 Iterator fromEnd,
5064 Iterator position,
5065 ALLOCATOR allocator,
5066 bsl::integral_constant<int,
5067 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
5068 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5069 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5070 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
5071 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
5072 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
5073 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
5074 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
5075 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
5076 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
5077 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
5078{
5079 const size_type backSize = fromEnd - position;
5080 Iterator end = fromEnd;
5081 Iterator dest = end + 1;
5082
5083
5084 MoveGuard guard(end, dest, backSize, false);
5085
5086 moveBack(&dest, &end, backSize);
5087 --dest;
5088
5089 bsl::allocator_traits<ALLOCATOR>::construct(
5090 allocator,
5091 dest.valuePtr(),
5092 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5093 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5094 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
5095 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
5096 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
5097 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
5098 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
5099 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
5100 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
5101 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
5102
5103 guard.release();
5104
5105 *toEnd = fromEnd + 1;
5106}
5107#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
5108
5109
5110#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
5111template <class VALUE_TYPE, int BLOCK_LENGTH>
5112template <class ALLOCATOR>
5113void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5114 Iterator *toEnd,
5115 Iterator fromEnd,
5116 Iterator position,
5117 ALLOCATOR allocator,
5118 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
5119{
5120 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5121 BLOCK_LENGTH,
5122 ALLOCATOR> ElementGuard;
5123
5124 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5125 BLOCK_LENGTH> EndpointProctor;
5126
5127 size_type backSize = fromEnd - position;
5128 Iterator end = fromEnd;
5129 Iterator dest = end + 1;
5130
5131 BSLS_ASSERT_SAFE(backSize >= 1);
5132
5133 ElementGuard guard(dest, dest, allocator);
5134
5135
5136 --dest;
5137 --end;
5138 bsl::allocator_traits<ALLOCATOR>::construct(
5139 allocator,
5140 dest.valuePtr(),
5141 MoveUtil::move_if_noexcept(*end));
5142 guard.moveBegin(-1);
5143
5144
5145 size_type n = 0;
5146 for (backSize -= 1; 0 < backSize; --backSize) {
5147 --dest;
5148 --end;
5149 *dest = MoveUtil::move_if_noexcept(*end);
5150 ++n;
5151 }
5152 guard.moveBegin(-n);
5153
5154
5155 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5156
5157
5158
5159 EndpointProctor endpointProctor(toEnd, position);
5160
5161 bsl::allocator_traits<ALLOCATOR>::construct(
5162 allocator,
5163 position.valuePtr());
5164
5165 endpointProctor.release();
5166 guard.release();
5167
5168 *toEnd = fromEnd + 1;
5169}
5170#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
5171
5172#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
5173template <class VALUE_TYPE, int BLOCK_LENGTH>
5174template <class ALLOCATOR, class Args_01>
5175void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5176 Iterator *toEnd,
5177 Iterator fromEnd,
5178 Iterator position,
5179 ALLOCATOR allocator,
5180 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5181 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
5182{
5183 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5184 BLOCK_LENGTH,
5185 ALLOCATOR> ElementGuard;
5186
5187 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5188 BLOCK_LENGTH> EndpointProctor;
5189
5190 size_type backSize = fromEnd - position;
5191 Iterator end = fromEnd;
5192 Iterator dest = end + 1;
5193
5194 BSLS_ASSERT_SAFE(backSize >= 1);
5195
5196 ElementGuard guard(dest, dest, allocator);
5197
5198
5199 --dest;
5200 --end;
5201 bsl::allocator_traits<ALLOCATOR>::construct(
5202 allocator,
5203 dest.valuePtr(),
5204 MoveUtil::move_if_noexcept(*end));
5205 guard.moveBegin(-1);
5206
5207
5208 size_type n = 0;
5209 for (backSize -= 1; 0 < backSize; --backSize) {
5210 --dest;
5211 --end;
5212 *dest = MoveUtil::move_if_noexcept(*end);
5213 ++n;
5214 }
5215 guard.moveBegin(-n);
5216
5217
5218 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5219
5220
5221
5222 EndpointProctor endpointProctor(toEnd, position);
5223
5224 bsl::allocator_traits<ALLOCATOR>::construct(
5225 allocator,
5226 position.valuePtr(),
5227 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
5228
5229 endpointProctor.release();
5230 guard.release();
5231
5232 *toEnd = fromEnd + 1;
5233}
5234#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
5235
5236#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
5237template <class VALUE_TYPE, int BLOCK_LENGTH>
5238template <class ALLOCATOR, class Args_01,
5239 class Args_02>
5240void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5241 Iterator *toEnd,
5242 Iterator fromEnd,
5243 Iterator position,
5244 ALLOCATOR allocator,
5245 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5246 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5247 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
5248{
5249 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5250 BLOCK_LENGTH,
5251 ALLOCATOR> ElementGuard;
5252
5253 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5254 BLOCK_LENGTH> EndpointProctor;
5255
5256 size_type backSize = fromEnd - position;
5257 Iterator end = fromEnd;
5258 Iterator dest = end + 1;
5259
5260 BSLS_ASSERT_SAFE(backSize >= 1);
5261
5262 ElementGuard guard(dest, dest, allocator);
5263
5264
5265 --dest;
5266 --end;
5267 bsl::allocator_traits<ALLOCATOR>::construct(
5268 allocator,
5269 dest.valuePtr(),
5270 MoveUtil::move_if_noexcept(*end));
5271 guard.moveBegin(-1);
5272
5273
5274 size_type n = 0;
5275 for (backSize -= 1; 0 < backSize; --backSize) {
5276 --dest;
5277 --end;
5278 *dest = MoveUtil::move_if_noexcept(*end);
5279 ++n;
5280 }
5281 guard.moveBegin(-n);
5282
5283
5284 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5285
5286
5287
5288 EndpointProctor endpointProctor(toEnd, position);
5289
5290 bsl::allocator_traits<ALLOCATOR>::construct(
5291 allocator,
5292 position.valuePtr(),
5293 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5294 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
5295
5296 endpointProctor.release();
5297 guard.release();
5298
5299 *toEnd = fromEnd + 1;
5300}
5301#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
5302
5303#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
5304template <class VALUE_TYPE, int BLOCK_LENGTH>
5305template <class ALLOCATOR, class Args_01,
5306 class Args_02,
5307 class Args_03>
5308void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5309 Iterator *toEnd,
5310 Iterator fromEnd,
5311 Iterator position,
5312 ALLOCATOR allocator,
5313 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5314 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5315 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5316 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
5317{
5318 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5319 BLOCK_LENGTH,
5320 ALLOCATOR> ElementGuard;
5321
5322 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5323 BLOCK_LENGTH> EndpointProctor;
5324
5325 size_type backSize = fromEnd - position;
5326 Iterator end = fromEnd;
5327 Iterator dest = end + 1;
5328
5329 BSLS_ASSERT_SAFE(backSize >= 1);
5330
5331 ElementGuard guard(dest, dest, allocator);
5332
5333
5334 --dest;
5335 --end;
5336 bsl::allocator_traits<ALLOCATOR>::construct(
5337 allocator,
5338 dest.valuePtr(),
5339 MoveUtil::move_if_noexcept(*end));
5340 guard.moveBegin(-1);
5341
5342
5343 size_type n = 0;
5344 for (backSize -= 1; 0 < backSize; --backSize) {
5345 --dest;
5346 --end;
5347 *dest = MoveUtil::move_if_noexcept(*end);
5348 ++n;
5349 }
5350 guard.moveBegin(-n);
5351
5352
5353 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5354
5355
5356
5357 EndpointProctor endpointProctor(toEnd, position);
5358
5359 bsl::allocator_traits<ALLOCATOR>::construct(
5360 allocator,
5361 position.valuePtr(),
5362 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5363 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5364 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
5365
5366 endpointProctor.release();
5367 guard.release();
5368
5369 *toEnd = fromEnd + 1;
5370}
5371#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
5372
5373#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
5374template <class VALUE_TYPE, int BLOCK_LENGTH>
5375template <class ALLOCATOR, class Args_01,
5376 class Args_02,
5377 class Args_03,
5378 class Args_04>
5379void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5380 Iterator *toEnd,
5381 Iterator fromEnd,
5382 Iterator position,
5383 ALLOCATOR allocator,
5384 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5385 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5386 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5387 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
5388 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
5389{
5390 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5391 BLOCK_LENGTH,
5392 ALLOCATOR> ElementGuard;
5393
5394 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5395 BLOCK_LENGTH> EndpointProctor;
5396
5397 size_type backSize = fromEnd - position;
5398 Iterator end = fromEnd;
5399 Iterator dest = end + 1;
5400
5401 BSLS_ASSERT_SAFE(backSize >= 1);
5402
5403 ElementGuard guard(dest, dest, allocator);
5404
5405
5406 --dest;
5407 --end;
5408 bsl::allocator_traits<ALLOCATOR>::construct(
5409 allocator,
5410 dest.valuePtr(),
5411 MoveUtil::move_if_noexcept(*end));
5412 guard.moveBegin(-1);
5413
5414
5415 size_type n = 0;
5416 for (backSize -= 1; 0 < backSize; --backSize) {
5417 --dest;
5418 --end;
5419 *dest = MoveUtil::move_if_noexcept(*end);
5420 ++n;
5421 }
5422 guard.moveBegin(-n);
5423
5424
5425 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5426
5427
5428
5429 EndpointProctor endpointProctor(toEnd, position);
5430
5431 bsl::allocator_traits<ALLOCATOR>::construct(
5432 allocator,
5433 position.valuePtr(),
5434 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5435 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5436 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
5437 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
5438
5439 endpointProctor.release();
5440 guard.release();
5441
5442 *toEnd = fromEnd + 1;
5443}
5444#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
5445
5446#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
5447template <class VALUE_TYPE, int BLOCK_LENGTH>
5448template <class ALLOCATOR, class Args_01,
5449 class Args_02,
5450 class Args_03,
5451 class Args_04,
5452 class Args_05>
5453void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5454 Iterator *toEnd,
5455 Iterator fromEnd,
5456 Iterator position,
5457 ALLOCATOR allocator,
5458 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5459 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5460 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5461 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
5462 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
5463 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
5464{
5465 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5466 BLOCK_LENGTH,
5467 ALLOCATOR> ElementGuard;
5468
5469 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5470 BLOCK_LENGTH> EndpointProctor;
5471
5472 size_type backSize = fromEnd - position;
5473 Iterator end = fromEnd;
5474 Iterator dest = end + 1;
5475
5476 BSLS_ASSERT_SAFE(backSize >= 1);
5477
5478 ElementGuard guard(dest, dest, allocator);
5479
5480
5481 --dest;
5482 --end;
5483 bsl::allocator_traits<ALLOCATOR>::construct(
5484 allocator,
5485 dest.valuePtr(),
5486 MoveUtil::move_if_noexcept(*end));
5487 guard.moveBegin(-1);
5488
5489
5490 size_type n = 0;
5491 for (backSize -= 1; 0 < backSize; --backSize) {
5492 --dest;
5493 --end;
5494 *dest = MoveUtil::move_if_noexcept(*end);
5495 ++n;
5496 }
5497 guard.moveBegin(-n);
5498
5499
5500 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5501
5502
5503
5504 EndpointProctor endpointProctor(toEnd, position);
5505
5506 bsl::allocator_traits<ALLOCATOR>::construct(
5507 allocator,
5508 position.valuePtr(),
5509 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5510 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5511 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
5512 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
5513 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
5514
5515 endpointProctor.release();
5516 guard.release();
5517
5518 *toEnd = fromEnd + 1;
5519}
5520#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
5521
5522#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
5523template <class VALUE_TYPE, int BLOCK_LENGTH>
5524template <class ALLOCATOR, class Args_01,
5525 class Args_02,
5526 class Args_03,
5527 class Args_04,
5528 class Args_05,
5529 class Args_06>
5530void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5531 Iterator *toEnd,
5532 Iterator fromEnd,
5533 Iterator position,
5534 ALLOCATOR allocator,
5535 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5536 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5537 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5538 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
5539 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
5540 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
5541 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
5542{
5543 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5544 BLOCK_LENGTH,
5545 ALLOCATOR> ElementGuard;
5546
5547 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5548 BLOCK_LENGTH> EndpointProctor;
5549
5550 size_type backSize = fromEnd - position;
5551 Iterator end = fromEnd;
5552 Iterator dest = end + 1;
5553
5554 BSLS_ASSERT_SAFE(backSize >= 1);
5555
5556 ElementGuard guard(dest, dest, allocator);
5557
5558
5559 --dest;
5560 --end;
5561 bsl::allocator_traits<ALLOCATOR>::construct(
5562 allocator,
5563 dest.valuePtr(),
5564 MoveUtil::move_if_noexcept(*end));
5565 guard.moveBegin(-1);
5566
5567
5568 size_type n = 0;
5569 for (backSize -= 1; 0 < backSize; --backSize) {
5570 --dest;
5571 --end;
5572 *dest = MoveUtil::move_if_noexcept(*end);
5573 ++n;
5574 }
5575 guard.moveBegin(-n);
5576
5577
5578 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5579
5580
5581
5582 EndpointProctor endpointProctor(toEnd, position);
5583
5584 bsl::allocator_traits<ALLOCATOR>::construct(
5585 allocator,
5586 position.valuePtr(),
5587 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5588 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5589 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
5590 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
5591 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
5592 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
5593
5594 endpointProctor.release();
5595 guard.release();
5596
5597 *toEnd = fromEnd + 1;
5598}
5599#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
5600
5601#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
5602template <class VALUE_TYPE, int BLOCK_LENGTH>
5603template <class ALLOCATOR, class Args_01,
5604 class Args_02,
5605 class Args_03,
5606 class Args_04,
5607 class Args_05,
5608 class Args_06,
5609 class Args_07>
5610void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5611 Iterator *toEnd,
5612 Iterator fromEnd,
5613 Iterator position,
5614 ALLOCATOR allocator,
5615 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5616 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5617 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5618 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
5619 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
5620 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
5621 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
5622 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
5623{
5624 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5625 BLOCK_LENGTH,
5626 ALLOCATOR> ElementGuard;
5627
5628 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5629 BLOCK_LENGTH> EndpointProctor;
5630
5631 size_type backSize = fromEnd - position;
5632 Iterator end = fromEnd;
5633 Iterator dest = end + 1;
5634
5635 BSLS_ASSERT_SAFE(backSize >= 1);
5636
5637 ElementGuard guard(dest, dest, allocator);
5638
5639
5640 --dest;
5641 --end;
5642 bsl::allocator_traits<ALLOCATOR>::construct(
5643 allocator,
5644 dest.valuePtr(),
5645 MoveUtil::move_if_noexcept(*end));
5646 guard.moveBegin(-1);
5647
5648
5649 size_type n = 0;
5650 for (backSize -= 1; 0 < backSize; --backSize) {
5651 --dest;
5652 --end;
5653 *dest = MoveUtil::move_if_noexcept(*end);
5654 ++n;
5655 }
5656 guard.moveBegin(-n);
5657
5658
5659 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5660
5661
5662
5663 EndpointProctor endpointProctor(toEnd, position);
5664
5665 bsl::allocator_traits<ALLOCATOR>::construct(
5666 allocator,
5667 position.valuePtr(),
5668 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5669 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5670 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
5671 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
5672 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
5673 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
5674 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
5675
5676 endpointProctor.release();
5677 guard.release();
5678
5679 *toEnd = fromEnd + 1;
5680}
5681#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
5682
5683#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
5684template <class VALUE_TYPE, int BLOCK_LENGTH>
5685template <class ALLOCATOR, class Args_01,
5686 class Args_02,
5687 class Args_03,
5688 class Args_04,
5689 class Args_05,
5690 class Args_06,
5691 class Args_07,
5692 class Args_08>
5693void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5694 Iterator *toEnd,
5695 Iterator fromEnd,
5696 Iterator position,
5697 ALLOCATOR allocator,
5698 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5699 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5700 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5701 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
5702 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
5703 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
5704 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
5705 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
5706 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
5707{
5708 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5709 BLOCK_LENGTH,
5710 ALLOCATOR> ElementGuard;
5711
5712 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5713 BLOCK_LENGTH> EndpointProctor;
5714
5715 size_type backSize = fromEnd - position;
5716 Iterator end = fromEnd;
5717 Iterator dest = end + 1;
5718
5719 BSLS_ASSERT_SAFE(backSize >= 1);
5720
5721 ElementGuard guard(dest, dest, allocator);
5722
5723
5724 --dest;
5725 --end;
5726 bsl::allocator_traits<ALLOCATOR>::construct(
5727 allocator,
5728 dest.valuePtr(),
5729 MoveUtil::move_if_noexcept(*end));
5730 guard.moveBegin(-1);
5731
5732
5733 size_type n = 0;
5734 for (backSize -= 1; 0 < backSize; --backSize) {
5735 --dest;
5736 --end;
5737 *dest = MoveUtil::move_if_noexcept(*end);
5738 ++n;
5739 }
5740 guard.moveBegin(-n);
5741
5742
5743 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5744
5745
5746
5747 EndpointProctor endpointProctor(toEnd, position);
5748
5749 bsl::allocator_traits<ALLOCATOR>::construct(
5750 allocator,
5751 position.valuePtr(),
5752 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5753 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5754 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
5755 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
5756 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
5757 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
5758 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
5759 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
5760
5761 endpointProctor.release();
5762 guard.release();
5763
5764 *toEnd = fromEnd + 1;
5765}
5766#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
5767
5768#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
5769template <class VALUE_TYPE, int BLOCK_LENGTH>
5770template <class ALLOCATOR, class Args_01,
5771 class Args_02,
5772 class Args_03,
5773 class Args_04,
5774 class Args_05,
5775 class Args_06,
5776 class Args_07,
5777 class Args_08,
5778 class Args_09>
5779void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5780 Iterator *toEnd,
5781 Iterator fromEnd,
5782 Iterator position,
5783 ALLOCATOR allocator,
5784 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5785 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5786 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5787 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
5788 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
5789 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
5790 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
5791 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
5792 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
5793 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
5794{
5795 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5796 BLOCK_LENGTH,
5797 ALLOCATOR> ElementGuard;
5798
5799 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5800 BLOCK_LENGTH> EndpointProctor;
5801
5802 size_type backSize = fromEnd - position;
5803 Iterator end = fromEnd;
5804 Iterator dest = end + 1;
5805
5806 BSLS_ASSERT_SAFE(backSize >= 1);
5807
5808 ElementGuard guard(dest, dest, allocator);
5809
5810
5811 --dest;
5812 --end;
5813 bsl::allocator_traits<ALLOCATOR>::construct(
5814 allocator,
5815 dest.valuePtr(),
5816 MoveUtil::move_if_noexcept(*end));
5817 guard.moveBegin(-1);
5818
5819
5820 size_type n = 0;
5821 for (backSize -= 1; 0 < backSize; --backSize) {
5822 --dest;
5823 --end;
5824 *dest = MoveUtil::move_if_noexcept(*end);
5825 ++n;
5826 }
5827 guard.moveBegin(-n);
5828
5829
5830 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5831
5832
5833
5834 EndpointProctor endpointProctor(toEnd, position);
5835
5836 bsl::allocator_traits<ALLOCATOR>::construct(
5837 allocator,
5838 position.valuePtr(),
5839 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5840 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5841 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
5842 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
5843 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
5844 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
5845 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
5846 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
5847 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
5848
5849 endpointProctor.release();
5850 guard.release();
5851
5852 *toEnd = fromEnd + 1;
5853}
5854#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
5855
5856#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
5857template <class VALUE_TYPE, int BLOCK_LENGTH>
5858template <class ALLOCATOR, class Args_01,
5859 class Args_02,
5860 class Args_03,
5861 class Args_04,
5862 class Args_05,
5863 class Args_06,
5864 class Args_07,
5865 class Args_08,
5866 class Args_09,
5867 class Args_10>
5868void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
5869 Iterator *toEnd,
5870 Iterator fromEnd,
5871 Iterator position,
5872 ALLOCATOR allocator,
5873 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
5874 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
5875 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
5876 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
5877 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
5878 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
5879 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
5880 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
5881 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
5882 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
5883 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
5884{
5885 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
5886 BLOCK_LENGTH,
5887 ALLOCATOR> ElementGuard;
5888
5889 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
5890 BLOCK_LENGTH> EndpointProctor;
5891
5892 size_type backSize = fromEnd - position;
5893 Iterator end = fromEnd;
5894 Iterator dest = end + 1;
5895
5896 BSLS_ASSERT_SAFE(backSize >= 1);
5897
5898 ElementGuard guard(dest, dest, allocator);
5899
5900
5901 --dest;
5902 --end;
5903 bsl::allocator_traits<ALLOCATOR>::construct(
5904 allocator,
5905 dest.valuePtr(),
5906 MoveUtil::move_if_noexcept(*end));
5907 guard.moveBegin(-1);
5908
5909
5910 size_type n = 0;
5911 for (backSize -= 1; 0 < backSize; --backSize) {
5912 --dest;
5913 --end;
5914 *dest = MoveUtil::move_if_noexcept(*end);
5915 ++n;
5916 }
5917 guard.moveBegin(-n);
5918
5919
5920 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
5921
5922
5923
5924 EndpointProctor endpointProctor(toEnd, position);
5925
5926 bsl::allocator_traits<ALLOCATOR>::construct(
5927 allocator,
5928 position.valuePtr(),
5929 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
5930 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
5931 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
5932 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
5933 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
5934 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
5935 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
5936 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
5937 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
5938 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
5939
5940 endpointProctor.release();
5941 guard.release();
5942
5943 *toEnd = fromEnd + 1;
5944}
5945#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
5946
5947
5948#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
5949template <class VALUE_TYPE, int BLOCK_LENGTH>
5950template <class ALLOCATOR>
5951inline
5952void
5953DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
5954 Iterator *toBegin,
5955 Iterator fromBegin,
5956 Iterator position,
5957 ALLOCATOR allocator)
5958{
5959 enum {
5960 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
5961 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
5962
5963 VALUE = IS_BITWISECOPYABLE
5964 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
5965 : IS_BITWISEMOVEABLE
5966 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
5967 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
5968 };
5969
5970 emplaceAndMoveToFrontDispatch(
5971 toBegin,
5972 fromBegin,
5973 position,
5974 allocator,
5975 bsl::integral_constant<int, VALUE>());
5976}
5977#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
5978
5979#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
5980template <class VALUE_TYPE, int BLOCK_LENGTH>
5981template <class ALLOCATOR, class Args_01>
5982inline
5983void
5984DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
5985 Iterator *toBegin,
5986 Iterator fromBegin,
5987 Iterator position,
5988 ALLOCATOR allocator,
5989 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
5990{
5991 enum {
5992 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
5993 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
5994
5995 VALUE = IS_BITWISECOPYABLE
5996 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
5997 : IS_BITWISEMOVEABLE
5998 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
5999 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6000 };
6001
6002 emplaceAndMoveToFrontDispatch(
6003 toBegin,
6004 fromBegin,
6005 position,
6006 allocator,
6007 bsl::integral_constant<int, VALUE>(),
6008 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
6009}
6010#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
6011
6012#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
6013template <class VALUE_TYPE, int BLOCK_LENGTH>
6014template <class ALLOCATOR, class Args_01,
6015 class Args_02>
6016inline
6017void
6018DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
6019 Iterator *toBegin,
6020 Iterator fromBegin,
6021 Iterator position,
6022 ALLOCATOR allocator,
6023 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6024 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
6025{
6026 enum {
6027 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
6028 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
6029
6030 VALUE = IS_BITWISECOPYABLE
6031 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
6032 : IS_BITWISEMOVEABLE
6033 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
6034 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6035 };
6036
6037 emplaceAndMoveToFrontDispatch(
6038 toBegin,
6039 fromBegin,
6040 position,
6041 allocator,
6042 bsl::integral_constant<int, VALUE>(),
6043 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6044 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
6045}
6046#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
6047
6048#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
6049template <class VALUE_TYPE, int BLOCK_LENGTH>
6050template <class ALLOCATOR, class Args_01,
6051 class Args_02,
6052 class Args_03>
6053inline
6054void
6055DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
6056 Iterator *toBegin,
6057 Iterator fromBegin,
6058 Iterator position,
6059 ALLOCATOR allocator,
6060 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6061 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6062 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
6063{
6064 enum {
6065 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
6066 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
6067
6068 VALUE = IS_BITWISECOPYABLE
6069 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
6070 : IS_BITWISEMOVEABLE
6071 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
6072 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6073 };
6074
6075 emplaceAndMoveToFrontDispatch(
6076 toBegin,
6077 fromBegin,
6078 position,
6079 allocator,
6080 bsl::integral_constant<int, VALUE>(),
6081 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6082 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6083 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
6084}
6085#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
6086
6087#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
6088template <class VALUE_TYPE, int BLOCK_LENGTH>
6089template <class ALLOCATOR, class Args_01,
6090 class Args_02,
6091 class Args_03,
6092 class Args_04>
6093inline
6094void
6095DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
6096 Iterator *toBegin,
6097 Iterator fromBegin,
6098 Iterator position,
6099 ALLOCATOR allocator,
6100 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6101 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6102 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6103 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
6104{
6105 enum {
6106 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
6107 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
6108
6109 VALUE = IS_BITWISECOPYABLE
6110 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
6111 : IS_BITWISEMOVEABLE
6112 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
6113 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6114 };
6115
6116 emplaceAndMoveToFrontDispatch(
6117 toBegin,
6118 fromBegin,
6119 position,
6120 allocator,
6121 bsl::integral_constant<int, VALUE>(),
6122 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6123 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6124 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6125 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
6126}
6127#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
6128
6129#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
6130template <class VALUE_TYPE, int BLOCK_LENGTH>
6131template <class ALLOCATOR, class Args_01,
6132 class Args_02,
6133 class Args_03,
6134 class Args_04,
6135 class Args_05>
6136inline
6137void
6138DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
6139 Iterator *toBegin,
6140 Iterator fromBegin,
6141 Iterator position,
6142 ALLOCATOR allocator,
6143 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6144 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6145 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6146 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6147 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
6148{
6149 enum {
6150 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
6151 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
6152
6153 VALUE = IS_BITWISECOPYABLE
6154 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
6155 : IS_BITWISEMOVEABLE
6156 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
6157 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6158 };
6159
6160 emplaceAndMoveToFrontDispatch(
6161 toBegin,
6162 fromBegin,
6163 position,
6164 allocator,
6165 bsl::integral_constant<int, VALUE>(),
6166 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6167 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6168 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6169 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6170 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
6171}
6172#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
6173
6174#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
6175template <class VALUE_TYPE, int BLOCK_LENGTH>
6176template <class ALLOCATOR, class Args_01,
6177 class Args_02,
6178 class Args_03,
6179 class Args_04,
6180 class Args_05,
6181 class Args_06>
6182inline
6183void
6184DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
6185 Iterator *toBegin,
6186 Iterator fromBegin,
6187 Iterator position,
6188 ALLOCATOR allocator,
6189 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6190 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6191 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6192 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6193 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6194 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
6195{
6196 enum {
6197 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
6198 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
6199
6200 VALUE = IS_BITWISECOPYABLE
6201 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
6202 : IS_BITWISEMOVEABLE
6203 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
6204 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6205 };
6206
6207 emplaceAndMoveToFrontDispatch(
6208 toBegin,
6209 fromBegin,
6210 position,
6211 allocator,
6212 bsl::integral_constant<int, VALUE>(),
6213 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6214 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6215 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6216 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6217 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6218 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
6219}
6220#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
6221
6222#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
6223template <class VALUE_TYPE, int BLOCK_LENGTH>
6224template <class ALLOCATOR, class Args_01,
6225 class Args_02,
6226 class Args_03,
6227 class Args_04,
6228 class Args_05,
6229 class Args_06,
6230 class Args_07>
6231inline
6232void
6233DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
6234 Iterator *toBegin,
6235 Iterator fromBegin,
6236 Iterator position,
6237 ALLOCATOR allocator,
6238 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6239 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6240 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6241 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6242 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6243 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
6244 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
6245{
6246 enum {
6247 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
6248 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
6249
6250 VALUE = IS_BITWISECOPYABLE
6251 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
6252 : IS_BITWISEMOVEABLE
6253 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
6254 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6255 };
6256
6257 emplaceAndMoveToFrontDispatch(
6258 toBegin,
6259 fromBegin,
6260 position,
6261 allocator,
6262 bsl::integral_constant<int, VALUE>(),
6263 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6264 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6265 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6266 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6267 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6268 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
6269 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
6270}
6271#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
6272
6273#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
6274template <class VALUE_TYPE, int BLOCK_LENGTH>
6275template <class ALLOCATOR, class Args_01,
6276 class Args_02,
6277 class Args_03,
6278 class Args_04,
6279 class Args_05,
6280 class Args_06,
6281 class Args_07,
6282 class Args_08>
6283inline
6284void
6285DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
6286 Iterator *toBegin,
6287 Iterator fromBegin,
6288 Iterator position,
6289 ALLOCATOR allocator,
6290 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6291 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6292 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6293 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6294 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6295 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
6296 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
6297 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
6298{
6299 enum {
6300 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
6301 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
6302
6303 VALUE = IS_BITWISECOPYABLE
6304 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
6305 : IS_BITWISEMOVEABLE
6306 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
6307 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6308 };
6309
6310 emplaceAndMoveToFrontDispatch(
6311 toBegin,
6312 fromBegin,
6313 position,
6314 allocator,
6315 bsl::integral_constant<int, VALUE>(),
6316 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6317 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6318 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6319 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6320 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6321 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
6322 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
6323 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
6324}
6325#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
6326
6327#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
6328template <class VALUE_TYPE, int BLOCK_LENGTH>
6329template <class ALLOCATOR, class Args_01,
6330 class Args_02,
6331 class Args_03,
6332 class Args_04,
6333 class Args_05,
6334 class Args_06,
6335 class Args_07,
6336 class Args_08,
6337 class Args_09>
6338inline
6339void
6340DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
6341 Iterator *toBegin,
6342 Iterator fromBegin,
6343 Iterator position,
6344 ALLOCATOR allocator,
6345 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6346 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6347 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6348 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6349 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6350 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
6351 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
6352 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
6353 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
6354{
6355 enum {
6356 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
6357 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
6358
6359 VALUE = IS_BITWISECOPYABLE
6360 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
6361 : IS_BITWISEMOVEABLE
6362 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
6363 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6364 };
6365
6366 emplaceAndMoveToFrontDispatch(
6367 toBegin,
6368 fromBegin,
6369 position,
6370 allocator,
6371 bsl::integral_constant<int, VALUE>(),
6372 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6373 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6374 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6375 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6376 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6377 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
6378 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
6379 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
6380 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
6381}
6382#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
6383
6384#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
6385template <class VALUE_TYPE, int BLOCK_LENGTH>
6386template <class ALLOCATOR, class Args_01,
6387 class Args_02,
6388 class Args_03,
6389 class Args_04,
6390 class Args_05,
6391 class Args_06,
6392 class Args_07,
6393 class Args_08,
6394 class Args_09,
6395 class Args_10>
6396inline
6397void
6398DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
6399 Iterator *toBegin,
6400 Iterator fromBegin,
6401 Iterator position,
6402 ALLOCATOR allocator,
6403 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6404 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6405 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6406 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6407 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6408 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
6409 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
6410 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
6411 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
6412 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
6413{
6414 enum {
6415 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
6416 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
6417
6418 VALUE = IS_BITWISECOPYABLE
6419 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
6420 : IS_BITWISEMOVEABLE
6421 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
6422 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
6423 };
6424
6425 emplaceAndMoveToFrontDispatch(
6426 toBegin,
6427 fromBegin,
6428 position,
6429 allocator,
6430 bsl::integral_constant<int, VALUE>(),
6431 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6432 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6433 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6434 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6435 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6436 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
6437 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
6438 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
6439 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
6440 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
6441}
6442#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
6443
6444
6445#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
6446template <class VALUE_TYPE, int BLOCK_LENGTH>
6447template <class ALLOCATOR>
6448void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6449 Iterator *toBegin,
6450 Iterator fromBegin,
6451 Iterator position,
6452 ALLOCATOR allocator,
6453 bsl::integral_constant<int,
6454 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>)
6455{
6456 const size_type frontSize = position - fromBegin;
6457 Iterator begin = fromBegin;
6458 Iterator dest = begin - 1;
6459
6460
6461 moveFront(&dest, &begin, frontSize);
6462
6463 bsl::allocator_traits<ALLOCATOR>::construct(
6464 allocator,
6465 dest.valuePtr());
6466
6467 *toBegin = fromBegin - 1;
6468}
6469#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
6470
6471#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
6472template <class VALUE_TYPE, int BLOCK_LENGTH>
6473template <class ALLOCATOR, class Args_01>
6474void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6475 Iterator *toBegin,
6476 Iterator fromBegin,
6477 Iterator position,
6478 ALLOCATOR allocator,
6479 bsl::integral_constant<int,
6480 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6481 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
6482{
6483 const size_type frontSize = position - fromBegin;
6484 Iterator begin = fromBegin;
6485 Iterator dest = begin - 1;
6486
6487
6488 moveFront(&dest, &begin, frontSize);
6489
6490 bsl::allocator_traits<ALLOCATOR>::construct(
6491 allocator,
6492 dest.valuePtr(),
6493 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
6494
6495 *toBegin = fromBegin - 1;
6496}
6497#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
6498
6499#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
6500template <class VALUE_TYPE, int BLOCK_LENGTH>
6501template <class ALLOCATOR, class Args_01,
6502 class Args_02>
6503void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6504 Iterator *toBegin,
6505 Iterator fromBegin,
6506 Iterator position,
6507 ALLOCATOR allocator,
6508 bsl::integral_constant<int,
6509 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6510 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6511 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
6512{
6513 const size_type frontSize = position - fromBegin;
6514 Iterator begin = fromBegin;
6515 Iterator dest = begin - 1;
6516
6517
6518 moveFront(&dest, &begin, frontSize);
6519
6520 bsl::allocator_traits<ALLOCATOR>::construct(
6521 allocator,
6522 dest.valuePtr(),
6523 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6524 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
6525
6526 *toBegin = fromBegin - 1;
6527}
6528#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
6529
6530#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
6531template <class VALUE_TYPE, int BLOCK_LENGTH>
6532template <class ALLOCATOR, class Args_01,
6533 class Args_02,
6534 class Args_03>
6535void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6536 Iterator *toBegin,
6537 Iterator fromBegin,
6538 Iterator position,
6539 ALLOCATOR allocator,
6540 bsl::integral_constant<int,
6541 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6542 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6543 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6544 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
6545{
6546 const size_type frontSize = position - fromBegin;
6547 Iterator begin = fromBegin;
6548 Iterator dest = begin - 1;
6549
6550
6551 moveFront(&dest, &begin, frontSize);
6552
6553 bsl::allocator_traits<ALLOCATOR>::construct(
6554 allocator,
6555 dest.valuePtr(),
6556 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6557 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6558 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
6559
6560 *toBegin = fromBegin - 1;
6561}
6562#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
6563
6564#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
6565template <class VALUE_TYPE, int BLOCK_LENGTH>
6566template <class ALLOCATOR, class Args_01,
6567 class Args_02,
6568 class Args_03,
6569 class Args_04>
6570void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6571 Iterator *toBegin,
6572 Iterator fromBegin,
6573 Iterator position,
6574 ALLOCATOR allocator,
6575 bsl::integral_constant<int,
6576 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6577 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6578 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6579 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6580 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
6581{
6582 const size_type frontSize = position - fromBegin;
6583 Iterator begin = fromBegin;
6584 Iterator dest = begin - 1;
6585
6586
6587 moveFront(&dest, &begin, frontSize);
6588
6589 bsl::allocator_traits<ALLOCATOR>::construct(
6590 allocator,
6591 dest.valuePtr(),
6592 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6593 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6594 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6595 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
6596
6597 *toBegin = fromBegin - 1;
6598}
6599#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
6600
6601#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
6602template <class VALUE_TYPE, int BLOCK_LENGTH>
6603template <class ALLOCATOR, class Args_01,
6604 class Args_02,
6605 class Args_03,
6606 class Args_04,
6607 class Args_05>
6608void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6609 Iterator *toBegin,
6610 Iterator fromBegin,
6611 Iterator position,
6612 ALLOCATOR allocator,
6613 bsl::integral_constant<int,
6614 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6615 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6616 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6617 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6618 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6619 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
6620{
6621 const size_type frontSize = position - fromBegin;
6622 Iterator begin = fromBegin;
6623 Iterator dest = begin - 1;
6624
6625
6626 moveFront(&dest, &begin, frontSize);
6627
6628 bsl::allocator_traits<ALLOCATOR>::construct(
6629 allocator,
6630 dest.valuePtr(),
6631 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6632 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6633 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6634 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6635 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
6636
6637 *toBegin = fromBegin - 1;
6638}
6639#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
6640
6641#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
6642template <class VALUE_TYPE, int BLOCK_LENGTH>
6643template <class ALLOCATOR, class Args_01,
6644 class Args_02,
6645 class Args_03,
6646 class Args_04,
6647 class Args_05,
6648 class Args_06>
6649void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6650 Iterator *toBegin,
6651 Iterator fromBegin,
6652 Iterator position,
6653 ALLOCATOR allocator,
6654 bsl::integral_constant<int,
6655 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6656 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6657 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6658 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6659 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6660 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6661 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
6662{
6663 const size_type frontSize = position - fromBegin;
6664 Iterator begin = fromBegin;
6665 Iterator dest = begin - 1;
6666
6667
6668 moveFront(&dest, &begin, frontSize);
6669
6670 bsl::allocator_traits<ALLOCATOR>::construct(
6671 allocator,
6672 dest.valuePtr(),
6673 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6674 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6675 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6676 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6677 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6678 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
6679
6680 *toBegin = fromBegin - 1;
6681}
6682#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
6683
6684#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
6685template <class VALUE_TYPE, int BLOCK_LENGTH>
6686template <class ALLOCATOR, class Args_01,
6687 class Args_02,
6688 class Args_03,
6689 class Args_04,
6690 class Args_05,
6691 class Args_06,
6692 class Args_07>
6693void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6694 Iterator *toBegin,
6695 Iterator fromBegin,
6696 Iterator position,
6697 ALLOCATOR allocator,
6698 bsl::integral_constant<int,
6699 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6700 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6701 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6702 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6703 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6704 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6705 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
6706 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
6707{
6708 const size_type frontSize = position - fromBegin;
6709 Iterator begin = fromBegin;
6710 Iterator dest = begin - 1;
6711
6712
6713 moveFront(&dest, &begin, frontSize);
6714
6715 bsl::allocator_traits<ALLOCATOR>::construct(
6716 allocator,
6717 dest.valuePtr(),
6718 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6719 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6720 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6721 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6722 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6723 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
6724 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
6725
6726 *toBegin = fromBegin - 1;
6727}
6728#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
6729
6730#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
6731template <class VALUE_TYPE, int BLOCK_LENGTH>
6732template <class ALLOCATOR, class Args_01,
6733 class Args_02,
6734 class Args_03,
6735 class Args_04,
6736 class Args_05,
6737 class Args_06,
6738 class Args_07,
6739 class Args_08>
6740void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6741 Iterator *toBegin,
6742 Iterator fromBegin,
6743 Iterator position,
6744 ALLOCATOR allocator,
6745 bsl::integral_constant<int,
6746 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6747 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6748 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6749 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6750 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6751 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6752 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
6753 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
6754 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
6755{
6756 const size_type frontSize = position - fromBegin;
6757 Iterator begin = fromBegin;
6758 Iterator dest = begin - 1;
6759
6760
6761 moveFront(&dest, &begin, frontSize);
6762
6763 bsl::allocator_traits<ALLOCATOR>::construct(
6764 allocator,
6765 dest.valuePtr(),
6766 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6767 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6768 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6769 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6770 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6771 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
6772 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
6773 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
6774
6775 *toBegin = fromBegin - 1;
6776}
6777#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
6778
6779#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
6780template <class VALUE_TYPE, int BLOCK_LENGTH>
6781template <class ALLOCATOR, class Args_01,
6782 class Args_02,
6783 class Args_03,
6784 class Args_04,
6785 class Args_05,
6786 class Args_06,
6787 class Args_07,
6788 class Args_08,
6789 class Args_09>
6790void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6791 Iterator *toBegin,
6792 Iterator fromBegin,
6793 Iterator position,
6794 ALLOCATOR allocator,
6795 bsl::integral_constant<int,
6796 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6797 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6798 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6799 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6800 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6801 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6802 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
6803 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
6804 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
6805 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
6806{
6807 const size_type frontSize = position - fromBegin;
6808 Iterator begin = fromBegin;
6809 Iterator dest = begin - 1;
6810
6811
6812 moveFront(&dest, &begin, frontSize);
6813
6814 bsl::allocator_traits<ALLOCATOR>::construct(
6815 allocator,
6816 dest.valuePtr(),
6817 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6818 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6819 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6820 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6821 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6822 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
6823 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
6824 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
6825 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
6826
6827 *toBegin = fromBegin - 1;
6828}
6829#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
6830
6831#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
6832template <class VALUE_TYPE, int BLOCK_LENGTH>
6833template <class ALLOCATOR, class Args_01,
6834 class Args_02,
6835 class Args_03,
6836 class Args_04,
6837 class Args_05,
6838 class Args_06,
6839 class Args_07,
6840 class Args_08,
6841 class Args_09,
6842 class Args_10>
6843void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6844 Iterator *toBegin,
6845 Iterator fromBegin,
6846 Iterator position,
6847 ALLOCATOR allocator,
6848 bsl::integral_constant<int,
6849 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
6850 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6851 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6852 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
6853 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
6854 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
6855 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
6856 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
6857 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
6858 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
6859 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
6860{
6861 const size_type frontSize = position - fromBegin;
6862 Iterator begin = fromBegin;
6863 Iterator dest = begin - 1;
6864
6865
6866 moveFront(&dest, &begin, frontSize);
6867
6868 bsl::allocator_traits<ALLOCATOR>::construct(
6869 allocator,
6870 dest.valuePtr(),
6871 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6872 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
6873 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
6874 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
6875 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
6876 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
6877 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
6878 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
6879 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
6880 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
6881
6882 *toBegin = fromBegin - 1;
6883}
6884#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
6885
6886
6887#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
6888template <class VALUE_TYPE, int BLOCK_LENGTH>
6889template <class ALLOCATOR>
6890void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6891 Iterator *toBegin,
6892 Iterator fromBegin,
6893 Iterator position,
6894 ALLOCATOR allocator,
6895 bsl::integral_constant<int,
6896 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>)
6897{
6898 const size_type frontSize = position - fromBegin;
6899 Iterator begin = fromBegin;
6900 Iterator dest = begin - 1;
6901
6902
6903 MoveGuard guard(begin, dest, frontSize, true);
6904
6905 moveFront(&dest, &begin, frontSize);
6906
6907 bsl::allocator_traits<ALLOCATOR>::construct(
6908 allocator,
6909 dest.valuePtr());
6910
6911 guard.release();
6912
6913 *toBegin = fromBegin - 1;
6914}
6915#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
6916
6917#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
6918template <class VALUE_TYPE, int BLOCK_LENGTH>
6919template <class ALLOCATOR, class Args_01>
6920void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6921 Iterator *toBegin,
6922 Iterator fromBegin,
6923 Iterator position,
6924 ALLOCATOR allocator,
6925 bsl::integral_constant<int,
6926 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
6927 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
6928{
6929 const size_type frontSize = position - fromBegin;
6930 Iterator begin = fromBegin;
6931 Iterator dest = begin - 1;
6932
6933
6934 MoveGuard guard(begin, dest, frontSize, true);
6935
6936 moveFront(&dest, &begin, frontSize);
6937
6938 bsl::allocator_traits<ALLOCATOR>::construct(
6939 allocator,
6940 dest.valuePtr(),
6941 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
6942
6943 guard.release();
6944
6945 *toBegin = fromBegin - 1;
6946}
6947#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
6948
6949#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
6950template <class VALUE_TYPE, int BLOCK_LENGTH>
6951template <class ALLOCATOR, class Args_01,
6952 class Args_02>
6953void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6954 Iterator *toBegin,
6955 Iterator fromBegin,
6956 Iterator position,
6957 ALLOCATOR allocator,
6958 bsl::integral_constant<int,
6959 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
6960 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6961 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
6962{
6963 const size_type frontSize = position - fromBegin;
6964 Iterator begin = fromBegin;
6965 Iterator dest = begin - 1;
6966
6967
6968 MoveGuard guard(begin, dest, frontSize, true);
6969
6970 moveFront(&dest, &begin, frontSize);
6971
6972 bsl::allocator_traits<ALLOCATOR>::construct(
6973 allocator,
6974 dest.valuePtr(),
6975 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
6976 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
6977
6978 guard.release();
6979
6980 *toBegin = fromBegin - 1;
6981}
6982#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
6983
6984#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
6985template <class VALUE_TYPE, int BLOCK_LENGTH>
6986template <class ALLOCATOR, class Args_01,
6987 class Args_02,
6988 class Args_03>
6989void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
6990 Iterator *toBegin,
6991 Iterator fromBegin,
6992 Iterator position,
6993 ALLOCATOR allocator,
6994 bsl::integral_constant<int,
6995 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
6996 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
6997 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
6998 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
6999{
7000 const size_type frontSize = position - fromBegin;
7001 Iterator begin = fromBegin;
7002 Iterator dest = begin - 1;
7003
7004
7005 MoveGuard guard(begin, dest, frontSize, true);
7006
7007 moveFront(&dest, &begin, frontSize);
7008
7009 bsl::allocator_traits<ALLOCATOR>::construct(
7010 allocator,
7011 dest.valuePtr(),
7012 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7013 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7014 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
7015
7016 guard.release();
7017
7018 *toBegin = fromBegin - 1;
7019}
7020#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
7021
7022#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
7023template <class VALUE_TYPE, int BLOCK_LENGTH>
7024template <class ALLOCATOR, class Args_01,
7025 class Args_02,
7026 class Args_03,
7027 class Args_04>
7028void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7029 Iterator *toBegin,
7030 Iterator fromBegin,
7031 Iterator position,
7032 ALLOCATOR allocator,
7033 bsl::integral_constant<int,
7034 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
7035 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7036 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7037 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7038 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
7039{
7040 const size_type frontSize = position - fromBegin;
7041 Iterator begin = fromBegin;
7042 Iterator dest = begin - 1;
7043
7044
7045 MoveGuard guard(begin, dest, frontSize, true);
7046
7047 moveFront(&dest, &begin, frontSize);
7048
7049 bsl::allocator_traits<ALLOCATOR>::construct(
7050 allocator,
7051 dest.valuePtr(),
7052 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7053 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7054 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7055 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
7056
7057 guard.release();
7058
7059 *toBegin = fromBegin - 1;
7060}
7061#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
7062
7063#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
7064template <class VALUE_TYPE, int BLOCK_LENGTH>
7065template <class ALLOCATOR, class Args_01,
7066 class Args_02,
7067 class Args_03,
7068 class Args_04,
7069 class Args_05>
7070void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7071 Iterator *toBegin,
7072 Iterator fromBegin,
7073 Iterator position,
7074 ALLOCATOR allocator,
7075 bsl::integral_constant<int,
7076 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
7077 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7078 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7079 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7080 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7081 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
7082{
7083 const size_type frontSize = position - fromBegin;
7084 Iterator begin = fromBegin;
7085 Iterator dest = begin - 1;
7086
7087
7088 MoveGuard guard(begin, dest, frontSize, true);
7089
7090 moveFront(&dest, &begin, frontSize);
7091
7092 bsl::allocator_traits<ALLOCATOR>::construct(
7093 allocator,
7094 dest.valuePtr(),
7095 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7096 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7097 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7098 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
7099 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
7100
7101 guard.release();
7102
7103 *toBegin = fromBegin - 1;
7104}
7105#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
7106
7107#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
7108template <class VALUE_TYPE, int BLOCK_LENGTH>
7109template <class ALLOCATOR, class Args_01,
7110 class Args_02,
7111 class Args_03,
7112 class Args_04,
7113 class Args_05,
7114 class Args_06>
7115void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7116 Iterator *toBegin,
7117 Iterator fromBegin,
7118 Iterator position,
7119 ALLOCATOR allocator,
7120 bsl::integral_constant<int,
7121 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
7122 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7123 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7124 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7125 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7126 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
7127 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
7128{
7129 const size_type frontSize = position - fromBegin;
7130 Iterator begin = fromBegin;
7131 Iterator dest = begin - 1;
7132
7133
7134 MoveGuard guard(begin, dest, frontSize, true);
7135
7136 moveFront(&dest, &begin, frontSize);
7137
7138 bsl::allocator_traits<ALLOCATOR>::construct(
7139 allocator,
7140 dest.valuePtr(),
7141 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7142 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7143 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7144 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
7145 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
7146 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
7147
7148 guard.release();
7149
7150 *toBegin = fromBegin - 1;
7151}
7152#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
7153
7154#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
7155template <class VALUE_TYPE, int BLOCK_LENGTH>
7156template <class ALLOCATOR, class Args_01,
7157 class Args_02,
7158 class Args_03,
7159 class Args_04,
7160 class Args_05,
7161 class Args_06,
7162 class Args_07>
7163void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7164 Iterator *toBegin,
7165 Iterator fromBegin,
7166 Iterator position,
7167 ALLOCATOR allocator,
7168 bsl::integral_constant<int,
7169 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
7170 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7171 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7172 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7173 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7174 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
7175 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
7176 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
7177{
7178 const size_type frontSize = position - fromBegin;
7179 Iterator begin = fromBegin;
7180 Iterator dest = begin - 1;
7181
7182
7183 MoveGuard guard(begin, dest, frontSize, true);
7184
7185 moveFront(&dest, &begin, frontSize);
7186
7187 bsl::allocator_traits<ALLOCATOR>::construct(
7188 allocator,
7189 dest.valuePtr(),
7190 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7191 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7192 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7193 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
7194 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
7195 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
7196 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
7197
7198 guard.release();
7199
7200 *toBegin = fromBegin - 1;
7201}
7202#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
7203
7204#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
7205template <class VALUE_TYPE, int BLOCK_LENGTH>
7206template <class ALLOCATOR, class Args_01,
7207 class Args_02,
7208 class Args_03,
7209 class Args_04,
7210 class Args_05,
7211 class Args_06,
7212 class Args_07,
7213 class Args_08>
7214void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7215 Iterator *toBegin,
7216 Iterator fromBegin,
7217 Iterator position,
7218 ALLOCATOR allocator,
7219 bsl::integral_constant<int,
7220 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
7221 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7222 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7223 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7224 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7225 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
7226 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
7227 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
7228 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
7229{
7230 const size_type frontSize = position - fromBegin;
7231 Iterator begin = fromBegin;
7232 Iterator dest = begin - 1;
7233
7234
7235 MoveGuard guard(begin, dest, frontSize, true);
7236
7237 moveFront(&dest, &begin, frontSize);
7238
7239 bsl::allocator_traits<ALLOCATOR>::construct(
7240 allocator,
7241 dest.valuePtr(),
7242 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7243 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7244 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7245 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
7246 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
7247 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
7248 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
7249 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
7250
7251 guard.release();
7252
7253 *toBegin = fromBegin - 1;
7254}
7255#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
7256
7257#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
7258template <class VALUE_TYPE, int BLOCK_LENGTH>
7259template <class ALLOCATOR, class Args_01,
7260 class Args_02,
7261 class Args_03,
7262 class Args_04,
7263 class Args_05,
7264 class Args_06,
7265 class Args_07,
7266 class Args_08,
7267 class Args_09>
7268void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7269 Iterator *toBegin,
7270 Iterator fromBegin,
7271 Iterator position,
7272 ALLOCATOR allocator,
7273 bsl::integral_constant<int,
7274 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
7275 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7276 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7277 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7278 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7279 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
7280 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
7281 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
7282 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
7283 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
7284{
7285 const size_type frontSize = position - fromBegin;
7286 Iterator begin = fromBegin;
7287 Iterator dest = begin - 1;
7288
7289
7290 MoveGuard guard(begin, dest, frontSize, true);
7291
7292 moveFront(&dest, &begin, frontSize);
7293
7294 bsl::allocator_traits<ALLOCATOR>::construct(
7295 allocator,
7296 dest.valuePtr(),
7297 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7298 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7299 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7300 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
7301 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
7302 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
7303 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
7304 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
7305 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
7306
7307 guard.release();
7308
7309 *toBegin = fromBegin - 1;
7310}
7311#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
7312
7313#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
7314template <class VALUE_TYPE, int BLOCK_LENGTH>
7315template <class ALLOCATOR, class Args_01,
7316 class Args_02,
7317 class Args_03,
7318 class Args_04,
7319 class Args_05,
7320 class Args_06,
7321 class Args_07,
7322 class Args_08,
7323 class Args_09,
7324 class Args_10>
7325void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7326 Iterator *toBegin,
7327 Iterator fromBegin,
7328 Iterator position,
7329 ALLOCATOR allocator,
7330 bsl::integral_constant<int,
7331 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
7332 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7333 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7334 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7335 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7336 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
7337 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
7338 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
7339 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
7340 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
7341 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
7342{
7343 const size_type frontSize = position - fromBegin;
7344 Iterator begin = fromBegin;
7345 Iterator dest = begin - 1;
7346
7347
7348 MoveGuard guard(begin, dest, frontSize, true);
7349
7350 moveFront(&dest, &begin, frontSize);
7351
7352 bsl::allocator_traits<ALLOCATOR>::construct(
7353 allocator,
7354 dest.valuePtr(),
7355 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7356 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7357 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7358 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
7359 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
7360 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
7361 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
7362 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
7363 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
7364 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
7365
7366 guard.release();
7367
7368 *toBegin = fromBegin - 1;
7369}
7370#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
7371
7372
7373#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
7374template <class VALUE_TYPE, int BLOCK_LENGTH>
7375template <class ALLOCATOR>
7376void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7377 Iterator *toBegin,
7378 Iterator fromBegin,
7379 Iterator position,
7380 ALLOCATOR allocator,
7381 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
7382{
7383 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
7384 BLOCK_LENGTH,
7385 ALLOCATOR> ElementGuard;
7386
7387 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
7388 BLOCK_LENGTH> EndpointProctor;
7389
7390 size_type frontSize = position - fromBegin;
7391 Iterator begin = fromBegin;
7392 Iterator dest = begin - 1;
7393
7394 BSLS_ASSERT_SAFE(frontSize >= 1);
7395
7396 ElementGuard guard(dest, dest, allocator);
7397
7398
7399 bsl::allocator_traits<ALLOCATOR>::construct(
7400 allocator,
7401 dest.valuePtr(),
7402 MoveUtil::move_if_noexcept(*begin));
7403 guard.moveEnd(1);
7404 ++dest;
7405 ++begin;
7406
7407
7408 size_type n = 0;
7409 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
7410 *dest = MoveUtil::move_if_noexcept(*begin);
7411 ++n;
7412 }
7413 guard.moveEnd(n);
7414
7415
7416 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
7417
7418
7419
7420 EndpointProctor endpointProctor(toBegin, position);
7421
7422 bsl::allocator_traits<ALLOCATOR>::construct(
7423 allocator,
7424 dest.valuePtr());
7425
7426 endpointProctor.release();
7427 guard.release();
7428
7429 *toBegin = fromBegin - 1;
7430}
7431#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 0
7432
7433#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
7434template <class VALUE_TYPE, int BLOCK_LENGTH>
7435template <class ALLOCATOR, class Args_01>
7436void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7437 Iterator *toBegin,
7438 Iterator fromBegin,
7439 Iterator position,
7440 ALLOCATOR allocator,
7441 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
7442 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
7443{
7444 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
7445 BLOCK_LENGTH,
7446 ALLOCATOR> ElementGuard;
7447
7448 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
7449 BLOCK_LENGTH> EndpointProctor;
7450
7451 size_type frontSize = position - fromBegin;
7452 Iterator begin = fromBegin;
7453 Iterator dest = begin - 1;
7454
7455 BSLS_ASSERT_SAFE(frontSize >= 1);
7456
7457 ElementGuard guard(dest, dest, allocator);
7458
7459
7460 bsl::allocator_traits<ALLOCATOR>::construct(
7461 allocator,
7462 dest.valuePtr(),
7463 MoveUtil::move_if_noexcept(*begin));
7464 guard.moveEnd(1);
7465 ++dest;
7466 ++begin;
7467
7468
7469 size_type n = 0;
7470 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
7471 *dest = MoveUtil::move_if_noexcept(*begin);
7472 ++n;
7473 }
7474 guard.moveEnd(n);
7475
7476
7477 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
7478
7479
7480
7481 EndpointProctor endpointProctor(toBegin, position);
7482
7483 bsl::allocator_traits<ALLOCATOR>::construct(
7484 allocator,
7485 dest.valuePtr(),
7486 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
7487
7488 endpointProctor.release();
7489 guard.release();
7490
7491 *toBegin = fromBegin - 1;
7492}
7493#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 1
7494
7495#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
7496template <class VALUE_TYPE, int BLOCK_LENGTH>
7497template <class ALLOCATOR, class Args_01,
7498 class Args_02>
7499void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7500 Iterator *toBegin,
7501 Iterator fromBegin,
7502 Iterator position,
7503 ALLOCATOR allocator,
7504 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
7505 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7506 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
7507{
7508 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
7509 BLOCK_LENGTH,
7510 ALLOCATOR> ElementGuard;
7511
7512 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
7513 BLOCK_LENGTH> EndpointProctor;
7514
7515 size_type frontSize = position - fromBegin;
7516 Iterator begin = fromBegin;
7517 Iterator dest = begin - 1;
7518
7519 BSLS_ASSERT_SAFE(frontSize >= 1);
7520
7521 ElementGuard guard(dest, dest, allocator);
7522
7523
7524 bsl::allocator_traits<ALLOCATOR>::construct(
7525 allocator,
7526 dest.valuePtr(),
7527 MoveUtil::move_if_noexcept(*begin));
7528 guard.moveEnd(1);
7529 ++dest;
7530 ++begin;
7531
7532
7533 size_type n = 0;
7534 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
7535 *dest = MoveUtil::move_if_noexcept(*begin);
7536 ++n;
7537 }
7538 guard.moveEnd(n);
7539
7540
7541 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
7542
7543
7544
7545 EndpointProctor endpointProctor(toBegin, position);
7546
7547 bsl::allocator_traits<ALLOCATOR>::construct(
7548 allocator,
7549 dest.valuePtr(),
7550 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7551 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
7552
7553 endpointProctor.release();
7554 guard.release();
7555
7556 *toBegin = fromBegin - 1;
7557}
7558#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 2
7559
7560#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
7561template <class VALUE_TYPE, int BLOCK_LENGTH>
7562template <class ALLOCATOR, class Args_01,
7563 class Args_02,
7564 class Args_03>
7565void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7566 Iterator *toBegin,
7567 Iterator fromBegin,
7568 Iterator position,
7569 ALLOCATOR allocator,
7570 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
7571 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7572 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7573 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
7574{
7575 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
7576 BLOCK_LENGTH,
7577 ALLOCATOR> ElementGuard;
7578
7579 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
7580 BLOCK_LENGTH> EndpointProctor;
7581
7582 size_type frontSize = position - fromBegin;
7583 Iterator begin = fromBegin;
7584 Iterator dest = begin - 1;
7585
7586 BSLS_ASSERT_SAFE(frontSize >= 1);
7587
7588 ElementGuard guard(dest, dest, allocator);
7589
7590
7591 bsl::allocator_traits<ALLOCATOR>::construct(
7592 allocator,
7593 dest.valuePtr(),
7594 MoveUtil::move_if_noexcept(*begin));
7595 guard.moveEnd(1);
7596 ++dest;
7597 ++begin;
7598
7599
7600 size_type n = 0;
7601 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
7602 *dest = MoveUtil::move_if_noexcept(*begin);
7603 ++n;
7604 }
7605 guard.moveEnd(n);
7606
7607
7608 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
7609
7610
7611
7612 EndpointProctor endpointProctor(toBegin, position);
7613
7614 bsl::allocator_traits<ALLOCATOR>::construct(
7615 allocator,
7616 dest.valuePtr(),
7617 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7618 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7619 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
7620
7621 endpointProctor.release();
7622 guard.release();
7623
7624 *toBegin = fromBegin - 1;
7625}
7626#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 3
7627
7628#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
7629template <class VALUE_TYPE, int BLOCK_LENGTH>
7630template <class ALLOCATOR, class Args_01,
7631 class Args_02,
7632 class Args_03,
7633 class Args_04>
7634void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7635 Iterator *toBegin,
7636 Iterator fromBegin,
7637 Iterator position,
7638 ALLOCATOR allocator,
7639 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
7640 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7641 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7642 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7643 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
7644{
7645 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
7646 BLOCK_LENGTH,
7647 ALLOCATOR> ElementGuard;
7648
7649 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
7650 BLOCK_LENGTH> EndpointProctor;
7651
7652 size_type frontSize = position - fromBegin;
7653 Iterator begin = fromBegin;
7654 Iterator dest = begin - 1;
7655
7656 BSLS_ASSERT_SAFE(frontSize >= 1);
7657
7658 ElementGuard guard(dest, dest, allocator);
7659
7660
7661 bsl::allocator_traits<ALLOCATOR>::construct(
7662 allocator,
7663 dest.valuePtr(),
7664 MoveUtil::move_if_noexcept(*begin));
7665 guard.moveEnd(1);
7666 ++dest;
7667 ++begin;
7668
7669
7670 size_type n = 0;
7671 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
7672 *dest = MoveUtil::move_if_noexcept(*begin);
7673 ++n;
7674 }
7675 guard.moveEnd(n);
7676
7677
7678 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
7679
7680
7681
7682 EndpointProctor endpointProctor(toBegin, position);
7683
7684 bsl::allocator_traits<ALLOCATOR>::construct(
7685 allocator,
7686 dest.valuePtr(),
7687 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7688 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7689 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7690 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
7691
7692 endpointProctor.release();
7693 guard.release();
7694
7695 *toBegin = fromBegin - 1;
7696}
7697#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 4
7698
7699#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
7700template <class VALUE_TYPE, int BLOCK_LENGTH>
7701template <class ALLOCATOR, class Args_01,
7702 class Args_02,
7703 class Args_03,
7704 class Args_04,
7705 class Args_05>
7706void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7707 Iterator *toBegin,
7708 Iterator fromBegin,
7709 Iterator position,
7710 ALLOCATOR allocator,
7711 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
7712 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7713 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7714 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7715 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7716 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
7717{
7718 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
7719 BLOCK_LENGTH,
7720 ALLOCATOR> ElementGuard;
7721
7722 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
7723 BLOCK_LENGTH> EndpointProctor;
7724
7725 size_type frontSize = position - fromBegin;
7726 Iterator begin = fromBegin;
7727 Iterator dest = begin - 1;
7728
7729 BSLS_ASSERT_SAFE(frontSize >= 1);
7730
7731 ElementGuard guard(dest, dest, allocator);
7732
7733
7734 bsl::allocator_traits<ALLOCATOR>::construct(
7735 allocator,
7736 dest.valuePtr(),
7737 MoveUtil::move_if_noexcept(*begin));
7738 guard.moveEnd(1);
7739 ++dest;
7740 ++begin;
7741
7742
7743 size_type n = 0;
7744 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
7745 *dest = MoveUtil::move_if_noexcept(*begin);
7746 ++n;
7747 }
7748 guard.moveEnd(n);
7749
7750
7751 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
7752
7753
7754
7755 EndpointProctor endpointProctor(toBegin, position);
7756
7757 bsl::allocator_traits<ALLOCATOR>::construct(
7758 allocator,
7759 dest.valuePtr(),
7760 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7761 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7762 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7763 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
7764 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
7765
7766 endpointProctor.release();
7767 guard.release();
7768
7769 *toBegin = fromBegin - 1;
7770}
7771#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 5
7772
7773#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
7774template <class VALUE_TYPE, int BLOCK_LENGTH>
7775template <class ALLOCATOR, class Args_01,
7776 class Args_02,
7777 class Args_03,
7778 class Args_04,
7779 class Args_05,
7780 class Args_06>
7781void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7782 Iterator *toBegin,
7783 Iterator fromBegin,
7784 Iterator position,
7785 ALLOCATOR allocator,
7786 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
7787 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7788 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7789 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7790 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7791 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
7792 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
7793{
7794 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
7795 BLOCK_LENGTH,
7796 ALLOCATOR> ElementGuard;
7797
7798 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
7799 BLOCK_LENGTH> EndpointProctor;
7800
7801 size_type frontSize = position - fromBegin;
7802 Iterator begin = fromBegin;
7803 Iterator dest = begin - 1;
7804
7805 BSLS_ASSERT_SAFE(frontSize >= 1);
7806
7807 ElementGuard guard(dest, dest, allocator);
7808
7809
7810 bsl::allocator_traits<ALLOCATOR>::construct(
7811 allocator,
7812 dest.valuePtr(),
7813 MoveUtil::move_if_noexcept(*begin));
7814 guard.moveEnd(1);
7815 ++dest;
7816 ++begin;
7817
7818
7819 size_type n = 0;
7820 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
7821 *dest = MoveUtil::move_if_noexcept(*begin);
7822 ++n;
7823 }
7824 guard.moveEnd(n);
7825
7826
7827 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
7828
7829
7830
7831 EndpointProctor endpointProctor(toBegin, position);
7832
7833 bsl::allocator_traits<ALLOCATOR>::construct(
7834 allocator,
7835 dest.valuePtr(),
7836 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7837 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7838 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7839 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
7840 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
7841 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
7842
7843 endpointProctor.release();
7844 guard.release();
7845
7846 *toBegin = fromBegin - 1;
7847}
7848#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 6
7849
7850#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
7851template <class VALUE_TYPE, int BLOCK_LENGTH>
7852template <class ALLOCATOR, class Args_01,
7853 class Args_02,
7854 class Args_03,
7855 class Args_04,
7856 class Args_05,
7857 class Args_06,
7858 class Args_07>
7859void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7860 Iterator *toBegin,
7861 Iterator fromBegin,
7862 Iterator position,
7863 ALLOCATOR allocator,
7864 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
7865 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7866 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7867 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7868 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7869 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
7870 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
7871 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
7872{
7873 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
7874 BLOCK_LENGTH,
7875 ALLOCATOR> ElementGuard;
7876
7877 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
7878 BLOCK_LENGTH> EndpointProctor;
7879
7880 size_type frontSize = position - fromBegin;
7881 Iterator begin = fromBegin;
7882 Iterator dest = begin - 1;
7883
7884 BSLS_ASSERT_SAFE(frontSize >= 1);
7885
7886 ElementGuard guard(dest, dest, allocator);
7887
7888
7889 bsl::allocator_traits<ALLOCATOR>::construct(
7890 allocator,
7891 dest.valuePtr(),
7892 MoveUtil::move_if_noexcept(*begin));
7893 guard.moveEnd(1);
7894 ++dest;
7895 ++begin;
7896
7897
7898 size_type n = 0;
7899 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
7900 *dest = MoveUtil::move_if_noexcept(*begin);
7901 ++n;
7902 }
7903 guard.moveEnd(n);
7904
7905
7906 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
7907
7908
7909
7910 EndpointProctor endpointProctor(toBegin, position);
7911
7912 bsl::allocator_traits<ALLOCATOR>::construct(
7913 allocator,
7914 dest.valuePtr(),
7915 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7916 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7917 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
7918 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
7919 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
7920 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
7921 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
7922
7923 endpointProctor.release();
7924 guard.release();
7925
7926 *toBegin = fromBegin - 1;
7927}
7928#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 7
7929
7930#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
7931template <class VALUE_TYPE, int BLOCK_LENGTH>
7932template <class ALLOCATOR, class Args_01,
7933 class Args_02,
7934 class Args_03,
7935 class Args_04,
7936 class Args_05,
7937 class Args_06,
7938 class Args_07,
7939 class Args_08>
7940void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
7941 Iterator *toBegin,
7942 Iterator fromBegin,
7943 Iterator position,
7944 ALLOCATOR allocator,
7945 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
7946 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
7947 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
7948 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
7949 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
7950 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
7951 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
7952 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
7953 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
7954{
7955 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
7956 BLOCK_LENGTH,
7957 ALLOCATOR> ElementGuard;
7958
7959 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
7960 BLOCK_LENGTH> EndpointProctor;
7961
7962 size_type frontSize = position - fromBegin;
7963 Iterator begin = fromBegin;
7964 Iterator dest = begin - 1;
7965
7966 BSLS_ASSERT_SAFE(frontSize >= 1);
7967
7968 ElementGuard guard(dest, dest, allocator);
7969
7970
7971 bsl::allocator_traits<ALLOCATOR>::construct(
7972 allocator,
7973 dest.valuePtr(),
7974 MoveUtil::move_if_noexcept(*begin));
7975 guard.moveEnd(1);
7976 ++dest;
7977 ++begin;
7978
7979
7980 size_type n = 0;
7981 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
7982 *dest = MoveUtil::move_if_noexcept(*begin);
7983 ++n;
7984 }
7985 guard.moveEnd(n);
7986
7987
7988 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
7989
7990
7991
7992 EndpointProctor endpointProctor(toBegin, position);
7993
7994 bsl::allocator_traits<ALLOCATOR>::construct(
7995 allocator,
7996 dest.valuePtr(),
7997 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
7998 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
7999 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
8000 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
8001 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
8002 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
8003 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
8004 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
8005
8006 endpointProctor.release();
8007 guard.release();
8008
8009 *toBegin = fromBegin - 1;
8010}
8011#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 8
8012
8013#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
8014template <class VALUE_TYPE, int BLOCK_LENGTH>
8015template <class ALLOCATOR, class Args_01,
8016 class Args_02,
8017 class Args_03,
8018 class Args_04,
8019 class Args_05,
8020 class Args_06,
8021 class Args_07,
8022 class Args_08,
8023 class Args_09>
8024void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
8025 Iterator *toBegin,
8026 Iterator fromBegin,
8027 Iterator position,
8028 ALLOCATOR allocator,
8029 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
8030 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
8031 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
8032 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
8033 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
8034 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
8035 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
8036 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
8037 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
8038 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
8039{
8040 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
8041 BLOCK_LENGTH,
8042 ALLOCATOR> ElementGuard;
8043
8044 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
8045 BLOCK_LENGTH> EndpointProctor;
8046
8047 size_type frontSize = position - fromBegin;
8048 Iterator begin = fromBegin;
8049 Iterator dest = begin - 1;
8050
8051 BSLS_ASSERT_SAFE(frontSize >= 1);
8052
8053 ElementGuard guard(dest, dest, allocator);
8054
8055
8056 bsl::allocator_traits<ALLOCATOR>::construct(
8057 allocator,
8058 dest.valuePtr(),
8059 MoveUtil::move_if_noexcept(*begin));
8060 guard.moveEnd(1);
8061 ++dest;
8062 ++begin;
8063
8064
8065 size_type n = 0;
8066 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
8067 *dest = MoveUtil::move_if_noexcept(*begin);
8068 ++n;
8069 }
8070 guard.moveEnd(n);
8071
8072
8073 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
8074
8075
8076
8077 EndpointProctor endpointProctor(toBegin, position);
8078
8079 bsl::allocator_traits<ALLOCATOR>::construct(
8080 allocator,
8081 dest.valuePtr(),
8082 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
8083 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
8084 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
8085 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
8086 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
8087 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
8088 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
8089 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
8090 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
8091
8092 endpointProctor.release();
8093 guard.release();
8094
8095 *toBegin = fromBegin - 1;
8096}
8097#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 9
8098
8099#if BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
8100template <class VALUE_TYPE, int BLOCK_LENGTH>
8101template <class ALLOCATOR, class Args_01,
8102 class Args_02,
8103 class Args_03,
8104 class Args_04,
8105 class Args_05,
8106 class Args_06,
8107 class Args_07,
8108 class Args_08,
8109 class Args_09,
8110 class Args_10>
8111void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
8112 Iterator *toBegin,
8113 Iterator fromBegin,
8114 Iterator position,
8115 ALLOCATOR allocator,
8116 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
8117 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
8118 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
8119 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
8120 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
8121 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
8122 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
8123 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
8124 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
8125 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
8126 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
8127{
8128 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
8129 BLOCK_LENGTH,
8130 ALLOCATOR> ElementGuard;
8131
8132 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
8133 BLOCK_LENGTH> EndpointProctor;
8134
8135 size_type frontSize = position - fromBegin;
8136 Iterator begin = fromBegin;
8137 Iterator dest = begin - 1;
8138
8139 BSLS_ASSERT_SAFE(frontSize >= 1);
8140
8141 ElementGuard guard(dest, dest, allocator);
8142
8143
8144 bsl::allocator_traits<ALLOCATOR>::construct(
8145 allocator,
8146 dest.valuePtr(),
8147 MoveUtil::move_if_noexcept(*begin));
8148 guard.moveEnd(1);
8149 ++dest;
8150 ++begin;
8151
8152
8153 size_type n = 0;
8154 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
8155 *dest = MoveUtil::move_if_noexcept(*begin);
8156 ++n;
8157 }
8158 guard.moveEnd(n);
8159
8160
8161 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
8162
8163
8164
8165 EndpointProctor endpointProctor(toBegin, position);
8166
8167 bsl::allocator_traits<ALLOCATOR>::construct(
8168 allocator,
8169 dest.valuePtr(),
8170 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
8171 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
8172 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
8173 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
8174 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
8175 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
8176 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
8177 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
8178 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
8179 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
8180
8181 endpointProctor.release();
8182 guard.release();
8183
8184 *toBegin = fromBegin - 1;
8185}
8186#endif // BSLALG_DEQUEPRIMITIVES_VARIADIC_LIMIT_B >= 10
8187
8188#else
8189// The generated code below is a workaround for the absence of perfect
8190// forwarding in some compilers.
8191template <class VALUE_TYPE, int BLOCK_LENGTH>
8192template <class ALLOCATOR, class... Args>
8193inline
8194void
8195DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBack(
8196 Iterator *toEnd,
8197 Iterator fromEnd,
8198 Iterator position,
8199 ALLOCATOR allocator,
8200 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
8201{
8202 enum {
8203 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
8204 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
8205
8206 VALUE = IS_BITWISECOPYABLE
8207 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
8208 : IS_BITWISEMOVEABLE
8209 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
8210 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
8211 };
8212
8213 emplaceAndMoveToBackDispatch(
8214 toEnd,
8215 fromEnd,
8216 position,
8217 allocator,
8218 bsl::integral_constant<int, VALUE>(),
8219 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
8220}
8221
8222template <class VALUE_TYPE, int BLOCK_LENGTH>
8223template <class ALLOCATOR, class... Args>
8224void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
8225 Iterator *toEnd,
8226 Iterator fromEnd,
8227 Iterator position,
8228 ALLOCATOR allocator,
8229 bsl::integral_constant<int,
8230 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
8231 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
8232{
8233 const size_type backSize = fromEnd - position;
8234 Iterator end = fromEnd;
8235 Iterator dest = end + 1;
8236
8237
8238 moveBack(&dest, &end, backSize);
8239 --dest;
8240
8241 bsl::allocator_traits<ALLOCATOR>::construct(
8242 allocator,
8243 dest.valuePtr(),
8244 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
8245
8246 *toEnd = fromEnd + 1;
8247}
8248
8249template <class VALUE_TYPE, int BLOCK_LENGTH>
8250template <class ALLOCATOR, class... Args>
8251void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
8252 Iterator *toEnd,
8253 Iterator fromEnd,
8254 Iterator position,
8255 ALLOCATOR allocator,
8256 bsl::integral_constant<int,
8257 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
8258 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
8259{
8260 const size_type backSize = fromEnd - position;
8261 Iterator end = fromEnd;
8262 Iterator dest = end + 1;
8263
8264
8265 MoveGuard guard(end, dest, backSize, false);
8266
8267 moveBack(&dest, &end, backSize);
8268 --dest;
8269
8270 bsl::allocator_traits<ALLOCATOR>::construct(
8271 allocator,
8272 dest.valuePtr(),
8273 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
8274
8275 guard.release();
8276
8277 *toEnd = fromEnd + 1;
8278}
8279
8280template <class VALUE_TYPE, int BLOCK_LENGTH>
8281template <class ALLOCATOR, class... Args>
8282void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToBackDispatch(
8283 Iterator *toEnd,
8284 Iterator fromEnd,
8285 Iterator position,
8286 ALLOCATOR allocator,
8287 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
8288 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
8289{
8290 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
8291 BLOCK_LENGTH,
8292 ALLOCATOR> ElementGuard;
8293
8294 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
8295 BLOCK_LENGTH> EndpointProctor;
8296
8297 size_type backSize = fromEnd - position;
8298 Iterator end = fromEnd;
8299 Iterator dest = end + 1;
8300
8301 BSLS_ASSERT_SAFE(backSize >= 1);
8302
8303 ElementGuard guard(dest, dest, allocator);
8304
8305
8306 --dest;
8307 --end;
8308 bsl::allocator_traits<ALLOCATOR>::construct(
8309 allocator,
8310 dest.valuePtr(),
8311 MoveUtil::move_if_noexcept(*end));
8312 guard.moveBegin(-1);
8313
8314
8315 size_type n = 0;
8316 for (backSize -= 1; 0 < backSize; --backSize) {
8317 --dest;
8318 --end;
8319 *dest = MoveUtil::move_if_noexcept(*end);
8320 ++n;
8321 }
8322 guard.moveBegin(-n);
8323
8324
8325 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, position.valuePtr());
8326
8327
8328
8329 EndpointProctor endpointProctor(toEnd, position);
8330
8331 bsl::allocator_traits<ALLOCATOR>::construct(
8332 allocator,
8333 position.valuePtr(),
8334 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
8335
8336 endpointProctor.release();
8337 guard.release();
8338
8339 *toEnd = fromEnd + 1;
8340}
8341
8342template <class VALUE_TYPE, int BLOCK_LENGTH>
8343template <class ALLOCATOR, class... Args>
8344inline
8345void
8346DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFront(
8347 Iterator *toBegin,
8348 Iterator fromBegin,
8349 Iterator position,
8350 ALLOCATOR allocator,
8351 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
8352{
8353 enum {
8354 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
8355 IS_BITWISEMOVEABLE = bslmf::IsBitwiseMoveable<VALUE_TYPE>::value,
8356
8357 VALUE = IS_BITWISECOPYABLE
8358 ? BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
8359 : IS_BITWISEMOVEABLE
8360 ? BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
8361 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
8362 };
8363
8364 emplaceAndMoveToFrontDispatch(
8365 toBegin,
8366 fromBegin,
8367 position,
8368 allocator,
8369 bsl::integral_constant<int, VALUE>(),
8370 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
8371}
8372
8373template <class VALUE_TYPE, int BLOCK_LENGTH>
8374template <class ALLOCATOR, class... Args>
8375void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
8376 Iterator *toBegin,
8377 Iterator fromBegin,
8378 Iterator position,
8379 ALLOCATOR allocator,
8380 bsl::integral_constant<int,
8381 BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS>,
8382 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
8383{
8384 const size_type frontSize = position - fromBegin;
8385 Iterator begin = fromBegin;
8386 Iterator dest = begin - 1;
8387
8388
8389 moveFront(&dest, &begin, frontSize);
8390
8391 bsl::allocator_traits<ALLOCATOR>::construct(
8392 allocator,
8393 dest.valuePtr(),
8394 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
8395
8396 *toBegin = fromBegin - 1;
8397}
8398
8399template <class VALUE_TYPE, int BLOCK_LENGTH>
8400template <class ALLOCATOR, class... Args>
8401void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
8402 Iterator *toBegin,
8403 Iterator fromBegin,
8404 Iterator position,
8405 ALLOCATOR allocator,
8406 bsl::integral_constant<int,
8407 BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS>,
8408 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
8409{
8410 const size_type frontSize = position - fromBegin;
8411 Iterator begin = fromBegin;
8412 Iterator dest = begin - 1;
8413
8414
8415 MoveGuard guard(begin, dest, frontSize, true);
8416
8417 moveFront(&dest, &begin, frontSize);
8418
8419 bsl::allocator_traits<ALLOCATOR>::construct(
8420 allocator,
8421 dest.valuePtr(),
8422 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
8423
8424 guard.release();
8425
8426 *toBegin = fromBegin - 1;
8427}
8428
8429template <class VALUE_TYPE, int BLOCK_LENGTH>
8430template <class ALLOCATOR, class... Args>
8431void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::emplaceAndMoveToFrontDispatch(
8432 Iterator *toBegin,
8433 Iterator fromBegin,
8434 Iterator position,
8435 ALLOCATOR allocator,
8436 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>,
8437 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
8438{
8439 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
8440 BLOCK_LENGTH,
8441 ALLOCATOR> ElementGuard;
8442
8443 typedef DequePrimitives_DequeEndpointProctor<VALUE_TYPE,
8444 BLOCK_LENGTH> EndpointProctor;
8445
8446 size_type frontSize = position - fromBegin;
8447 Iterator begin = fromBegin;
8448 Iterator dest = begin - 1;
8449
8450 BSLS_ASSERT_SAFE(frontSize >= 1);
8451
8452 ElementGuard guard(dest, dest, allocator);
8453
8454
8455 bsl::allocator_traits<ALLOCATOR>::construct(
8456 allocator,
8457 dest.valuePtr(),
8458 MoveUtil::move_if_noexcept(*begin));
8459 guard.moveEnd(1);
8460 ++dest;
8461 ++begin;
8462
8463
8464 size_type n = 0;
8465 for (frontSize -= 1; 0 < frontSize; --frontSize, ++dest, ++begin) {
8466 *dest = MoveUtil::move_if_noexcept(*begin);
8467 ++n;
8468 }
8469 guard.moveEnd(n);
8470
8471
8472 bsl::allocator_traits<ALLOCATOR>::destroy(allocator, dest.valuePtr());
8473
8474
8475
8476 EndpointProctor endpointProctor(toBegin, position);
8477
8478 bsl::allocator_traits<ALLOCATOR>::construct(
8479 allocator,
8480 dest.valuePtr(),
8481 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
8482
8483 endpointProctor.release();
8484 guard.release();
8485
8486 *toBegin = fromBegin - 1;
8487}
8488// }}} END GENERATED CODE
8489#endif
8490
8491template <class VALUE_TYPE, int BLOCK_LENGTH>
8492void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>
8493 ::moveBack(Iterator *destination,
8494 Iterator *source,
8495 size_type numElements)
8496{
8497 if (destination->offsetInBlock() > numElements
8498 && source->offsetInBlock() > numElements) {
8499 // There is enough room to move everything at once.
8500
8501 *destination -= numElements;
8502 *source -= numElements;
8503 std::memmove((void *)destination->valuePtr(),
8504 source->valuePtr(),
8505 numElements * sizeof(VALUE_TYPE));
8506
8507 return; // RETURN
8508 }
8509
8510 // Moving the blocks involving segments of 3 different lengths, as
8511 // illustrated below. We need to distinguish whether destination or the
8512 // source have more space remaining, and adjust the algorithm accordingly.
8513 //..
8514 // [--- n ---] - segment 'n'
8515 // [--- n'---] - segment with equal length as 'n'.
8516 // [--- n ---I-- m --] - two segments, with length 'n' and 'm'.
8517 // - - - - - - - -
8518 // | | | | | | | | | - a block in the deque pointed by a 'blockPtr'
8519 // - - - - - - - -
8520 //..
8521 //
8522 // Scenario 1: Source has less element than destination has space
8523 // ==============================================================
8524 // Under this scenario, we have to move all elements from the source block
8525 // to the destination block first (segment 1), then fill the destination
8526 // block with the remaining elements (segment 2). After, we alternate
8527 // between segments 3 and 2.
8528 //..
8529 // [--- 3 ---I- 2'-] [- 1 -] [- 2 -I- 1'-]
8530 // - - - - - - - - - - - - - - - - - - - - - - - -
8531 // |d|e|f|g|h|i|j|k| |a|b|c|/| | | | | | | | | | | | | |
8532 // - - - - - - - - - - - - - - - - - - - - - - - -
8533 // ^ ^
8534 // source ____| destination _____|
8535 //..
8536 //
8537 // Scenario 2: Source has more elements than destination has space
8538 // ================================================================
8539 // Under this scenario, we can only move some elements (the number of
8540 // elements that can fit in the destination block) from the source block to
8541 // the destination block first (segment 1), then move the remaining
8542 // elements (segment 2) from the source block. After, we alternate between
8543 // segments 3 and 2.
8544 //..
8545 // [---- 3 ----]
8546 // [---- 3' ---] [-2-I- 1 -] [2' ] [- 1 -]
8547 // - - - - - - - - - - - - - - - - - - - - - - - -
8548 // |d|e|f|g|h|i|j|k| |a|b|c|d|e|/| | | | | | | | | | | |
8549 // - - - - - - - - - - - - - - - - - - - - - - - -
8550 // ^ ^
8551 // source _____| destination _|
8552 //
8553 // 1) Copy segment 1
8554 // 2) Copy segment 2
8555 // 3) Copy segment 3
8556 // 4) Repeat 2, 3 until there's less than 1 'BLOCK_LENGTH' left
8557 // 5) Copy the remaining items over
8558 //..
8559
8560 size_type firstSegment, secondSegment;
8561 if (source->offsetInBlock() > destination->offsetInBlock()) {
8562 firstSegment = destination->offsetInBlock();
8563 secondSegment = source->offsetInBlock() - firstSegment;
8564 }
8565 else {
8566 firstSegment = source->offsetInBlock();
8567 secondSegment = destination->offsetInBlock() - firstSegment;
8568 }
8569
8570 size_type thirdSegment = BLOCK_LENGTH - secondSegment;
8571
8572 *destination -= firstSegment;
8573 *source -= firstSegment;
8574 numElements -= firstSegment;
8575
8576 std::memmove((void *)destination->valuePtr(),
8577 source->valuePtr(),
8578 firstSegment * sizeof(VALUE_TYPE));
8579
8580 for (; numElements >= BLOCK_LENGTH; numElements -= BLOCK_LENGTH) {
8581
8582 *destination -= secondSegment;
8583 *source -= secondSegment;
8584
8585 std::memmove((void *)destination->valuePtr(),
8586 source->valuePtr(),
8587 secondSegment * sizeof(VALUE_TYPE));
8588
8589 *destination -= thirdSegment;
8590 *source -= thirdSegment;
8591
8592 std::memmove((void *)destination->valuePtr(),
8593 source->valuePtr(),
8594 thirdSegment * sizeof(VALUE_TYPE));
8595 }
8596
8597 size_type remaining = numElements > secondSegment
8598 ? secondSegment
8599 : numElements;
8600
8601 *destination -= remaining;
8602 *source -= remaining;
8603 numElements -= remaining;
8604
8605 std::memmove((void *)destination->valuePtr(),
8606 source->valuePtr(),
8607 remaining * sizeof(VALUE_TYPE));
8608
8609 *destination -= numElements;
8610 *source -= numElements;
8611
8612 std::memmove((void *)destination->valuePtr(),
8613 source->valuePtr(),
8614 numElements * sizeof(VALUE_TYPE));
8615}
8616
8617template <class VALUE_TYPE, int BLOCK_LENGTH>
8618void DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>
8619 ::moveFront(Iterator *destination,
8620 Iterator *source,
8621 size_type numElements)
8622{
8623 if (destination->remainingInBlock() > numElements
8624 && source->remainingInBlock() > numElements) {
8625 // There is enough room to move everything at once
8626
8627 std::memmove((void *)destination->valuePtr(),
8628 source->valuePtr(),
8629 numElements * sizeof(VALUE_TYPE));
8630 *destination += numElements;
8631 *source += numElements;
8632
8633 return; // RETURN
8634 }
8635
8636 // Moving the blocks involving segments of 3 different lengths, as
8637 // illustrated below. We need to distinguish whether destination or the
8638 // source have more space remaining, and adjust the algorithm accordingly.
8639 //..
8640 // [--- n ---] - segment 'n'
8641 // [--- n'---] - segment with equal length as 'n'
8642 // [--- n ---I-- m --] - two segments, with length 'n' and 'm'.
8643 // - - - - - - - -
8644 // | | | | | | | | | - a block in the deque pointed by a 'blockPtr'
8645 // - - - - - - - -
8646 //..
8647 //
8648 // Scenario 1: Source has more elements than destination has space
8649 // ===============================================================
8650 // Under this scenario, we can only move some elements (the number of
8651 // elements that can fit in the destination block) from the source block to
8652 // the destination block first (segment 1), then move the remaining
8653 // elements (segment 2) from the source block. After, we alternate between
8654 // segments 3 and 2.
8655 //..
8656 // [---- 3 ----]
8657 // [- 1 -] [ 2'] [- 1'-I-2-] [---- 3'----]
8658 // - - - - - - - - - - - - - - - - - - - - - - - -
8659 // | | | | | | | | | | | | |a|a|b|c|d| |e|f|g|h|i|j|k|l|
8660 // - - - - - - - - - - - - - - - - - - - - - - - -
8661 // ^ ^
8662 // |_ destination |____ source
8663 //..
8664 //
8665 // Scenario 2: Source has less elements than destination has space
8666 // ===============================================================
8667 // Under this scenario, we have to move all elements from the source block
8668 // to the destination block first (segment 1), then fill the destination
8669 // block with the remaining elements (segment 2). After, we alternate
8670 // between segments 3 and 2.
8671 //..
8672 // [- 1'-I- 2 -] [--- 3'---I- 1 -] [- 2'-I--- 3 ---]
8673 // - - - - - - - - - - - - - - - - - - - - - - - -
8674 // | | | | | | | | | | | | | | |a|b|c| |d|e|f|g|h|i|j|k|
8675 // - - - - - - - - - - - - - - - - - - - - - - - -
8676 // ^ ^
8677 // |_ destination |____ source
8678 //
8679 // 1) Copy segment 1
8680 // 2) Copy segment 2
8681 // 3) Copy segment 3
8682 // 4) Repeat 2, 3 until there's less than 1 'BLOCK_LENGTH' left
8683 // 5) Copy the remaining items over
8684 //..
8685
8686 size_type firstSegment, secondSegment;
8687 if (source->remainingInBlock() > destination->remainingInBlock()) {
8688 firstSegment = destination->remainingInBlock();
8689 secondSegment = source->remainingInBlock() - firstSegment;
8690 }
8691 else {
8692 firstSegment = source->remainingInBlock();
8693 secondSegment = destination->remainingInBlock() - firstSegment;
8694 }
8695
8696 size_type thirdSegment = BLOCK_LENGTH - secondSegment;
8697
8698 std::memmove((void *)destination->valuePtr(),
8699 source->valuePtr(),
8700 firstSegment * sizeof(VALUE_TYPE));
8701
8702 *destination += firstSegment;
8703 *source += firstSegment;
8704 numElements -= firstSegment;
8705
8706 for (; numElements >= BLOCK_LENGTH; numElements -= BLOCK_LENGTH) {
8707
8708 std::memmove((void *)destination->valuePtr(),
8709 source->valuePtr(),
8710 secondSegment * sizeof(VALUE_TYPE));
8711
8712 *destination += secondSegment;
8713 *source += secondSegment;
8714
8715 std::memmove((void *)destination->valuePtr(),
8716 source->valuePtr(),
8717 thirdSegment * sizeof(VALUE_TYPE));
8718
8719 *destination += thirdSegment;
8720 *source += thirdSegment;
8721 }
8722
8723 size_type remaining = numElements > secondSegment
8724 ? secondSegment
8725 : numElements;
8726
8727 std::memmove((void *)destination->valuePtr(),
8728 source->valuePtr(),
8729 remaining * sizeof(VALUE_TYPE));
8730
8731 *destination += remaining;
8732 *source += remaining;
8733 numElements -= remaining;
8734
8735 std::memmove((void *)destination->valuePtr(),
8736 source->valuePtr(),
8737 numElements * sizeof(VALUE_TYPE));
8738
8739 *destination += numElements;
8740 *source += numElements;
8741}
8742
8743template <class VALUE_TYPE, int BLOCK_LENGTH>
8744template <class ALLOCATOR>
8745void
8746DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>
8747 ::uninitializedFillNBack(Iterator *toEnd,
8748 Iterator fromEnd,
8749 size_type numElements,
8750 const VALUE_TYPE& value,
8751 ALLOCATOR allocator)
8752{
8753 if (fromEnd.remainingInBlock() > numElements) {
8754 ArrayPrimitives::uninitializedFillN(fromEnd.valuePtr(),
8755 numElements,
8756 value,
8757 allocator);
8758 fromEnd += numElements;
8759 *toEnd = fromEnd;
8760 return; // RETURN
8761 }
8762
8763 size_type firstRemaining = fromEnd.remainingInBlock();
8764
8765 ArrayPrimitives::uninitializedFillN(fromEnd.valuePtr(),
8766 firstRemaining,
8767 value,
8768 allocator);
8769
8770 numElements -= firstRemaining;
8771 fromEnd += firstRemaining;
8772 *toEnd = fromEnd;
8773
8774 for ( ; numElements >= BLOCK_LENGTH; numElements -= BLOCK_LENGTH) {
8775 ArrayPrimitives::uninitializedFillN(fromEnd.valuePtr(),
8776 BLOCK_LENGTH,
8777 value,
8778 allocator);
8779 fromEnd.nextBlock();
8780 toEnd->nextBlock();
8781 }
8782
8783 ArrayPrimitives::uninitializedFillN(fromEnd.valuePtr(),
8784 numElements,
8785 value,
8786 allocator);
8787
8788 fromEnd += numElements;
8789 *toEnd = fromEnd;
8790}
8791
8792template <class VALUE_TYPE, int BLOCK_LENGTH>
8793template <class ALLOCATOR>
8794void
8795DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>
8796 ::valueInititalizeN(Iterator *toEnd,
8797 Iterator fromEnd,
8798 size_type numElements,
8799 ALLOCATOR allocator)
8800{
8801 if (fromEnd.remainingInBlock() > numElements) {
8802 ArrayPrimitives::defaultConstruct(fromEnd.valuePtr(),
8803 numElements,
8804 allocator);
8805 fromEnd += numElements;
8806 *toEnd = fromEnd;
8807 return; // RETURN
8808 }
8809
8810 size_type firstRemaining = fromEnd.remainingInBlock();
8811
8812 ArrayPrimitives::defaultConstruct(fromEnd.valuePtr(),
8813 firstRemaining,
8814 allocator);
8815
8816 numElements -= firstRemaining;
8817 fromEnd += firstRemaining;
8818 *toEnd = fromEnd;
8819
8820 for ( ; numElements >= BLOCK_LENGTH; numElements -= BLOCK_LENGTH) {
8821 ArrayPrimitives::defaultConstruct(fromEnd.valuePtr(),
8822 BLOCK_LENGTH,
8823 allocator);
8824 fromEnd.nextBlock();
8825 toEnd->nextBlock();
8826 }
8827
8828 ArrayPrimitives::defaultConstruct(fromEnd.valuePtr(),
8829 numElements,
8830 allocator);
8831
8832 fromEnd += numElements;
8833 *toEnd = fromEnd;
8834}
8835
8836template <class VALUE_TYPE, int BLOCK_LENGTH>
8837template <class ALLOCATOR>
8838void
8839DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>
8840 ::uninitializedFillNFront(Iterator *toBegin,
8841 Iterator fromBegin,
8842 size_type numElements,
8843 const VALUE_TYPE& value,
8844 ALLOCATOR allocator)
8845{
8846 if (fromBegin.offsetInBlock() > numElements) {
8847 fromBegin -= numElements;
8848
8849 ArrayPrimitives::uninitializedFillN(fromBegin.valuePtr(),
8850 numElements,
8851 value,
8852 allocator);
8853 *toBegin = fromBegin;
8854 return; // RETURN
8855 }
8856
8857 size_type firstRemaining = fromBegin.offsetInBlock();
8858
8859 fromBegin -= firstRemaining;
8860 numElements -= firstRemaining;
8861
8862 ArrayPrimitives::uninitializedFillN(fromBegin.valuePtr(),
8863 firstRemaining,
8864 value,
8865 allocator);
8866
8867 *toBegin = fromBegin; // in case of exception
8868
8869 for ( ; numElements >= BLOCK_LENGTH; numElements -= BLOCK_LENGTH) {
8870 fromBegin.previousBlock();
8871 ArrayPrimitives::uninitializedFillN(fromBegin.valuePtr(),
8872 BLOCK_LENGTH,
8873 value,
8874 allocator);
8875 *toBegin = fromBegin;
8876 }
8877
8878 fromBegin -= numElements;
8879 ArrayPrimitives::uninitializedFillN(fromBegin.valuePtr(),
8880 numElements,
8881 value,
8882 allocator);
8883
8884 *toBegin = fromBegin;
8885}
8886
8887 // ------------------------------------
8888 // class DequePrimitives<VALUE_TYPE, 1>
8889 // ------------------------------------
8890
8891// CLASS METHODS
8892template <class VALUE_TYPE>
8893template <class ALLOCATOR>
8894typename DequePrimitives<VALUE_TYPE, 1>::Iterator
8895DequePrimitives<VALUE_TYPE, 1>::erase(Iterator *toBegin,
8896 Iterator *toEnd,
8897 Iterator fromBegin,
8898 Iterator first,
8899 Iterator last,
8900 Iterator fromEnd,
8901 ALLOCATOR allocator)
8902{
8903 size_type frontSize = first - fromBegin;
8904 size_type backSize = fromEnd - last;
8905 Iterator ret;
8906
8907 if (frontSize < backSize) {
8908 ret = last;
8909 for (; 0 < frontSize; --frontSize) {
8910 --last;
8911 --first;
8912 *last = *first;
8913 }
8914 *toBegin = last;
8915 *toEnd = fromEnd;
8916 }
8917 else {
8918 ret = first;
8919 for (; 0 < backSize; --backSize, ++first, ++last) {
8920 *first = *last;
8921 }
8922 *toBegin = fromBegin;
8923 *toEnd = first;
8924 }
8925 destruct(first, last, allocator);
8926 return ret;
8927}
8928
8929template <class VALUE_TYPE>
8930template <class ALLOCATOR>
8931void DequePrimitives<VALUE_TYPE, 1>::destruct(Iterator begin,
8932 Iterator end,
8933 ALLOCATOR allocator)
8934{
8935 for (; !(begin == end); ++begin) {
8936 bsl::allocator_traits<ALLOCATOR>::destroy(allocator,
8937 begin.valuePtr());
8938 }
8939}
8940
8941template <class VALUE_TYPE>
8942template <class ALLOCATOR>
8943void
8944DequePrimitives<VALUE_TYPE, 1>
8945 ::insertAndMoveToFront(Iterator *toBegin,
8946 Iterator fromBegin,
8947 Iterator position,
8948 size_type numElements,
8949 const VALUE_TYPE& value,
8950 ALLOCATOR allocator)
8951{
8952 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
8953 1,
8954 ALLOCATOR> ElementGuard;
8955
8956 size_type frontSize = position - fromBegin;
8957 Iterator begin = fromBegin;
8958 Iterator dest = begin - numElements;
8959 size_type numDest;
8960
8961 bsls::ObjectBuffer<VALUE_TYPE> space;
8962 bslma::ConstructionUtil::construct(BSLS_UTIL_ADDRESSOF(space.object()),
8963 bslma::Default::allocator(),
8964 value);
8965 bslma::DestructorProctor<VALUE_TYPE>
8966 temp(BSLS_UTIL_ADDRESSOF(space.object()));
8967
8968 // TBD: this does the same thing as the old code - don't like that we
8969 // circumvent the whole allocator thing, but for now, let's keep it
8970 // consistent.
8971 // ConstructorProxy<VALUE_TYPE>
8972 // tempValue(value, bslma::Default::allocator());
8973
8974 ElementGuard guard(dest, dest, allocator);
8975 if (frontSize >= numElements) {
8976 for (numDest = numElements; 0 < numDest; --numDest, ++dest, ++begin) {
8977 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
8978 dest.valuePtr(),
8979 *begin);
8980 guard.moveEnd(1);
8981 }
8982 for (frontSize -= numElements; 0 < frontSize;
8983 --frontSize, ++dest, ++begin) {
8984 *dest = *begin;
8985 }
8986 for (numDest = numElements; 0 < numDest; --numDest, ++dest) {
8987 *dest = space.object();
8988 }
8989 } else {
8990 for (numDest = frontSize; 0 < numDest; --numDest, ++dest, ++begin) {
8991 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
8992 dest.valuePtr(),
8993 *begin);
8994 guard.moveEnd(1);
8995 }
8996 for (numDest = numElements; frontSize < numDest; --numDest, ++dest) {
8997 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
8998 dest.valuePtr(),
8999 space.object());
9000 guard.moveEnd(1);
9001 }
9002 for (; 0 < numDest; --numDest, ++dest) {
9003 *dest = space.object();
9004 }
9005 }
9006 guard.release();
9007 *toBegin = fromBegin - numElements;
9008}
9009
9010template <class VALUE_TYPE>
9011template <class FWD_ITER, class SENTINEL, class ALLOCATOR>
9012void
9013DequePrimitives<VALUE_TYPE, 1>
9014 ::insertAndMoveToFront(Iterator *toBegin,
9015 Iterator fromBegin,
9016 Iterator position,
9017 FWD_ITER first,
9018 SENTINEL /*last*/,
9019 size_type numElements,
9020 ALLOCATOR allocator)
9021{
9022 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
9023 1,
9024 ALLOCATOR> ElementGuard;
9025
9026 size_type frontSize = position - fromBegin;
9027 Iterator begin = fromBegin;
9028 Iterator dest = begin - numElements;
9029 size_type numDest;
9030
9031 ElementGuard guard(dest, dest, allocator);
9032 if (frontSize >= numElements) {
9033 for (numDest = numElements; 0 < numDest; --numDest, ++dest, ++begin) {
9034 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9035 dest.valuePtr(),
9036 *begin);
9037 guard.moveEnd(1);
9038 }
9039 for (frontSize -= numElements; 0 < frontSize;
9040 --frontSize, ++dest, ++begin) {
9041 *dest = *begin;
9042 }
9043 for (numDest = numElements; 0 < numDest; --numDest, ++dest, ++first) {
9044 *dest = *first;
9045 }
9046 } else {
9047 for (numDest = frontSize; 0 < numDest; --numDest, ++dest, ++begin) {
9048 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9049 dest.valuePtr(),
9050 *begin);
9051 guard.moveEnd(1);
9052 }
9053 for (numDest = numElements; frontSize < numDest;
9054 --numDest, ++dest, ++first) {
9055 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9056 dest.valuePtr(),
9057 *first);
9058 guard.moveEnd(1);
9059 }
9060 for (; 0 < numDest; --numDest, ++dest, ++first) {
9061 *dest = *first;
9062 }
9063 }
9064 guard.release();
9065 *toBegin = fromBegin - numElements;
9066}
9067
9068template <class VALUE_TYPE>
9069template <class ALLOCATOR>
9070void
9071DequePrimitives<VALUE_TYPE, 1>::insertAndMoveToBack(
9072 Iterator *toEnd,
9073 Iterator fromEnd,
9074 Iterator position,
9075 size_type numElements,
9076 const VALUE_TYPE& value,
9077 ALLOCATOR allocator)
9078{
9079 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
9080 1,
9081 ALLOCATOR> ElementGuard;
9082
9083 size_type backSize = fromEnd - position;
9084 Iterator end = fromEnd;
9085 Iterator dest = end + numElements;
9086 size_type numDest;
9087
9088 bsls::ObjectBuffer<VALUE_TYPE> space;
9089 bslma::ConstructionUtil::construct(BSLS_UTIL_ADDRESSOF(space.object()),
9090 bslma::Default::allocator(),
9091 value);
9092 bslma::DestructorProctor<VALUE_TYPE>
9093 temp(BSLS_UTIL_ADDRESSOF(space.object()));
9094
9095 // TBD: this does the same thing as the old code - don't like that we
9096 // circumvent the whole allocator thing, but for now, let's keep it
9097 // consistent.
9098 // ConstructorProxy<VALUE_TYPE>
9099 // tempValue(value, bslma::Default::allocator());
9100
9101 ElementGuard guard(dest, dest, allocator);
9102 if (backSize >= numElements) {
9103 for (numDest = numElements; 0 < numDest; --numDest) {
9104 --dest;
9105 --end;
9106 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9107 dest.valuePtr(),
9108 *end);
9109 guard.moveBegin(-1);
9110 }
9111 for (backSize -= numElements; 0 < backSize; --backSize) {
9112 --dest;
9113 --end;
9114 *dest = *end;
9115 }
9116 for (numDest = numElements; 0 < numDest; --numDest, ++position) {
9117 *position = space.object();
9118 }
9119 } else {
9120 for (numDest = backSize; 0 < numDest; --numDest) {
9121 --dest;
9122 --end;
9123 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9124 dest.valuePtr(),
9125 *end);
9126 guard.moveBegin(-1);
9127 }
9128 for (numDest = numElements; backSize < numDest; --numDest) {
9129 --dest;
9130 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9131 dest.valuePtr(),
9132 space.object());
9133 guard.moveBegin(-1);
9134 }
9135 for (; 0 < numDest; --numDest, ++position) {
9136 *position = space.object();
9137 }
9138 }
9139 guard.release();
9140 *toEnd = fromEnd + numElements;
9141}
9142
9143template <class VALUE_TYPE>
9144template <class FWD_ITER, class SENTINEL, class ALLOCATOR>
9145void
9146DequePrimitives<VALUE_TYPE, 1>::insertAndMoveToBack(Iterator *toEnd,
9147 Iterator fromEnd,
9148 Iterator position,
9149 FWD_ITER first,
9150 SENTINEL /*last*/,
9151 size_type numElements,
9152 ALLOCATOR allocator)
9153{
9154 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
9155 1,
9156 ALLOCATOR> ElementGuard;
9157
9158 size_type backSize = fromEnd - position;
9159 Iterator end = fromEnd;
9160 Iterator dest = end + numElements;
9161 size_type numDest;
9162
9163 ElementGuard guard(dest, dest, allocator);
9164 if (backSize >= numElements) {
9165 for (numDest = numElements; 0 < numDest; --numDest) {
9166 --dest;
9167 --end;
9168 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9169 dest.valuePtr(),
9170 *end);
9171 guard.moveBegin(-1);
9172 }
9173 for (numDest = backSize; numElements < numDest; --numDest) {
9174 --dest;
9175 --end;
9176 *dest = *end;
9177 }
9178 for (; 0 < numDest; ++first, ++position, --numDest) {
9179 *position = *first;
9180 }
9181 } else {
9182 for (numDest = backSize; 0 < numDest; --numDest) {
9183 --dest;
9184 --end;
9185 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9186 dest.valuePtr(),
9187 *end);
9188 guard.moveBegin(-1);
9189 }
9190 for (numDest = backSize; 0 < numDest; --numDest, ++position, ++first) {
9191 *position = *first;
9192 }
9193 ElementGuard guard2(position, position, allocator);
9194 for (numDest = numElements; backSize < numDest; ++first, ++position,
9195 --numDest) {
9196 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9197 position.valuePtr(),
9198 *first);
9199 guard2.moveEnd(1);
9200 }
9201 guard2.release();
9202 }
9203 guard.release();
9204 *toEnd = fromEnd + numElements;
9205}
9206
9207template <class VALUE_TYPE>
9208template <class ALLOCATOR>
9209inline
9210void
9211DequePrimitives<VALUE_TYPE, 1>::uninitializedFillNFront(
9212 Iterator *toBegin,
9213 Iterator fromBegin,
9214 size_type numElements,
9215 const VALUE_TYPE& value,
9216 ALLOCATOR allocator)
9217{
9218 enum {
9219 IS_FUNCTION_POINTER = bslmf::IsFunctionPointer<VALUE_TYPE>::value,
9220 IS_FUNDAMENTAL = bslmf::IsFundamental<VALUE_TYPE>::value,
9221 IS_POINTER = bslmf::IsPointer<VALUE_TYPE>::value,
9222
9223 IS_FUNDAMENTAL_OR_POINTER = IS_FUNDAMENTAL ||
9224 (IS_POINTER && !IS_FUNCTION_POINTER),
9225
9226 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
9227
9228 VALUE = IS_FUNDAMENTAL_OR_POINTER || IS_BITWISECOPYABLE
9229 ? BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS
9230 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
9231 };
9232
9233 uninitializedFillNFront(toBegin,
9234 fromBegin,
9235 numElements,
9236 value,
9237 allocator,
9238 bsl::integral_constant<int, VALUE>());
9239}
9240
9241template <class VALUE_TYPE>
9242template <class ALLOCATOR>
9243void DequePrimitives<VALUE_TYPE, 1>::uninitializedFillNFront(
9244 Iterator *toBegin,
9245 Iterator fromBegin,
9246 size_type numElements,
9247 const VALUE_TYPE& value,
9248 ALLOCATOR allocator,
9249 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
9250{
9251 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
9252 1,
9253 ALLOCATOR> ElementGuard;
9254
9255 ElementGuard guard(fromBegin, fromBegin, allocator);
9256 for (; 0 < numElements; --numElements) {
9257 --fromBegin;
9258 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9259 fromBegin.valuePtr(),
9260 value);
9261 guard.moveBegin(-1);
9262 }
9263 guard.release();
9264 *toBegin = fromBegin;
9265}
9266
9267template <class VALUE_TYPE>
9268template <class ALLOCATOR>
9269void DequePrimitives<VALUE_TYPE, 1>::uninitializedFillNFront(
9270 Iterator *toBegin,
9271 Iterator fromBegin,
9272 size_type numElements,
9273 const VALUE_TYPE& value,
9274 ALLOCATOR allocator,
9275 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS>)
9276{
9277 *toBegin = fromBegin; // necessary in case 'numElements = 0'
9278 for ( ; 0 < numElements; --numElements) {
9279 --fromBegin;
9280 ArrayPrimitives::uninitializedFillN(fromBegin.valuePtr(),
9281 1,
9282 value,
9283 allocator);
9284 *toBegin = fromBegin; // in case of exception
9285 }
9286}
9287
9288template <class VALUE_TYPE>
9289template <class ALLOCATOR>
9290inline
9291void
9292DequePrimitives<VALUE_TYPE, 1>::uninitializedFillNBack(
9293 Iterator *toEnd,
9294 Iterator fromEnd,
9295 size_type numElements,
9296 const VALUE_TYPE& value,
9297 ALLOCATOR allocator)
9298{
9299 enum {
9300 IS_FUNCTION_POINTER = bslmf::IsFunctionPointer<VALUE_TYPE>::value,
9301 IS_FUNDAMENTAL = bslmf::IsFundamental<VALUE_TYPE>::value,
9302 IS_POINTER = bslmf::IsPointer<VALUE_TYPE>::value,
9303
9304 IS_FUNDAMENTAL_OR_POINTER = IS_FUNDAMENTAL ||
9305 (IS_POINTER && !IS_FUNCTION_POINTER),
9306
9307 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
9308
9309 VALUE = IS_FUNDAMENTAL_OR_POINTER || IS_BITWISECOPYABLE
9310 ? BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS
9311 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
9312 };
9313
9314 uninitializedFillNBack(toEnd,
9315 fromEnd,
9316 numElements,
9317 value,
9318 allocator,
9319 bsl::integral_constant<int, VALUE>());
9320}
9321
9322template <class VALUE_TYPE>
9323template <class ALLOCATOR>
9324void DequePrimitives<VALUE_TYPE, 1>::uninitializedFillNBack(
9325 Iterator *toEnd,
9326 Iterator fromEnd,
9327 size_type numElements,
9328 const VALUE_TYPE& value,
9329 ALLOCATOR allocator,
9330 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
9331{
9332 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
9333 1,
9334 ALLOCATOR> ElementGuard;
9335
9336 ElementGuard guard(fromEnd, fromEnd, allocator);
9337 for (; 0 < numElements; --numElements) {
9338 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9339 fromEnd.valuePtr(),
9340 value);
9341 ++fromEnd;
9342 guard.moveEnd(1);
9343 }
9344 guard.release();
9345 *toEnd = fromEnd;
9346}
9347
9348template <class VALUE_TYPE>
9349template <class ALLOCATOR>
9350void DequePrimitives<VALUE_TYPE, 1>::uninitializedFillNBack(
9351 Iterator *toEnd,
9352 Iterator fromEnd,
9353 size_type numElements,
9354 const VALUE_TYPE& value,
9355 ALLOCATOR allocator,
9356 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS>)
9357{
9358 *toEnd = fromEnd; // necessary in case 'numElements = 0'
9359 for ( ; 0 < numElements; --numElements) {
9360 ArrayPrimitives::uninitializedFillN(fromEnd.valuePtr(),
9361 1,
9362 value,
9363 allocator);
9364 ++fromEnd;
9365 *toEnd = fromEnd;
9366 }
9367}
9368
9369template <class VALUE_TYPE>
9370template <class ALLOCATOR>
9371inline
9372void
9373DequePrimitives<VALUE_TYPE, 1>::valueInititalizeN(Iterator *toEnd,
9374 Iterator fromEnd,
9375 size_type numElements,
9376 ALLOCATOR allocator)
9377{
9378 enum {
9379 IS_FUNCTION_POINTER = bslmf::IsFunctionPointer<VALUE_TYPE>::value,
9380 IS_FUNDAMENTAL = bslmf::IsFundamental<VALUE_TYPE>::value,
9381 IS_POINTER = bslmf::IsPointer<VALUE_TYPE>::value,
9382
9383 IS_FUNDAMENTAL_OR_POINTER = IS_FUNDAMENTAL ||
9384 (IS_POINTER && !IS_FUNCTION_POINTER),
9385
9386 IS_BITWISECOPYABLE = bslmf::IsBitwiseCopyable<VALUE_TYPE>::value,
9387
9388 VALUE = IS_FUNDAMENTAL_OR_POINTER || IS_BITWISECOPYABLE
9389 ? BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS
9390 : BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
9391 };
9392
9393 valueInititalizeN(toEnd,
9394 fromEnd,
9395 numElements,
9396 allocator,
9397 bsl::integral_constant<int, VALUE>());
9398}
9399
9400template <class VALUE_TYPE>
9401template <class ALLOCATOR>
9402void DequePrimitives<VALUE_TYPE, 1>::valueInititalizeN(
9403 Iterator *toEnd,
9404 Iterator fromEnd,
9405 size_type numElements,
9406 ALLOCATOR allocator,
9407 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NIL_TRAITS>)
9408{
9409 typedef DequePrimitives_DequeElementGuard<VALUE_TYPE,
9410 1,
9411 ALLOCATOR> ElementGuard;
9412
9413 ElementGuard guard(fromEnd, fromEnd, allocator);
9414 for (; 0 < numElements; --numElements) {
9415 bsl::allocator_traits<ALLOCATOR>::construct(allocator,
9416 fromEnd.valuePtr());
9417 ++fromEnd;
9418 guard.moveEnd(1);
9419 }
9420 guard.release();
9421 *toEnd = fromEnd;
9422}
9423
9424template <class VALUE_TYPE>
9425template <class ALLOCATOR>
9426void DequePrimitives<VALUE_TYPE, 1>::valueInititalizeN(
9427 Iterator *toEnd,
9428 Iterator fromEnd,
9429 size_type numElements,
9430 ALLOCATOR allocator,
9431 bsl::integral_constant<int, BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS>)
9432{
9433 *toEnd = fromEnd; // necessary in case 'numElements = 0'
9434 for ( ; 0 < numElements; --numElements) {
9435 ArrayPrimitives::defaultConstruct(fromEnd.valuePtr(),
9436 1,
9437 allocator);
9438 ++fromEnd;
9439 *toEnd = fromEnd;
9440 }
9441}
9442
9443 // ---------------------------------------
9444 // class DequePrimitives_DequeElementGuard
9445 // ---------------------------------------
9446
9447// CREATORS
9448template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
9449inline
9450DequePrimitives_DequeElementGuard<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>
9451 ::DequePrimitives_DequeElementGuard(const Iterator& begin,
9452 const Iterator& end,
9453 ALLOCATOR allocator)
9454: d_begin(begin)
9455, d_end(end)
9456, d_allocator(allocator)
9457{
9458}
9459
9460template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
9461inline
9462DequePrimitives_DequeElementGuard<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>
9463 ::~DequePrimitives_DequeElementGuard()
9464{
9465 DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::destruct(d_begin,
9466 d_end,
9467 d_allocator);
9468}
9469
9470// MANIPULATORS
9471template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
9472inline
9473typename DequePrimitives_DequeElementGuard
9474<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>::Iterator&
9475DequePrimitives_DequeElementGuard<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>
9476 ::moveBegin(std::ptrdiff_t offset)
9477{
9478 d_begin += offset;
9479 return d_begin;
9480}
9481
9482template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
9483inline
9484typename DequePrimitives_DequeElementGuard
9485<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>::Iterator&
9486DequePrimitives_DequeElementGuard<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>
9487 ::moveEnd(std::ptrdiff_t offset)
9488{
9489 d_end += offset;
9490 return d_end;
9491}
9492
9493template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
9494inline
9495void DequePrimitives_DequeElementGuard<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>::
9496 release()
9497{
9498 d_begin = d_end;
9499}
9500
9501 // -----------------------------------------------
9502 // class DequePrimitives_ExternalDequeElementGuard
9503 // -----------------------------------------------
9504
9505// CREATORS
9506template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
9507inline
9508DequePrimitives_ExternalDequeElementGuard<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>
9509 ::DequePrimitives_ExternalDequeElementGuard(Iterator *begin,
9510 Iterator *end,
9511 ALLOCATOR allocator)
9512: d_begin_p(begin)
9513, d_end_p(end)
9514, d_allocator(allocator)
9515{
9516}
9517
9518template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
9519inline
9520DequePrimitives_ExternalDequeElementGuard<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>
9521 ::~DequePrimitives_ExternalDequeElementGuard()
9522{
9523 if (d_begin_p != d_end_p) {
9524 DequePrimitives<VALUE_TYPE, BLOCK_LENGTH>::destruct(*d_begin_p,
9525 *d_end_p,
9526 d_allocator);
9527 }
9528}
9529
9530// MANIPULATORS
9531template <class VALUE_TYPE, int BLOCK_LENGTH, class ALLOCATOR>
9532inline
9533void
9534DequePrimitives_ExternalDequeElementGuard<VALUE_TYPE, BLOCK_LENGTH, ALLOCATOR>
9535 ::release()
9536{
9537 d_begin_p = d_end_p = 0;
9538}
9539
9540 // ------------------------------------
9541 // class DequePrimitives_DequeMoveGuard
9542 // ------------------------------------
9543
9544// CREATORS
9545template <class VALUE_TYPE, int BLOCK_LENGTH>
9546inline
9547DequePrimitives_DequeMoveGuard<VALUE_TYPE, BLOCK_LENGTH>
9548 ::DequePrimitives_DequeMoveGuard(Iterator dest,
9549 Iterator src,
9550 std::size_t size,
9551 bool isFront)
9552: d_destination_p(dest)
9553, d_source_p(src)
9554, d_size(size)
9555, d_front(isFront)
9556{
9557}
9558
9559template <class VALUE_TYPE, int BLOCK_LENGTH>
9560inline
9561DequePrimitives_DequeMoveGuard<VALUE_TYPE, BLOCK_LENGTH>
9562 ::~DequePrimitives_DequeMoveGuard()
9563{
9564 if (d_size != 0) {
9565 // We need to reverse 'moveFront'.
9566 if (d_front) {
9567 d_destination_p += d_size;
9568 d_source_p += d_size;
9569 DequePrimitives::moveBack(&d_destination_p, &d_source_p, d_size);
9570 }
9571 // We need to reverse 'moveBack'.
9572 else {
9573 d_destination_p -= d_size;
9574 d_source_p -= d_size;
9575 DequePrimitives::moveFront(&d_destination_p, &d_source_p, d_size);
9576 }
9577 }
9578}
9579
9580// MANIPULATORS
9581template <class VALUE_TYPE, int BLOCK_LENGTH>
9582inline
9583void DequePrimitives_DequeMoveGuard<VALUE_TYPE, BLOCK_LENGTH>::release()
9584{
9585 d_size = 0;
9586}
9587
9588 // ------------------------------------------
9589 // class DequePrimitives_DequeEndpointProctor
9590 // ------------------------------------------
9591
9592// CREATORS
9593template <class VALUE_TYPE, int BLOCK_LENGTH>
9594inline
9595DequePrimitives_DequeEndpointProctor<VALUE_TYPE, BLOCK_LENGTH>
9596 ::DequePrimitives_DequeEndpointProctor(Iterator *endpoint,
9597 Iterator position)
9598: d_endpoint_p(endpoint)
9599, d_position(position)
9600{
9601}
9602
9603template <class VALUE_TYPE, int BLOCK_LENGTH>
9604inline
9605DequePrimitives_DequeEndpointProctor<VALUE_TYPE, BLOCK_LENGTH>
9606 ::~DequePrimitives_DequeEndpointProctor()
9607{
9608 if (0 != d_endpoint_p) {
9609 *d_endpoint_p = d_position;
9610 }
9611}
9612
9613// MANIPULATORS
9614template <class VALUE_TYPE, int BLOCK_LENGTH>
9615inline
9616void DequePrimitives_DequeEndpointProctor<VALUE_TYPE, BLOCK_LENGTH>::release()
9617{
9618 d_endpoint_p = 0;
9619}
9620
9621} // close package namespace
9622
9623
9624
9625#else // if ! defined(DEFINED_BSLALG_DEQUEPRIMITIVES_H)
9626# error Not valid except when included from bslalg_dequeprimitives.h
9627#endif // ! defined(COMPILING_BSLALG_DEQUEPRIMITIVES_H)
9628
9629#endif // ! defined(INCLUDED_BSLALG_DEQUEPRIMITIVES_CPP03)
9630
9631// ----------------------------------------------------------------------------
9632// Copyright 2013 Bloomberg Finance L.P.
9633//
9634// Licensed under the Apache License, Version 2.0 (the "License");
9635// you may not use this file except in compliance with the License.
9636// You may obtain a copy of the License at
9637//
9638// http://www.apache.org/licenses/LICENSE-2.0
9639//
9640// Unless required by applicable law or agreed to in writing, software
9641// distributed under the License is distributed on an "AS IS" BASIS,
9642// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
9643// See the License for the specific language governing permissions and
9644// limitations under the License.
9645// ----------------------------- END-OF-FILE ----------------------------------
9646
9647/** @} */
9648/** @} */
9649/** @} */
bslalg::DequePrimitives_DequeElementGuard::moveEnd
Iterator & moveEnd(std::ptrdiff_t offset=1)
Definition bslalg_dequeprimitives.h:3457
bslalg::DequePrimitives_DequeElementGuard::moveBegin
Iterator & moveBegin(std::ptrdiff_t offset=-1)
Definition bslalg_dequeprimitives.h:3446
bslalg::DequePrimitives_DequeElementGuard::release
void release()
Definition bslalg_dequeprimitives.h:3466
bslalg::DequePrimitives_DequeElementGuard::~DequePrimitives_DequeElementGuard
~DequePrimitives_DequeElementGuard()
Definition bslalg_dequeprimitives.h:3433
bslalg::DequePrimitives_DequeElementGuard::Iterator
DequeIterator< VALUE_TYPE, BLOCK_LENGTH > Iterator
Definition bslalg_dequeprimitives.h:951
bslalg::DequePrimitives_DequeEndpointProctor::release
void release()
Definition bslalg_dequeprimitives.h:3586
bslalg::DequePrimitives_DequeEndpointProctor::~DequePrimitives_DequeEndpointProctor
~DequePrimitives_DequeEndpointProctor()
Definition bslalg_dequeprimitives.h:3576
bslalg::DequePrimitives_DequeEndpointProctor::Iterator
DequeIterator< VALUE_TYPE, BLOCK_LENGTH > Iterator
Definition bslalg_dequeprimitives.h:1132
bslalg::DequePrimitives_DequeMoveGuard::release
void release()
Set the size of the range guarded by this object to be zero.
Definition bslalg_dequeprimitives.h:3553
bslalg::DequePrimitives_DequeMoveGuard::~DequePrimitives_DequeMoveGuard
~DequePrimitives_DequeMoveGuard()
Definition bslalg_dequeprimitives.h:3532
bslalg::DequePrimitives_DequeMoveGuard::DequePrimitives
bslalg::DequePrimitives< VALUE_TYPE, BLOCK_LENGTH > DequePrimitives
Definition bslalg_dequeprimitives.h:1079
bslalg::DequePrimitives_DequeMoveGuard::Iterator
DequeIterator< VALUE_TYPE, BLOCK_LENGTH > Iterator
Definition bslalg_dequeprimitives.h:1078
bslalg::DequePrimitives_ExternalDequeElementGuard::~DequePrimitives_ExternalDequeElementGuard
~DequePrimitives_ExternalDequeElementGuard()
Definition bslalg_dequeprimitives.h:3491
bslalg::DequePrimitives_ExternalDequeElementGuard::release
void release()
Definition bslalg_dequeprimitives.h:3505
bslalg::DequePrimitives_ExternalDequeElementGuard::Iterator
DequeIterator< VALUE_TYPE, BLOCK_LENGTH > Iterator
Definition bslalg_dequeprimitives.h:1019
bslma::DestructorProctor
Definition bslma_destructorproctor.h:259
bslmf::MovableRef
Definition bslmf_movableref.h:752
BSLS_ASSERT_SAFE
#define BSLS_ASSERT_SAFE(X)
Definition bsls_assert.h:1917
BSLS_COMPILERFEATURES_FORWARD_REF
#define BSLS_COMPILERFEATURES_FORWARD_REF(T)
Definition bsls_compilerfeatures.h:2343
BSLS_COMPILERFEATURES_FORWARD
#define BSLS_COMPILERFEATURES_FORWARD(T, V)
Definition bsls_compilerfeatures.h:2349
BSLS_UTIL_ADDRESSOF
#define BSLS_UTIL_ADDRESSOF(OBJ)
Definition bsls_util.h:296
bdlat_ArrayFunctions::size
bsl::size_t size(const TYPE &array)
Return the number of elements in the specified array.
bsl::erase
deque< VALUE_TYPE, ALLOCATOR >::size_type erase(deque< VALUE_TYPE, ALLOCATOR > &deq, const BDE_OTHER_TYPE &value)
Definition bslstl_deque.h:4424
bsl::begin
T::iterator begin(T &container)
Definition bslstl_iterator.h:1593
bsl::end
T::iterator end(T &container)
Definition bslstl_iterator.h:1621
bslalg
Definition bdlc_flathashmap.h:2218
bslalg::BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
@ BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS
Definition bslalg_dequeprimitives.h:224
bslalg::BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS
@ BSLALG_DEQUEPRIMITIVES_NON_NIL_TRAITS
Definition bslalg_dequeprimitives.h:225
bslalg::BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
@ BSLALG_DEQUEPRIMITIVES_BITWISE_MOVEABLE_TRAITS
Definition bslalg_dequeprimitives.h:223
bslalg::BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
@ BSLALG_DEQUEPRIMITIVES_NIL_TRAITS
Definition bslalg_dequeprimitives.h:222
bsl::allocator_traits::construct
static void construct(ALLOCATOR_TYPE &basicAllocator, ELEMENT_TYPE *elementAddr, Args &&... arguments)
Definition bslma_allocatortraits.h:1527
bsl::allocator_traits::destroy
static void destroy(ALLOCATOR_TYPE &basicAllocator, ELEMENT_TYPE *elementAddr)
Definition bslma_allocatortraits.h:1549
bsl::integral_constant
Definition bslmf_integralconstant.h:261
bslalg::ArrayPrimitives::defaultConstruct
static void defaultConstruct(typename bsl::allocator_traits< ALLOCATOR >::pointer begin, size_type numElements, ALLOCATOR allocator)
Definition bslalg_arrayprimitives.h:2129
bslalg::ArrayPrimitives::uninitializedFillN
static void uninitializedFillN(typename bsl::allocator_traits< ALLOCATOR >::pointer begin, size_type numElements, const typename bsl::allocator_traits< ALLOCATOR >::value_type &value, ALLOCATOR allocator)
Definition bslalg_arrayprimitives.h:1970
bslalg::DequePrimitives
Definition bslalg_dequeprimitives.h:241
bslalg::DequePrimitives::moveBack
static void moveBack(Iterator *destination, Iterator *source, size_type numElements)
Definition bslalg_dequeprimitives.h:2463
bslalg::DequePrimitives::insertAndMoveToBack
static void insertAndMoveToBack(Iterator *toEnd, Iterator fromEnd, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator)
Definition bslalg_dequeprimitives.h:1339
bslalg::DequePrimitives::insertAndMoveToFront
static void insertAndMoveToFront(Iterator *toBegin, Iterator fromBegin, Iterator position, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator)
Definition bslalg_dequeprimitives.h:1754
bslalg::DequePrimitives::uninitializedFillNFront
static void uninitializedFillNFront(Iterator *toBegin, Iterator fromBegin, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator)
Definition bslalg_dequeprimitives.h:2810
bslalg::DequePrimitives::uninitializedFillNBack
static void uninitializedFillNBack(Iterator *toEnd, Iterator fromEnd, size_type numElements, const VALUE_TYPE &value, ALLOCATOR allocator)
Definition bslalg_dequeprimitives.h:2717
bslalg::DequePrimitives::moveInsertAndMoveToFront
static void moveInsertAndMoveToFront(Iterator *toBegin, Iterator fromBegin, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator)
Definition bslalg_dequeprimitives.h:2005
bslalg::DequePrimitives::emplaceAndMoveToBack
static void emplaceAndMoveToBack(Iterator *toEnd, Iterator fromEnd, Iterator position, ALLOCATOR allocator, Args &&... arguments)
Definition bslalg_dequeprimitives.h:2146
bslalg::DequePrimitives::size_type
std::size_t size_type
Definition bslalg_dequeprimitives.h:244
bslalg::DequePrimitives::emplaceAndMoveToFront
static void emplaceAndMoveToFront(Iterator *toBegin, Iterator fromBegin, Iterator position, ALLOCATOR allocator, Args &&... arguments)
Definition bslalg_dequeprimitives.h:2307
bslalg::DequePrimitives::Iterator
DequeIterator< VALUE_TYPE, BLOCK_LENGTH > Iterator
Definition bslalg_dequeprimitives.h:245
bslalg::DequePrimitives::valueInititalizeN
static void valueInititalizeN(Iterator *toEnd, Iterator fromEnd, size_type numElements, ALLOCATOR allocator)
Definition bslalg_dequeprimitives.h:2766
bslalg::DequePrimitives::moveInsertAndMoveToBack
static void moveInsertAndMoveToBack(Iterator *toEnd, Iterator fromEnd, Iterator position, bslmf::MovableRef< VALUE_TYPE > value, ALLOCATOR allocator)
Definition bslalg_dequeprimitives.h:1609
bslalg::DequePrimitives::erase
static Iterator erase(Iterator *toBegin, Iterator *toEnd, Iterator fromBegin, Iterator first, Iterator last, Iterator fromEnd, ALLOCATOR allocator)
Definition bslalg_dequeprimitives.h:1229
bslalg::DequePrimitives::destruct
static void destruct(Iterator begin, Iterator end, ALLOCATOR allocator)
Definition bslalg_dequeprimitives.h:1181
bslalg::DequePrimitives::moveFront
static void moveFront(Iterator *destination, Iterator *source, size_type numElements)
Definition bslalg_dequeprimitives.h:2589
bslalg::DequePrimitives::emplaceAndMoveToFrontDispatch
static void emplaceAndMoveToFrontDispatch(Iterator *toBegin, Iterator fromBegin, Iterator position, ALLOCATOR allocator, bsl::integral_constant< int, BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS >, Args &&... arguments)
Definition bslalg_dequeprimitives.h:2336
bslalg::DequePrimitives::emplaceAndMoveToBackDispatch
static void emplaceAndMoveToBackDispatch(Iterator *toEnd, Iterator fromEnd, Iterator position, ALLOCATOR allocator, bsl::integral_constant< int, BSLALG_DEQUEPRIMITIVES_BITWISE_COPYABLE_TRAITS >, Args &&... arguments)
Definition bslalg_dequeprimitives.h:2175
bslma::ConstructionUtil::construct
static void construct(TARGET_TYPE *address, const ALLOCATOR &allocator)
Definition bslma_constructionutil.h:1244
bslma::Default::allocator
static Allocator * allocator(Allocator *basicAllocator=0)
Definition bslma_default.h:913
bslmf::IsBitwiseCopyable
Definition bslmf_isbitwisecopyable.h:298
bslmf::IsBitwiseMoveable
Definition bslmf_isbitwisemoveable.h:718
bslmf::IsFunctionPointer
Definition bslmf_functionpointertraits.h:163
bslmf::IsFundamental
Definition bslmf_isfundamental.h:303
bslmf::IsPointer
Definition bslmf_ispointer.h:198
bslmf::MovableRefUtil
Definition bslmf_movableref.h:795
bsls::ObjectBuffer
Definition bsls_objectbuffer.h:277
bsls::ObjectBuffer::object
TYPE & object()
Definition bsls_objectbuffer.h:352