BDE 4.39.x Production Release
Loading...
Searching...
No Matches
bsltf_stdallocatoradaptor_cpp03.h
Go to the documentation of this file.
1/// @file bsltf_stdallocatoradaptor_cpp03.h
2///
3/// The content of this file has been pre-processed for Doxygen.
4///
5
6
7// bsltf_stdallocatoradaptor_cpp03.h -*-C++-*-
8
9// Automatically generated file. **DO NOT EDIT**
10
11#ifndef INCLUDED_BSLTF_STDALLOCATORADAPTOR_CPP03
12#define INCLUDED_BSLTF_STDALLOCATORADAPTOR_CPP03
13
14/// @defgroup bsltf_stdallocatoradaptor_cpp03 bsltf_stdallocatoradaptor_cpp03
15/// @brief Provide C++03 implementation for bsltf_stdallocatoradaptor.h
16/// @addtogroup bsl
17/// @{
18/// @addtogroup bsltf
19/// @{
20/// @addtogroup bsltf_stdallocatoradaptor_cpp03
21/// @{
22///
23/// <h1> Outline </h1>
24/// * <a href="#bsltf_stdallocatoradaptor_cpp03-purpose"> Purpose</a>
25/// * <a href="#bsltf_stdallocatoradaptor_cpp03-classes"> Classes </a>
26/// * <a href="#bsltf_stdallocatoradaptor_cpp03-description"> Description </a>
27///
28/// # Purpose {#bsltf_stdallocatoradaptor_cpp03-purpose}
29/// Provide C++03 implementation for bsltf_stdallocatoradaptor.h
30///
31/// # Classes {#bsltf_stdallocatoradaptor_cpp03-classes}
32/// See bsltf_stdallocatoradaptor.h for list of classes
33///
34/// @see bsltf_stdallocatoradaptor
35///
36/// # Description {#bsltf_stdallocatoradaptor_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 Sun Sep 1 05:38:52 2024
48/// Command line: sim_cpp11_features.pl bsltf_stdallocatoradaptor.h
49/// @}
50/** @} */
51/** @} */
52
53/** @addtogroup bsl
54 * @{
55 */
56/** @addtogroup bsltf
57 * @{
58 */
59/** @addtogroup bsltf_stdallocatoradaptor_cpp03
60 * @{
61 */
62
63#ifdef COMPILING_BSLTF_STDALLOCATORADAPTOR_H
64
65
66namespace bsltf {
67
68 // =========================
69 // class StdAllocatorAdaptor
70 // =========================
71
72/// This class template provides the facade of an allocator but mostly
73/// delegates operations to the allocator object (of template parameter
74/// type) it adapts, except that it enables the propagation of the
75/// (stateful) allocator object to constructed elements, if appropriate.
76///
77/// See @ref bsltf_stdallocatoradaptor_cpp03
78template <class ALLOCATOR>
79class StdAllocatorAdaptor : public ALLOCATOR {
80
81 // PRIVATE TYPES
82 typedef bsl::allocator_traits<ALLOCATOR> AllocatorTraits;
83
84 // PRIVATE MANIPULATORS
85#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
86// {{{ BEGIN GENERATED CODE
87// Command line: sim_cpp11_features.pl bsltf_stdallocatoradaptor.h
88#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
89#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT 14
90#endif
91#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A
92#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
93#endif
94
95#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 0
96 template <class ELEMENT_TYPE>
97 void privateConstruct(bsl::true_type,
98 ELEMENT_TYPE *elemAddr);
99#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 0
100
101#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 1
102 template <class ELEMENT_TYPE, class Args_01>
103 void privateConstruct(bsl::true_type,
104 ELEMENT_TYPE *elemAddr,
105 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
106#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 1
107
108#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 2
109 template <class ELEMENT_TYPE, class Args_01,
110 class Args_02>
111 void privateConstruct(bsl::true_type,
112 ELEMENT_TYPE *elemAddr,
113 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
114 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
115#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 2
116
117#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 3
118 template <class ELEMENT_TYPE, class Args_01,
119 class Args_02,
120 class Args_03>
121 void privateConstruct(bsl::true_type,
122 ELEMENT_TYPE *elemAddr,
123 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
124 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
125 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
126#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 3
127
128#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 4
129 template <class ELEMENT_TYPE, class Args_01,
130 class Args_02,
131 class Args_03,
132 class Args_04>
133 void privateConstruct(bsl::true_type,
134 ELEMENT_TYPE *elemAddr,
135 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
136 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
137 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
138 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
139#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 4
140
141#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 5
142 template <class ELEMENT_TYPE, class Args_01,
143 class Args_02,
144 class Args_03,
145 class Args_04,
146 class Args_05>
147 void privateConstruct(bsl::true_type,
148 ELEMENT_TYPE *elemAddr,
149 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
150 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
151 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
152 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
153 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
154#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 5
155
156#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 6
157 template <class ELEMENT_TYPE, class Args_01,
158 class Args_02,
159 class Args_03,
160 class Args_04,
161 class Args_05,
162 class Args_06>
163 void privateConstruct(bsl::true_type,
164 ELEMENT_TYPE *elemAddr,
165 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
166 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
167 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
168 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
169 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
170 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
171#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 6
172
173#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 7
174 template <class ELEMENT_TYPE, class Args_01,
175 class Args_02,
176 class Args_03,
177 class Args_04,
178 class Args_05,
179 class Args_06,
180 class Args_07>
181 void privateConstruct(bsl::true_type,
182 ELEMENT_TYPE *elemAddr,
183 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
184 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
185 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
186 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
187 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
188 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
189 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
190#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 7
191
192#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 8
193 template <class ELEMENT_TYPE, class Args_01,
194 class Args_02,
195 class Args_03,
196 class Args_04,
197 class Args_05,
198 class Args_06,
199 class Args_07,
200 class Args_08>
201 void privateConstruct(bsl::true_type,
202 ELEMENT_TYPE *elemAddr,
203 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
204 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
205 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
206 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
207 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
208 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
209 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
210 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
211#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 8
212
213#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 9
214 template <class ELEMENT_TYPE, class Args_01,
215 class Args_02,
216 class Args_03,
217 class Args_04,
218 class Args_05,
219 class Args_06,
220 class Args_07,
221 class Args_08,
222 class Args_09>
223 void privateConstruct(bsl::true_type,
224 ELEMENT_TYPE *elemAddr,
225 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
226 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
227 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
228 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
229 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
230 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
231 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
232 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
233 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
234#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 9
235
236#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 10
237 template <class ELEMENT_TYPE, class Args_01,
238 class Args_02,
239 class Args_03,
240 class Args_04,
241 class Args_05,
242 class Args_06,
243 class Args_07,
244 class Args_08,
245 class Args_09,
246 class Args_10>
247 void privateConstruct(bsl::true_type,
248 ELEMENT_TYPE *elemAddr,
249 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
250 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
251 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
252 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
253 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
254 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
255 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
256 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
257 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
258 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
259#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 10
260
261#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 11
262 template <class ELEMENT_TYPE, class Args_01,
263 class Args_02,
264 class Args_03,
265 class Args_04,
266 class Args_05,
267 class Args_06,
268 class Args_07,
269 class Args_08,
270 class Args_09,
271 class Args_10,
272 class Args_11>
273 void privateConstruct(bsl::true_type,
274 ELEMENT_TYPE *elemAddr,
275 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
276 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
277 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
278 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
279 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
280 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
281 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
282 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
283 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
284 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
285 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11);
286#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 11
287
288#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 12
289 template <class ELEMENT_TYPE, class Args_01,
290 class Args_02,
291 class Args_03,
292 class Args_04,
293 class Args_05,
294 class Args_06,
295 class Args_07,
296 class Args_08,
297 class Args_09,
298 class Args_10,
299 class Args_11,
300 class Args_12>
301 void privateConstruct(bsl::true_type,
302 ELEMENT_TYPE *elemAddr,
303 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
304 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
305 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
306 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
307 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
308 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
309 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
310 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
311 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
312 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
313 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
314 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12);
315#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 12
316
317#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 13
318 template <class ELEMENT_TYPE, class Args_01,
319 class Args_02,
320 class Args_03,
321 class Args_04,
322 class Args_05,
323 class Args_06,
324 class Args_07,
325 class Args_08,
326 class Args_09,
327 class Args_10,
328 class Args_11,
329 class Args_12,
330 class Args_13>
331 void privateConstruct(bsl::true_type,
332 ELEMENT_TYPE *elemAddr,
333 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
334 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
335 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
336 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
337 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
338 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
339 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
340 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
341 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
342 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
343 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
344 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
345 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13);
346#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 13
347
348#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 14
349 template <class ELEMENT_TYPE, class Args_01,
350 class Args_02,
351 class Args_03,
352 class Args_04,
353 class Args_05,
354 class Args_06,
355 class Args_07,
356 class Args_08,
357 class Args_09,
358 class Args_10,
359 class Args_11,
360 class Args_12,
361 class Args_13,
362 class Args_14>
363 void privateConstruct(bsl::true_type,
364 ELEMENT_TYPE *elemAddr,
365 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
366 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
367 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
368 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
369 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
370 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
371 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
372 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
373 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
374 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
375 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
376 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
377 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
378 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14);
379#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 14
380
381
382#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 0
383 template <class ELEMENT_TYPE>
384 void privateConstruct(bsl::false_type,
385 ELEMENT_TYPE *elemAddr);
386#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 0
387
388#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 1
389 template <class ELEMENT_TYPE, class Args_01>
390 void privateConstruct(bsl::false_type,
391 ELEMENT_TYPE *elemAddr,
392 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
393#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 1
394
395#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 2
396 template <class ELEMENT_TYPE, class Args_01,
397 class Args_02>
398 void privateConstruct(bsl::false_type,
399 ELEMENT_TYPE *elemAddr,
400 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
401 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
402#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 2
403
404#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 3
405 template <class ELEMENT_TYPE, class Args_01,
406 class Args_02,
407 class Args_03>
408 void privateConstruct(bsl::false_type,
409 ELEMENT_TYPE *elemAddr,
410 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
411 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
412 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
413#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 3
414
415#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 4
416 template <class ELEMENT_TYPE, class Args_01,
417 class Args_02,
418 class Args_03,
419 class Args_04>
420 void privateConstruct(bsl::false_type,
421 ELEMENT_TYPE *elemAddr,
422 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
423 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
424 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
425 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
426#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 4
427
428#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 5
429 template <class ELEMENT_TYPE, class Args_01,
430 class Args_02,
431 class Args_03,
432 class Args_04,
433 class Args_05>
434 void privateConstruct(bsl::false_type,
435 ELEMENT_TYPE *elemAddr,
436 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
437 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
438 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
439 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
440 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
441#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 5
442
443#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 6
444 template <class ELEMENT_TYPE, class Args_01,
445 class Args_02,
446 class Args_03,
447 class Args_04,
448 class Args_05,
449 class Args_06>
450 void privateConstruct(bsl::false_type,
451 ELEMENT_TYPE *elemAddr,
452 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
453 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
454 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
455 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
456 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
457 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
458#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 6
459
460#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 7
461 template <class ELEMENT_TYPE, class Args_01,
462 class Args_02,
463 class Args_03,
464 class Args_04,
465 class Args_05,
466 class Args_06,
467 class Args_07>
468 void privateConstruct(bsl::false_type,
469 ELEMENT_TYPE *elemAddr,
470 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
471 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
472 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
473 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
474 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
475 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
476 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
477#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 7
478
479#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 8
480 template <class ELEMENT_TYPE, class Args_01,
481 class Args_02,
482 class Args_03,
483 class Args_04,
484 class Args_05,
485 class Args_06,
486 class Args_07,
487 class Args_08>
488 void privateConstruct(bsl::false_type,
489 ELEMENT_TYPE *elemAddr,
490 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
491 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
492 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
493 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
494 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
495 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
496 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
497 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
498#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 8
499
500#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 9
501 template <class ELEMENT_TYPE, class Args_01,
502 class Args_02,
503 class Args_03,
504 class Args_04,
505 class Args_05,
506 class Args_06,
507 class Args_07,
508 class Args_08,
509 class Args_09>
510 void privateConstruct(bsl::false_type,
511 ELEMENT_TYPE *elemAddr,
512 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
513 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
514 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
515 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
516 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
517 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
518 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
519 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
520 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
521#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 9
522
523#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 10
524 template <class ELEMENT_TYPE, class Args_01,
525 class Args_02,
526 class Args_03,
527 class Args_04,
528 class Args_05,
529 class Args_06,
530 class Args_07,
531 class Args_08,
532 class Args_09,
533 class Args_10>
534 void privateConstruct(bsl::false_type,
535 ELEMENT_TYPE *elemAddr,
536 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
537 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
538 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
539 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
540 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
541 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
542 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
543 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
544 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
545 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
546#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 10
547
548#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 11
549 template <class ELEMENT_TYPE, class Args_01,
550 class Args_02,
551 class Args_03,
552 class Args_04,
553 class Args_05,
554 class Args_06,
555 class Args_07,
556 class Args_08,
557 class Args_09,
558 class Args_10,
559 class Args_11>
560 void privateConstruct(bsl::false_type,
561 ELEMENT_TYPE *elemAddr,
562 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
563 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
564 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
565 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
566 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
567 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
568 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
569 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
570 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
571 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
572 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11);
573#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 11
574
575#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 12
576 template <class ELEMENT_TYPE, class Args_01,
577 class Args_02,
578 class Args_03,
579 class Args_04,
580 class Args_05,
581 class Args_06,
582 class Args_07,
583 class Args_08,
584 class Args_09,
585 class Args_10,
586 class Args_11,
587 class Args_12>
588 void privateConstruct(bsl::false_type,
589 ELEMENT_TYPE *elemAddr,
590 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
591 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
592 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
593 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
594 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
595 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
596 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
597 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
598 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
599 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
600 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
601 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12);
602#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 12
603
604#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 13
605 template <class ELEMENT_TYPE, class Args_01,
606 class Args_02,
607 class Args_03,
608 class Args_04,
609 class Args_05,
610 class Args_06,
611 class Args_07,
612 class Args_08,
613 class Args_09,
614 class Args_10,
615 class Args_11,
616 class Args_12,
617 class Args_13>
618 void privateConstruct(bsl::false_type,
619 ELEMENT_TYPE *elemAddr,
620 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
621 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
622 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
623 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
624 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
625 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
626 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
627 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
628 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
629 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
630 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
631 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
632 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13);
633#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 13
634
635#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 14
636 template <class ELEMENT_TYPE, class Args_01,
637 class Args_02,
638 class Args_03,
639 class Args_04,
640 class Args_05,
641 class Args_06,
642 class Args_07,
643 class Args_08,
644 class Args_09,
645 class Args_10,
646 class Args_11,
647 class Args_12,
648 class Args_13,
649 class Args_14>
650 void privateConstruct(bsl::false_type,
651 ELEMENT_TYPE *elemAddr,
652 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
653 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
654 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
655 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
656 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
657 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
658 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
659 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
660 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
661 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
662 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
663 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
664 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
665 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14);
666#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_A >= 14
667
668#else
669// The generated code below is a workaround for the absence of perfect
670// forwarding in some compilers.
671
672 template <class ELEMENT_TYPE, class... Args>
673 void privateConstruct(bsl::true_type,
674 ELEMENT_TYPE *elemAddr,
675 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
676
677 template <class ELEMENT_TYPE, class... Args>
678 void privateConstruct(bsl::false_type,
679 ELEMENT_TYPE *elemAddr,
680 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
681
682// }}} END GENERATED CODE
683#endif
684
685 public:
686 // TRAITS
687 BSLMF_NESTED_TRAIT_DECLARATION(StdAllocatorAdaptor, bslma::IsStdAllocator);
688
689 // PUBLIC TYPES
690 typedef typename ALLOCATOR::size_type size_type;
691 typedef typename ALLOCATOR::difference_type difference_type;
692 typedef typename ALLOCATOR::pointer pointer;
693 typedef typename ALLOCATOR::const_pointer const_pointer;
694 typedef typename ALLOCATOR::reference reference;
695 typedef typename ALLOCATOR::const_reference const_reference;
696 typedef typename ALLOCATOR::value_type value_type;
697
698 /// This nested `struct` template, parameterized by some
699 /// `BDE_OTHER_TYPE`, provides a namespace for an `other` type alias,
700 /// which is an allocator type following the same template as this one but that allocates elements of `BDE_OTHER_TYPE`.
701 ///
702 /// \note Note that this
703 /// allocator type is convertible to and from `other` for any
704 /// `BDE_OTHER_TYPE` including `void`.
705 template <class BDE_OTHER_TYPE>
706 struct rebind
707 {
708
709 typedef StdAllocatorAdaptor<
710 typename ALLOCATOR::template rebind<BDE_OTHER_TYPE>::other> other;
711 };
712
713 // CREATORS
714
715 /// Create a standard allocator adaptor object for a default-constructed
716 /// allocator object of the (template parameter) type `ALLOCATOR`.
717 StdAllocatorAdaptor();
718
719 /// Create a standard allocator adaptor object for the specified
720 /// `allocator` of the (template parameter) type `ALLOCATOR`.
721 explicit StdAllocatorAdaptor(const ALLOCATOR& allocator);
722
723 /// Create a standard allocator adaptor object from the null pointer
724 /// constant.
725 explicit StdAllocatorAdaptor(bsl::nullptr_t);
726
727 /// Create a copy of the specified `other` allocator adaptor.
728 template <class ANY_TYPE>
729 StdAllocatorAdaptor(const StdAllocatorAdaptor<ANY_TYPE>& other);
730
731#ifdef BSLS_COMPILERFEATURES_SUPPORT_DEFAULTED_FUNCTIONS
732 /// Create a copy of the specified `original` allocator adaptor.
733 StdAllocatorAdaptor(const StdAllocatorAdaptor& original) = default;
734#else
735 StdAllocatorAdaptor(const StdAllocatorAdaptor& original) = default;
736#endif
737
738 ~StdAllocatorAdaptor() = default;
739 // Destroy this object.
740
741 // MANIPULATORS
742#ifdef BSLS_COMPILERFEATURES_SUPPORT_DEFAULTED_FUNCTIONS
743 /// Assign to this object the value of the specified `rhs` object, and
744 /// return a reference providing modifiable access to this object.
745 StdAllocatorAdaptor& operator=(const StdAllocatorAdaptor& original) =
746 default;
747#else
748 StdAllocatorAdaptor& operator=(const StdAllocatorAdaptor& rhs) =
749 default;
750#endif
751
752#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
753// {{{ BEGIN GENERATED CODE
754// Command line: sim_cpp11_features.pl bsltf_stdallocatoradaptor.h
755#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
756#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT 14
757#endif
758#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B
759#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
760#endif
761
762#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 0
763 template <class ELEMENT_TYPE>
764 void construct(ELEMENT_TYPE *address);
765#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 0
766
767#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 1
768 template <class ELEMENT_TYPE, class Args_01>
769 void construct(ELEMENT_TYPE *address,
770 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
771#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 1
772
773#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 2
774 template <class ELEMENT_TYPE, class Args_01,
775 class Args_02>
776 void construct(ELEMENT_TYPE *address,
777 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
778 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
779#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 2
780
781#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 3
782 template <class ELEMENT_TYPE, class Args_01,
783 class Args_02,
784 class Args_03>
785 void construct(ELEMENT_TYPE *address,
786 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
787 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
788 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
789#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 3
790
791#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 4
792 template <class ELEMENT_TYPE, class Args_01,
793 class Args_02,
794 class Args_03,
795 class Args_04>
796 void construct(ELEMENT_TYPE *address,
797 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
798 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
799 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
800 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
801#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 4
802
803#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 5
804 template <class ELEMENT_TYPE, class Args_01,
805 class Args_02,
806 class Args_03,
807 class Args_04,
808 class Args_05>
809 void construct(ELEMENT_TYPE *address,
810 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
811 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
812 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
813 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
814 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
815#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 5
816
817#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 6
818 template <class ELEMENT_TYPE, class Args_01,
819 class Args_02,
820 class Args_03,
821 class Args_04,
822 class Args_05,
823 class Args_06>
824 void construct(ELEMENT_TYPE *address,
825 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
826 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
827 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
828 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
829 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
830 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
831#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 6
832
833#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 7
834 template <class ELEMENT_TYPE, class Args_01,
835 class Args_02,
836 class Args_03,
837 class Args_04,
838 class Args_05,
839 class Args_06,
840 class Args_07>
841 void construct(ELEMENT_TYPE *address,
842 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
843 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
844 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
845 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
846 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
847 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
848 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
849#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 7
850
851#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 8
852 template <class ELEMENT_TYPE, class Args_01,
853 class Args_02,
854 class Args_03,
855 class Args_04,
856 class Args_05,
857 class Args_06,
858 class Args_07,
859 class Args_08>
860 void construct(ELEMENT_TYPE *address,
861 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
862 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
863 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
864 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
865 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
866 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
867 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
868 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
869#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 8
870
871#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 9
872 template <class ELEMENT_TYPE, class Args_01,
873 class Args_02,
874 class Args_03,
875 class Args_04,
876 class Args_05,
877 class Args_06,
878 class Args_07,
879 class Args_08,
880 class Args_09>
881 void construct(ELEMENT_TYPE *address,
882 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
883 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
884 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
885 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
886 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
887 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
888 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
889 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
890 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
891#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 9
892
893#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 10
894 template <class ELEMENT_TYPE, class Args_01,
895 class Args_02,
896 class Args_03,
897 class Args_04,
898 class Args_05,
899 class Args_06,
900 class Args_07,
901 class Args_08,
902 class Args_09,
903 class Args_10>
904 void construct(ELEMENT_TYPE *address,
905 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
906 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
907 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
908 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
909 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
910 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
911 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
912 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
913 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
914 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
915#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 10
916
917#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 11
918 template <class ELEMENT_TYPE, class Args_01,
919 class Args_02,
920 class Args_03,
921 class Args_04,
922 class Args_05,
923 class Args_06,
924 class Args_07,
925 class Args_08,
926 class Args_09,
927 class Args_10,
928 class Args_11>
929 void construct(ELEMENT_TYPE *address,
930 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
931 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
932 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
933 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
934 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
935 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
936 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
937 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
938 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
939 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
940 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11);
941#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 11
942
943#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 12
944 template <class ELEMENT_TYPE, class Args_01,
945 class Args_02,
946 class Args_03,
947 class Args_04,
948 class Args_05,
949 class Args_06,
950 class Args_07,
951 class Args_08,
952 class Args_09,
953 class Args_10,
954 class Args_11,
955 class Args_12>
956 void construct(ELEMENT_TYPE *address,
957 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
958 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
959 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
960 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
961 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
962 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
963 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
964 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
965 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
966 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
967 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
968 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12);
969#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 12
970
971#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 13
972 template <class ELEMENT_TYPE, class Args_01,
973 class Args_02,
974 class Args_03,
975 class Args_04,
976 class Args_05,
977 class Args_06,
978 class Args_07,
979 class Args_08,
980 class Args_09,
981 class Args_10,
982 class Args_11,
983 class Args_12,
984 class Args_13>
985 void construct(ELEMENT_TYPE *address,
986 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
987 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
988 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
989 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
990 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
991 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
992 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
993 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
994 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
995 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
996 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
997 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
998 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13);
999#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 13
1000
1001#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 14
1002 template <class ELEMENT_TYPE, class Args_01,
1003 class Args_02,
1004 class Args_03,
1005 class Args_04,
1006 class Args_05,
1007 class Args_06,
1008 class Args_07,
1009 class Args_08,
1010 class Args_09,
1011 class Args_10,
1012 class Args_11,
1013 class Args_12,
1014 class Args_13,
1015 class Args_14>
1016 void construct(ELEMENT_TYPE *address,
1017 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1018 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1019 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1020 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1021 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1022 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1023 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1024 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1025 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1026 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1027 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1028 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
1029 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
1030 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14);
1031#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 14
1032
1033#else
1034// The generated code below is a workaround for the absence of perfect
1035// forwarding in some compilers.
1036
1037 template <class ELEMENT_TYPE, class... Args>
1038 void construct(ELEMENT_TYPE *address,
1039 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
1040// }}} END GENERATED CODE
1041#endif
1042
1043 // ACCESSORS
1044
1045 /// Return a reference to the non-modifiable allocator instance
1046 /// associated with this standard allocator adaptor.
1047 const ALLOCATOR& allocator() const;
1048
1049 /// Return an allocator adaptor for the allocator object returned by the
1050 /// @ref select_on_container_copy_construction class method in the
1051 /// `allocator_traits` class template for the allocator object, of the
1052 /// (template parameter) type `ALLOCATOR`, associated with this adaptor.
1053 /// The `allocator_traits` class template presumably delegates this call
1054 /// to the allocator object if such an operation is supported by the
1055 /// `ALLOCATOR` type, or provides a suitable default behavior if such an
1056 /// operation is not supported.
1057 StdAllocatorAdaptor<ALLOCATOR>
1058 select_on_container_copy_construction() const;
1059};
1060
1061// FREE OPERATORS
1062
1063/// Return `true` if the specified `lhs` and `rhs` adaptors are equal and
1064/// `false` otherwise. Two allocator adaptor instances are equal if their
1065/// associated allocator instances are equal.
1066template <class TYPE1, class TYPE2>
1067bool operator==(const StdAllocatorAdaptor<TYPE1>& lhs,
1068 const StdAllocatorAdaptor<TYPE2>& rhs);
1069
1070/// Return `true` if the specified `lhs` and `rhs` adaptors are not equal
1071/// and `false` otherwise. Two allocator adaptor instances are not equal if
1072/// their associated allocator instances are not equal.
1073template <class TYPE1, class TYPE2>
1074bool operator!=(const StdAllocatorAdaptor<TYPE1>& lhs,
1075 const StdAllocatorAdaptor<TYPE2>& rhs);
1076
1077// ============================================================================
1078// INLINE DEFINITIONS
1079// ============================================================================
1080
1081 // -------------------------
1082 // class StdAllocatorAdaptor
1083 // -------------------------
1084
1085// PRIVATE MANIPULATORS
1086#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
1087// {{{ BEGIN GENERATED CODE
1088// Command line: sim_cpp11_features.pl bsltf_stdallocatoradaptor.h
1089#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
1090#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT 14
1091#endif
1092#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C
1093#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
1094#endif
1095#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 0
1096template <class ALLOCATOR>
1097template <class ELEMENT_TYPE>
1098inline
1099void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1100 bsl::true_type,
1101 ELEMENT_TYPE *address)
1102{
1103 AllocatorTraits::construct(
1104 *this,
1105 address,
1106 *this);
1107}
1108#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 0
1109
1110#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 1
1111template <class ALLOCATOR>
1112template <class ELEMENT_TYPE, class Args_01>
1113inline
1114void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1115 bsl::true_type,
1116 ELEMENT_TYPE *address,
1117 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
1118{
1119 AllocatorTraits::construct(
1120 *this,
1121 address,
1122 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1123 *this);
1124}
1125#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 1
1126
1127#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 2
1128template <class ALLOCATOR>
1129template <class ELEMENT_TYPE, class Args_01,
1130 class Args_02>
1131inline
1132void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1133 bsl::true_type,
1134 ELEMENT_TYPE *address,
1135 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1136 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
1137{
1138 AllocatorTraits::construct(
1139 *this,
1140 address,
1141 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1142 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1143 *this);
1144}
1145#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 2
1146
1147#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 3
1148template <class ALLOCATOR>
1149template <class ELEMENT_TYPE, class Args_01,
1150 class Args_02,
1151 class Args_03>
1152inline
1153void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1154 bsl::true_type,
1155 ELEMENT_TYPE *address,
1156 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1157 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1158 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
1159{
1160 AllocatorTraits::construct(
1161 *this,
1162 address,
1163 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1164 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1165 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1166 *this);
1167}
1168#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 3
1169
1170#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 4
1171template <class ALLOCATOR>
1172template <class ELEMENT_TYPE, class Args_01,
1173 class Args_02,
1174 class Args_03,
1175 class Args_04>
1176inline
1177void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1178 bsl::true_type,
1179 ELEMENT_TYPE *address,
1180 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1181 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1182 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1183 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
1184{
1185 AllocatorTraits::construct(
1186 *this,
1187 address,
1188 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1189 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1190 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1191 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1192 *this);
1193}
1194#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 4
1195
1196#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 5
1197template <class ALLOCATOR>
1198template <class ELEMENT_TYPE, class Args_01,
1199 class Args_02,
1200 class Args_03,
1201 class Args_04,
1202 class Args_05>
1203inline
1204void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1205 bsl::true_type,
1206 ELEMENT_TYPE *address,
1207 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1208 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1209 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1210 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1211 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
1212{
1213 AllocatorTraits::construct(
1214 *this,
1215 address,
1216 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1217 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1218 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1219 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1220 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1221 *this);
1222}
1223#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 5
1224
1225#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 6
1226template <class ALLOCATOR>
1227template <class ELEMENT_TYPE, class Args_01,
1228 class Args_02,
1229 class Args_03,
1230 class Args_04,
1231 class Args_05,
1232 class Args_06>
1233inline
1234void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1235 bsl::true_type,
1236 ELEMENT_TYPE *address,
1237 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1238 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1239 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1240 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1241 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1242 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
1243{
1244 AllocatorTraits::construct(
1245 *this,
1246 address,
1247 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1248 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1249 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1250 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1251 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1252 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1253 *this);
1254}
1255#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 6
1256
1257#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 7
1258template <class ALLOCATOR>
1259template <class ELEMENT_TYPE, class Args_01,
1260 class Args_02,
1261 class Args_03,
1262 class Args_04,
1263 class Args_05,
1264 class Args_06,
1265 class Args_07>
1266inline
1267void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1268 bsl::true_type,
1269 ELEMENT_TYPE *address,
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{
1278 AllocatorTraits::construct(
1279 *this,
1280 address,
1281 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1282 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1283 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1284 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1285 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1286 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1287 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1288 *this);
1289}
1290#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 7
1291
1292#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 8
1293template <class ALLOCATOR>
1294template <class ELEMENT_TYPE, class Args_01,
1295 class Args_02,
1296 class Args_03,
1297 class Args_04,
1298 class Args_05,
1299 class Args_06,
1300 class Args_07,
1301 class Args_08>
1302inline
1303void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1304 bsl::true_type,
1305 ELEMENT_TYPE *address,
1306 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1307 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1308 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1309 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1310 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1311 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1312 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1313 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
1314{
1315 AllocatorTraits::construct(
1316 *this,
1317 address,
1318 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1319 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1320 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1321 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1322 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1323 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1324 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1325 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1326 *this);
1327}
1328#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 8
1329
1330#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 9
1331template <class ALLOCATOR>
1332template <class ELEMENT_TYPE, class Args_01,
1333 class Args_02,
1334 class Args_03,
1335 class Args_04,
1336 class Args_05,
1337 class Args_06,
1338 class Args_07,
1339 class Args_08,
1340 class Args_09>
1341inline
1342void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1343 bsl::true_type,
1344 ELEMENT_TYPE *address,
1345 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1346 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1347 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1348 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1349 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1350 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1351 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1352 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1353 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
1354{
1355 AllocatorTraits::construct(
1356 *this,
1357 address,
1358 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1359 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1360 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1361 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1362 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1363 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1364 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1365 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1366 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1367 *this);
1368}
1369#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 9
1370
1371#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 10
1372template <class ALLOCATOR>
1373template <class ELEMENT_TYPE, class Args_01,
1374 class Args_02,
1375 class Args_03,
1376 class Args_04,
1377 class Args_05,
1378 class Args_06,
1379 class Args_07,
1380 class Args_08,
1381 class Args_09,
1382 class Args_10>
1383inline
1384void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1385 bsl::true_type,
1386 ELEMENT_TYPE *address,
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 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1392 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1393 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1394 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1395 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1396 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
1397{
1398 AllocatorTraits::construct(
1399 *this,
1400 address,
1401 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1402 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1403 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1404 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1405 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1406 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1407 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1408 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1409 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1410 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1411 *this);
1412}
1413#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 10
1414
1415#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 11
1416template <class ALLOCATOR>
1417template <class ELEMENT_TYPE, class Args_01,
1418 class Args_02,
1419 class Args_03,
1420 class Args_04,
1421 class Args_05,
1422 class Args_06,
1423 class Args_07,
1424 class Args_08,
1425 class Args_09,
1426 class Args_10,
1427 class Args_11>
1428inline
1429void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1430 bsl::true_type,
1431 ELEMENT_TYPE *address,
1432 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1433 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1434 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1435 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1436 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1437 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1438 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1439 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1440 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1441 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1442 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11)
1443{
1444 AllocatorTraits::construct(
1445 *this,
1446 address,
1447 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1448 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1449 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1450 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1451 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1452 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1453 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1454 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1455 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1456 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1457 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1458 *this);
1459}
1460#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 11
1461
1462#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 12
1463template <class ALLOCATOR>
1464template <class ELEMENT_TYPE, class Args_01,
1465 class Args_02,
1466 class Args_03,
1467 class Args_04,
1468 class Args_05,
1469 class Args_06,
1470 class Args_07,
1471 class Args_08,
1472 class Args_09,
1473 class Args_10,
1474 class Args_11,
1475 class Args_12>
1476inline
1477void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1478 bsl::true_type,
1479 ELEMENT_TYPE *address,
1480 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1481 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1482 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1483 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1484 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1485 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1486 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1487 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1488 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1489 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1490 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1491 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12)
1492{
1493 AllocatorTraits::construct(
1494 *this,
1495 address,
1496 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1497 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1498 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1499 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1500 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1501 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1502 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1503 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1504 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1505 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1506 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1507 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
1508 *this);
1509}
1510#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 12
1511
1512#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 13
1513template <class ALLOCATOR>
1514template <class ELEMENT_TYPE, class Args_01,
1515 class Args_02,
1516 class Args_03,
1517 class Args_04,
1518 class Args_05,
1519 class Args_06,
1520 class Args_07,
1521 class Args_08,
1522 class Args_09,
1523 class Args_10,
1524 class Args_11,
1525 class Args_12,
1526 class Args_13>
1527inline
1528void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1529 bsl::true_type,
1530 ELEMENT_TYPE *address,
1531 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1532 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1533 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1534 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1535 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1536 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1537 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1538 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1539 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1540 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1541 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1542 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
1543 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13)
1544{
1545 AllocatorTraits::construct(
1546 *this,
1547 address,
1548 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1549 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1550 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1551 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1552 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1553 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1554 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1555 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1556 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1557 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1558 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1559 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
1560 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13),
1561 *this);
1562}
1563#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 13
1564
1565#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 14
1566template <class ALLOCATOR>
1567template <class ELEMENT_TYPE, class Args_01,
1568 class Args_02,
1569 class Args_03,
1570 class Args_04,
1571 class Args_05,
1572 class Args_06,
1573 class Args_07,
1574 class Args_08,
1575 class Args_09,
1576 class Args_10,
1577 class Args_11,
1578 class Args_12,
1579 class Args_13,
1580 class Args_14>
1581inline
1582void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1583 bsl::true_type,
1584 ELEMENT_TYPE *address,
1585 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1586 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1587 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1588 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1589 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1590 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1591 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1592 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1593 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1594 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1595 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1596 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
1597 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
1598 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14)
1599{
1600 AllocatorTraits::construct(
1601 *this,
1602 address,
1603 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1604 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1605 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1606 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1607 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1608 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1609 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1610 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1611 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1612 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1613 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1614 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
1615 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13),
1616 BSLS_COMPILERFEATURES_FORWARD(Args_14, arguments_14),
1617 *this);
1618}
1619#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 14
1620
1621
1622#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 0
1623template <class ALLOCATOR>
1624template <class ELEMENT_TYPE>
1625inline
1626void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1627 bsl::false_type,
1628 ELEMENT_TYPE *address)
1629{
1630 AllocatorTraits::construct(
1631 *this, address);
1632}
1633#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 0
1634
1635#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 1
1636template <class ALLOCATOR>
1637template <class ELEMENT_TYPE, class Args_01>
1638inline
1639void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1640 bsl::false_type,
1641 ELEMENT_TYPE *address,
1642 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
1643{
1644 AllocatorTraits::construct(
1645 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
1646}
1647#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 1
1648
1649#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 2
1650template <class ALLOCATOR>
1651template <class ELEMENT_TYPE, class Args_01,
1652 class Args_02>
1653inline
1654void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1655 bsl::false_type,
1656 ELEMENT_TYPE *address,
1657 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1658 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
1659{
1660 AllocatorTraits::construct(
1661 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1662 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
1663}
1664#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 2
1665
1666#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 3
1667template <class ALLOCATOR>
1668template <class ELEMENT_TYPE, class Args_01,
1669 class Args_02,
1670 class Args_03>
1671inline
1672void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1673 bsl::false_type,
1674 ELEMENT_TYPE *address,
1675 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1676 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1677 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
1678{
1679 AllocatorTraits::construct(
1680 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1681 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1682 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
1683}
1684#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 3
1685
1686#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 4
1687template <class ALLOCATOR>
1688template <class ELEMENT_TYPE, class Args_01,
1689 class Args_02,
1690 class Args_03,
1691 class Args_04>
1692inline
1693void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1694 bsl::false_type,
1695 ELEMENT_TYPE *address,
1696 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1697 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1698 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1699 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
1700{
1701 AllocatorTraits::construct(
1702 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1703 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1704 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1705 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
1706}
1707#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 4
1708
1709#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 5
1710template <class ALLOCATOR>
1711template <class ELEMENT_TYPE, class Args_01,
1712 class Args_02,
1713 class Args_03,
1714 class Args_04,
1715 class Args_05>
1716inline
1717void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1718 bsl::false_type,
1719 ELEMENT_TYPE *address,
1720 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1721 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1722 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1723 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1724 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
1725{
1726 AllocatorTraits::construct(
1727 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1728 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1729 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1730 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1731 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
1732}
1733#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 5
1734
1735#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 6
1736template <class ALLOCATOR>
1737template <class ELEMENT_TYPE, class Args_01,
1738 class Args_02,
1739 class Args_03,
1740 class Args_04,
1741 class Args_05,
1742 class Args_06>
1743inline
1744void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1745 bsl::false_type,
1746 ELEMENT_TYPE *address,
1747 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1748 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1749 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1750 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1751 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1752 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
1753{
1754 AllocatorTraits::construct(
1755 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1756 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1757 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1758 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1759 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1760 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
1761}
1762#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 6
1763
1764#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 7
1765template <class ALLOCATOR>
1766template <class ELEMENT_TYPE, class Args_01,
1767 class Args_02,
1768 class Args_03,
1769 class Args_04,
1770 class Args_05,
1771 class Args_06,
1772 class Args_07>
1773inline
1774void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1775 bsl::false_type,
1776 ELEMENT_TYPE *address,
1777 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1778 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1779 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1780 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1781 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1782 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1783 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
1784{
1785 AllocatorTraits::construct(
1786 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1787 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1788 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1789 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1790 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1791 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1792 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
1793}
1794#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 7
1795
1796#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 8
1797template <class ALLOCATOR>
1798template <class ELEMENT_TYPE, class Args_01,
1799 class Args_02,
1800 class Args_03,
1801 class Args_04,
1802 class Args_05,
1803 class Args_06,
1804 class Args_07,
1805 class Args_08>
1806inline
1807void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1808 bsl::false_type,
1809 ELEMENT_TYPE *address,
1810 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1811 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1812 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1813 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1814 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1815 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1816 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1817 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
1818{
1819 AllocatorTraits::construct(
1820 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1821 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1822 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1823 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1824 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1825 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1826 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1827 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
1828}
1829#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 8
1830
1831#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 9
1832template <class ALLOCATOR>
1833template <class ELEMENT_TYPE, class Args_01,
1834 class Args_02,
1835 class Args_03,
1836 class Args_04,
1837 class Args_05,
1838 class Args_06,
1839 class Args_07,
1840 class Args_08,
1841 class Args_09>
1842inline
1843void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1844 bsl::false_type,
1845 ELEMENT_TYPE *address,
1846 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1847 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1848 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1849 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1850 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1851 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1852 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1853 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1854 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
1855{
1856 AllocatorTraits::construct(
1857 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1858 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1859 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1860 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1861 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1862 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1863 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1864 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1865 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
1866}
1867#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 9
1868
1869#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 10
1870template <class ALLOCATOR>
1871template <class ELEMENT_TYPE, class Args_01,
1872 class Args_02,
1873 class Args_03,
1874 class Args_04,
1875 class Args_05,
1876 class Args_06,
1877 class Args_07,
1878 class Args_08,
1879 class Args_09,
1880 class Args_10>
1881inline
1882void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1883 bsl::false_type,
1884 ELEMENT_TYPE *address,
1885 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1886 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1887 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1888 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1889 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1890 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1891 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1892 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1893 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1894 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
1895{
1896 AllocatorTraits::construct(
1897 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1898 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1899 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1900 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1901 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1902 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1903 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1904 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1905 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1906 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
1907}
1908#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 10
1909
1910#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 11
1911template <class ALLOCATOR>
1912template <class ELEMENT_TYPE, class Args_01,
1913 class Args_02,
1914 class Args_03,
1915 class Args_04,
1916 class Args_05,
1917 class Args_06,
1918 class Args_07,
1919 class Args_08,
1920 class Args_09,
1921 class Args_10,
1922 class Args_11>
1923inline
1924void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1925 bsl::false_type,
1926 ELEMENT_TYPE *address,
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 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1937 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11)
1938{
1939 AllocatorTraits::construct(
1940 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1941 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1942 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1943 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1944 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1945 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1946 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1947 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1948 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1949 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1950 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11));
1951}
1952#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 11
1953
1954#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 12
1955template <class ALLOCATOR>
1956template <class ELEMENT_TYPE, class Args_01,
1957 class Args_02,
1958 class Args_03,
1959 class Args_04,
1960 class Args_05,
1961 class Args_06,
1962 class Args_07,
1963 class Args_08,
1964 class Args_09,
1965 class Args_10,
1966 class Args_11,
1967 class Args_12>
1968inline
1969void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1970 bsl::false_type,
1971 ELEMENT_TYPE *address,
1972 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1973 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1974 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1975 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1976 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1977 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1978 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1979 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1980 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1981 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1982 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1983 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12)
1984{
1985 AllocatorTraits::construct(
1986 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1987 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1988 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1989 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1990 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1991 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1992 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1993 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1994 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1995 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1996 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1997 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12));
1998}
1999#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 12
2000
2001#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 13
2002template <class ALLOCATOR>
2003template <class ELEMENT_TYPE, class Args_01,
2004 class Args_02,
2005 class Args_03,
2006 class Args_04,
2007 class Args_05,
2008 class Args_06,
2009 class Args_07,
2010 class Args_08,
2011 class Args_09,
2012 class Args_10,
2013 class Args_11,
2014 class Args_12,
2015 class Args_13>
2016inline
2017void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
2018 bsl::false_type,
2019 ELEMENT_TYPE *address,
2020 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2021 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2022 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2023 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2024 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2025 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2026 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2027 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2028 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2029 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2030 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2031 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
2032 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13)
2033{
2034 AllocatorTraits::construct(
2035 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2036 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2037 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2038 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2039 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2040 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2041 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2042 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2043 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2044 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2045 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2046 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
2047 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13));
2048}
2049#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 13
2050
2051#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 14
2052template <class ALLOCATOR>
2053template <class ELEMENT_TYPE, class Args_01,
2054 class Args_02,
2055 class Args_03,
2056 class Args_04,
2057 class Args_05,
2058 class Args_06,
2059 class Args_07,
2060 class Args_08,
2061 class Args_09,
2062 class Args_10,
2063 class Args_11,
2064 class Args_12,
2065 class Args_13,
2066 class Args_14>
2067inline
2068void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
2069 bsl::false_type,
2070 ELEMENT_TYPE *address,
2071 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2072 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2073 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2074 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2075 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2076 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2077 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2078 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2079 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2080 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2081 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2082 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
2083 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
2084 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14)
2085{
2086 AllocatorTraits::construct(
2087 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2088 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2089 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2090 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2091 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2092 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2093 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2094 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2095 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2096 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2097 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2098 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
2099 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13),
2100 BSLS_COMPILERFEATURES_FORWARD(Args_14, arguments_14));
2101}
2102#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 14
2103
2104#else
2105// The generated code below is a workaround for the absence of perfect
2106// forwarding in some compilers.
2107template <class ALLOCATOR>
2108template <class ELEMENT_TYPE, class... Args>
2109inline
2110void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
2111 bsl::true_type,
2112 ELEMENT_TYPE *address,
2113 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
2114{
2115 AllocatorTraits::construct(
2116 *this,
2117 address,
2118 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...,
2119 *this);
2120}
2121
2122template <class ALLOCATOR>
2123template <class ELEMENT_TYPE, class... Args>
2124inline
2125void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
2126 bsl::false_type,
2127 ELEMENT_TYPE *address,
2128 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
2129{
2130 AllocatorTraits::construct(
2131 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
2132}
2133
2134// }}} END GENERATED CODE
2135#endif
2136
2137// CREATORS
2138template <class ALLOCATOR>
2139inline
2140StdAllocatorAdaptor<ALLOCATOR>::StdAllocatorAdaptor()
2141: ALLOCATOR()
2142{
2143}
2144
2145template <class ALLOCATOR>
2146inline
2147StdAllocatorAdaptor<ALLOCATOR>::StdAllocatorAdaptor(const ALLOCATOR& allocator)
2148: ALLOCATOR(allocator)
2149{
2150}
2151
2152template <class ALLOCATOR>
2153inline
2154StdAllocatorAdaptor<ALLOCATOR>::StdAllocatorAdaptor(bsl::nullptr_t)
2155: ALLOCATOR(0)
2156{
2157}
2158
2159template <class ALLOCATOR>
2160template <class ANY_TYPE>
2161inline
2162StdAllocatorAdaptor<ALLOCATOR>::StdAllocatorAdaptor(
2163 const StdAllocatorAdaptor<ANY_TYPE>& other)
2164: ALLOCATOR(other)
2165{
2166}
2167
2168// MANIPULATORS
2169#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
2170// {{{ BEGIN GENERATED CODE
2171// Command line: sim_cpp11_features.pl bsltf_stdallocatoradaptor.h
2172#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
2173#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT 14
2174#endif
2175#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D
2176#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
2177#endif
2178#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 0
2179template <class ALLOCATOR>
2180template <class ELEMENT_TYPE>
2181inline void
2182StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address)
2183{
2184 enum { k_PassSelfAtEnd =
2185 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2186 ! bsl::is_convertible<StdAllocatorAdaptor *,
2187 bsl::allocator<value_type> *>::value
2188 };
2189
2190 privateConstruct(
2191 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2192 address);
2193}
2194#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 0
2195
2196#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 1
2197template <class ALLOCATOR>
2198template <class ELEMENT_TYPE, class Args_01>
2199inline void
2200StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2201 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
2202{
2203 enum { k_PassSelfAtEnd =
2204 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2205 ! bsl::is_convertible<StdAllocatorAdaptor *,
2206 bsl::allocator<value_type> *>::value
2207 };
2208
2209 privateConstruct(
2210 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2211 address,
2212 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
2213}
2214#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 1
2215
2216#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 2
2217template <class ALLOCATOR>
2218template <class ELEMENT_TYPE, class Args_01,
2219 class Args_02>
2220inline void
2221StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2222 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2223 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
2224{
2225 enum { k_PassSelfAtEnd =
2226 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2227 ! bsl::is_convertible<StdAllocatorAdaptor *,
2228 bsl::allocator<value_type> *>::value
2229 };
2230
2231 privateConstruct(
2232 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2233 address,
2234 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2235 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
2236}
2237#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 2
2238
2239#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 3
2240template <class ALLOCATOR>
2241template <class ELEMENT_TYPE, class Args_01,
2242 class Args_02,
2243 class Args_03>
2244inline void
2245StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2246 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2247 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2248 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
2249{
2250 enum { k_PassSelfAtEnd =
2251 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2252 ! bsl::is_convertible<StdAllocatorAdaptor *,
2253 bsl::allocator<value_type> *>::value
2254 };
2255
2256 privateConstruct(
2257 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2258 address,
2259 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2260 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2261 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
2262}
2263#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 3
2264
2265#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 4
2266template <class ALLOCATOR>
2267template <class ELEMENT_TYPE, class Args_01,
2268 class Args_02,
2269 class Args_03,
2270 class Args_04>
2271inline void
2272StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2273 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2274 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2275 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2276 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
2277{
2278 enum { k_PassSelfAtEnd =
2279 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2280 ! bsl::is_convertible<StdAllocatorAdaptor *,
2281 bsl::allocator<value_type> *>::value
2282 };
2283
2284 privateConstruct(
2285 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2286 address,
2287 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2288 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2289 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2290 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
2291}
2292#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 4
2293
2294#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 5
2295template <class ALLOCATOR>
2296template <class ELEMENT_TYPE, class Args_01,
2297 class Args_02,
2298 class Args_03,
2299 class Args_04,
2300 class Args_05>
2301inline void
2302StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2303 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2304 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2305 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2306 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2307 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
2308{
2309 enum { k_PassSelfAtEnd =
2310 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2311 ! bsl::is_convertible<StdAllocatorAdaptor *,
2312 bsl::allocator<value_type> *>::value
2313 };
2314
2315 privateConstruct(
2316 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2317 address,
2318 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2319 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2320 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2321 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2322 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
2323}
2324#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 5
2325
2326#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 6
2327template <class ALLOCATOR>
2328template <class ELEMENT_TYPE, class Args_01,
2329 class Args_02,
2330 class Args_03,
2331 class Args_04,
2332 class Args_05,
2333 class Args_06>
2334inline void
2335StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2336 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2337 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2338 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2339 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2340 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2341 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
2342{
2343 enum { k_PassSelfAtEnd =
2344 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2345 ! bsl::is_convertible<StdAllocatorAdaptor *,
2346 bsl::allocator<value_type> *>::value
2347 };
2348
2349 privateConstruct(
2350 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2351 address,
2352 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2353 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2354 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2355 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2356 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2357 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
2358}
2359#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 6
2360
2361#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 7
2362template <class ALLOCATOR>
2363template <class ELEMENT_TYPE, class Args_01,
2364 class Args_02,
2365 class Args_03,
2366 class Args_04,
2367 class Args_05,
2368 class Args_06,
2369 class Args_07>
2370inline void
2371StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2372 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2373 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2374 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2375 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2376 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2377 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2378 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
2379{
2380 enum { k_PassSelfAtEnd =
2381 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2382 ! bsl::is_convertible<StdAllocatorAdaptor *,
2383 bsl::allocator<value_type> *>::value
2384 };
2385
2386 privateConstruct(
2387 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2388 address,
2389 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2390 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2391 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2392 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2393 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2394 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2395 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
2396}
2397#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 7
2398
2399#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 8
2400template <class ALLOCATOR>
2401template <class ELEMENT_TYPE, class Args_01,
2402 class Args_02,
2403 class Args_03,
2404 class Args_04,
2405 class Args_05,
2406 class Args_06,
2407 class Args_07,
2408 class Args_08>
2409inline void
2410StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2411 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2412 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2413 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2414 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2415 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2416 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2417 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2418 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
2419{
2420 enum { k_PassSelfAtEnd =
2421 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2422 ! bsl::is_convertible<StdAllocatorAdaptor *,
2423 bsl::allocator<value_type> *>::value
2424 };
2425
2426 privateConstruct(
2427 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2428 address,
2429 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2430 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2431 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2432 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2433 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2434 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2435 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2436 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
2437}
2438#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 8
2439
2440#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 9
2441template <class ALLOCATOR>
2442template <class ELEMENT_TYPE, class Args_01,
2443 class Args_02,
2444 class Args_03,
2445 class Args_04,
2446 class Args_05,
2447 class Args_06,
2448 class Args_07,
2449 class Args_08,
2450 class Args_09>
2451inline void
2452StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2453 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2454 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2455 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2456 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2457 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2458 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2459 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2460 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2461 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
2462{
2463 enum { k_PassSelfAtEnd =
2464 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2465 ! bsl::is_convertible<StdAllocatorAdaptor *,
2466 bsl::allocator<value_type> *>::value
2467 };
2468
2469 privateConstruct(
2470 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2471 address,
2472 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2473 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2474 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2475 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2476 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2477 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2478 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2479 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2480 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
2481}
2482#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 9
2483
2484#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 10
2485template <class ALLOCATOR>
2486template <class ELEMENT_TYPE, class Args_01,
2487 class Args_02,
2488 class Args_03,
2489 class Args_04,
2490 class Args_05,
2491 class Args_06,
2492 class Args_07,
2493 class Args_08,
2494 class Args_09,
2495 class Args_10>
2496inline void
2497StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2498 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2499 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2500 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2501 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2502 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2503 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2504 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2505 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2506 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2507 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
2508{
2509 enum { k_PassSelfAtEnd =
2510 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2511 ! bsl::is_convertible<StdAllocatorAdaptor *,
2512 bsl::allocator<value_type> *>::value
2513 };
2514
2515 privateConstruct(
2516 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2517 address,
2518 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2519 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2520 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2521 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2522 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2523 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2524 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2525 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2526 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2527 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
2528}
2529#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 10
2530
2531#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 11
2532template <class ALLOCATOR>
2533template <class ELEMENT_TYPE, class Args_01,
2534 class Args_02,
2535 class Args_03,
2536 class Args_04,
2537 class Args_05,
2538 class Args_06,
2539 class Args_07,
2540 class Args_08,
2541 class Args_09,
2542 class Args_10,
2543 class Args_11>
2544inline void
2545StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2546 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2547 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2548 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2549 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2550 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2551 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2552 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2553 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2554 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2555 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2556 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11)
2557{
2558 enum { k_PassSelfAtEnd =
2559 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2560 ! bsl::is_convertible<StdAllocatorAdaptor *,
2561 bsl::allocator<value_type> *>::value
2562 };
2563
2564 privateConstruct(
2565 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2566 address,
2567 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2568 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2569 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2570 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2571 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2572 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2573 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2574 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2575 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2576 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2577 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11));
2578}
2579#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 11
2580
2581#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 12
2582template <class ALLOCATOR>
2583template <class ELEMENT_TYPE, class Args_01,
2584 class Args_02,
2585 class Args_03,
2586 class Args_04,
2587 class Args_05,
2588 class Args_06,
2589 class Args_07,
2590 class Args_08,
2591 class Args_09,
2592 class Args_10,
2593 class Args_11,
2594 class Args_12>
2595inline void
2596StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2597 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2598 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2599 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2600 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2601 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2602 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2603 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2604 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2605 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2606 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2607 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2608 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12)
2609{
2610 enum { k_PassSelfAtEnd =
2611 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2612 ! bsl::is_convertible<StdAllocatorAdaptor *,
2613 bsl::allocator<value_type> *>::value
2614 };
2615
2616 privateConstruct(
2617 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2618 address,
2619 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2620 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2621 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2622 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2623 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2624 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2625 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2626 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2627 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2628 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2629 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2630 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12));
2631}
2632#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 12
2633
2634#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 13
2635template <class ALLOCATOR>
2636template <class ELEMENT_TYPE, class Args_01,
2637 class Args_02,
2638 class Args_03,
2639 class Args_04,
2640 class Args_05,
2641 class Args_06,
2642 class Args_07,
2643 class Args_08,
2644 class Args_09,
2645 class Args_10,
2646 class Args_11,
2647 class Args_12,
2648 class Args_13>
2649inline void
2650StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2651 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2652 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2653 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2654 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2655 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2656 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2657 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2658 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2659 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2660 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2661 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2662 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
2663 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13)
2664{
2665 enum { k_PassSelfAtEnd =
2666 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2667 ! bsl::is_convertible<StdAllocatorAdaptor *,
2668 bsl::allocator<value_type> *>::value
2669 };
2670
2671 privateConstruct(
2672 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2673 address,
2674 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2675 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2676 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2677 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2678 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2679 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2680 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2681 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2682 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2683 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2684 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2685 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
2686 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13));
2687}
2688#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 13
2689
2690#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 14
2691template <class ALLOCATOR>
2692template <class ELEMENT_TYPE, class Args_01,
2693 class Args_02,
2694 class Args_03,
2695 class Args_04,
2696 class Args_05,
2697 class Args_06,
2698 class Args_07,
2699 class Args_08,
2700 class Args_09,
2701 class Args_10,
2702 class Args_11,
2703 class Args_12,
2704 class Args_13,
2705 class Args_14>
2706inline void
2707StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2708 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2709 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2710 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2711 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2712 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2713 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2714 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2715 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2716 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2717 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2718 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2719 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
2720 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
2721 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14)
2722{
2723 enum { k_PassSelfAtEnd =
2724 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2725 ! bsl::is_convertible<StdAllocatorAdaptor *,
2726 bsl::allocator<value_type> *>::value
2727 };
2728
2729 privateConstruct(
2730 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2731 address,
2732 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2733 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2734 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2735 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2736 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2737 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2738 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2739 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2740 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2741 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2742 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2743 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
2744 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13),
2745 BSLS_COMPILERFEATURES_FORWARD(Args_14, arguments_14));
2746}
2747#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 14
2748
2749#else
2750// The generated code below is a workaround for the absence of perfect
2751// forwarding in some compilers.
2752template <class ALLOCATOR>
2753template <class ELEMENT_TYPE, class... Args>
2754inline void
2755StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2756 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
2757{
2758 enum { k_PassSelfAtEnd =
2759 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2760 ! bsl::is_convertible<StdAllocatorAdaptor *,
2761 bsl::allocator<value_type> *>::value
2762 };
2763
2764 privateConstruct(
2765 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2766 address,
2767 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
2768}
2769// }}} END GENERATED CODE
2770#endif
2771
2772// ACCESSORS
2773template <class ALLOCATOR>
2774inline
2775const ALLOCATOR& StdAllocatorAdaptor<ALLOCATOR>::allocator() const
2776{
2777 return *this;
2778}
2779
2780template <class ALLOCATOR>
2781inline
2782StdAllocatorAdaptor<ALLOCATOR>
2783StdAllocatorAdaptor<ALLOCATOR>::select_on_container_copy_construction() const
2784{
2785 return StdAllocatorAdaptor<ALLOCATOR>(
2786 AllocatorTraits::select_on_container_copy_construction(
2787 *reinterpret_cast<const ALLOCATOR *>(this)));
2788}
2789
2790// FREE OPERATORS
2791template <class TYPE1, class TYPE2>
2792inline
2793bool operator==(const bsltf::StdAllocatorAdaptor<TYPE1>& lhs,
2794 const bsltf::StdAllocatorAdaptor<TYPE2>& rhs)
2795{
2796 return lhs.allocator() == rhs.allocator();
2797}
2798
2799template <class TYPE1, class TYPE2>
2800inline
2801bool operator!=(const bsltf::StdAllocatorAdaptor<TYPE1>& lhs,
2802 const bsltf::StdAllocatorAdaptor<TYPE2>& rhs)
2803{
2804 return lhs.allocator() != rhs.allocator();
2805}
2806
2807} // close package namespace
2808
2809
2810#else // if ! defined(DEFINED_BSLTF_STDALLOCATORADAPTOR_H)
2811# error Not valid except when included from bsltf_stdallocatoradaptor.h
2812#endif // ! defined(COMPILING_BSLTF_STDALLOCATORADAPTOR_H)
2813
2814#endif // ! defined(INCLUDED_BSLTF_STDALLOCATORADAPTOR_CPP03)
2815
2816// ----------------------------------------------------------------------------
2817// Copyright 2016 Bloomberg Finance L.P.
2818//
2819// Licensed under the Apache License, Version 2.0 (the "License");
2820// you may not use this file except in compliance with the License.
2821// You may obtain a copy of the License at
2822//
2823// http://www.apache.org/licenses/LICENSE-2.0
2824//
2825// Unless required by applicable law or agreed to in writing, software
2826// distributed under the License is distributed on an "AS IS" BASIS,
2827// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2828// See the License for the specific language governing permissions and
2829// limitations under the License.
2830// ----------------------------- END-OF-FILE ----------------------------------
2831
2832/** @} */
2833/** @} */
2834/** @} */
BSLMF_NESTED_TRAIT_DECLARATION
#define BSLMF_NESTED_TRAIT_DECLARATION(t_TYPE, t_TRAIT)
Definition bslmf_nestedtraitdeclaration.h:231
bsl::allocator
Definition bslma_bslallocator.h:588
bsltf::StdAllocatorAdaptor
Definition bsltf_stdallocatoradaptor.h:172
bsltf::StdAllocatorAdaptor::size_type
ALLOCATOR::size_type size_type
Definition bsltf_stdallocatoradaptor.h:204
bsltf::StdAllocatorAdaptor::allocator
const ALLOCATOR & allocator() const
Definition bsltf_stdallocatoradaptor.h:415
bsltf::StdAllocatorAdaptor::select_on_container_copy_construction
StdAllocatorAdaptor< ALLOCATOR > select_on_container_copy_construction() const
Definition bsltf_stdallocatoradaptor.h:423
bsltf::StdAllocatorAdaptor::construct
void construct(ELEMENT_TYPE *address, Args &&... arguments)
Definition bsltf_stdallocatoradaptor.h:389
bsltf::StdAllocatorAdaptor::difference_type
ALLOCATOR::difference_type difference_type
Definition bsltf_stdallocatoradaptor.h:205
bsltf::StdAllocatorAdaptor::reference
ALLOCATOR::reference reference
Definition bsltf_stdallocatoradaptor.h:208
bsltf::StdAllocatorAdaptor::operator=
StdAllocatorAdaptor & operator=(const StdAllocatorAdaptor &rhs)=default
bsltf::StdAllocatorAdaptor::pointer
ALLOCATOR::pointer pointer
Definition bsltf_stdallocatoradaptor.h:206
bsltf::StdAllocatorAdaptor::const_reference
ALLOCATOR::const_reference const_reference
Definition bsltf_stdallocatoradaptor.h:209
bsltf::StdAllocatorAdaptor::StdAllocatorAdaptor
StdAllocatorAdaptor()
Definition bsltf_stdallocatoradaptor.h:356
bsltf::StdAllocatorAdaptor::value_type
ALLOCATOR::value_type value_type
Definition bsltf_stdallocatoradaptor.h:210
bsltf::StdAllocatorAdaptor::const_pointer
ALLOCATOR::const_pointer const_pointer
Definition bsltf_stdallocatoradaptor.h:207
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
balb::operator!=
bool operator!=(const FileCleanerConfiguration &lhs, const FileCleanerConfiguration &rhs)
balb::operator==
bool operator==(const FileCleanerConfiguration &lhs, const FileCleanerConfiguration &rhs)
bsl::nullptr_t
BloombergLP::bsls::Nullptr_Impl::Type nullptr_t
Definition bsls_nullptr.h:283
bsl::rhs
ALLOCATOR const STRING_VIEW_LIKE_TYPE & rhs
Definition bslstl_string.h:3918
bsl::lhs
ALLOCATOR & lhs
Definition bslstl_string.h:3917
bsltf
Definition bsltf_allocargumenttype.h:92
bsl::allocator_traits
Definition bslma_allocatortraits.h:1089
bsl::integral_constant< bool, true >
bsl::is_convertible
Definition bslmf_isconvertible.h:875
bsl::uses_allocator
Definition bslmf_usesallocator.h:165
bslma::IsStdAllocator
Definition bslma_isstdallocator.h:202
bsltf::StdAllocatorAdaptor::rebind::other
StdAllocatorAdaptor< typename ALLOCATOR::template rebind< BDE_OTHER_TYPE >::other > other
Definition bsltf_stdallocatoradaptor.h:224