BDE 4.14.0 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
701 /// but that allocates elements of `BDE_OTHER_TYPE`. Note that this
702 /// allocator type is convertible to and from `other` for any
703 /// `BDE_OTHER_TYPE` including `void`.
704 template <class BDE_OTHER_TYPE>
705 struct rebind
706 {
707
708 typedef StdAllocatorAdaptor<
709 typename ALLOCATOR::template rebind<BDE_OTHER_TYPE>::other> other;
710 };
711
712 // CREATORS
713
714 /// Create a standard allocator adaptor object for a default-constructed
715 /// allocator object of the (template parameter) type `ALLOCATOR`.
716 StdAllocatorAdaptor();
717
718 /// Create a standard allocator adaptor object for the specified
719 /// `allocator` of the (template parameter) type `ALLOCATOR`.
720 explicit StdAllocatorAdaptor(const ALLOCATOR& allocator);
721
722 /// Create a standard allocator adaptor object from the null pointer
723 /// constant.
724 explicit StdAllocatorAdaptor(bsl::nullptr_t);
725
726 /// Create a copy of the specified `other` allocator adaptor.
727 template <class ANY_TYPE>
728 StdAllocatorAdaptor(const StdAllocatorAdaptor<ANY_TYPE>& other);
729
730#ifdef BSLS_COMPILERFEATURES_SUPPORT_DEFAULTED_FUNCTIONS
731 /// Create a copy of the specified `original` allocator adaptor.
732 StdAllocatorAdaptor(const StdAllocatorAdaptor& original) = default;
733#else
734 StdAllocatorAdaptor(const StdAllocatorAdaptor& original) = default;
735#endif
736
737 ~StdAllocatorAdaptor() = default;
738 // Destroy this object.
739
740 // MANIPULATORS
741#ifdef BSLS_COMPILERFEATURES_SUPPORT_DEFAULTED_FUNCTIONS
742 /// Assign to this object the value of the specified `rhs` object, and
743 /// return a reference providing modifiable access to this object.
744 StdAllocatorAdaptor& operator=(const StdAllocatorAdaptor& original) =
745 default;
746#else
747 StdAllocatorAdaptor& operator=(const StdAllocatorAdaptor& rhs) =
748 default;
749#endif
750
751#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
752// {{{ BEGIN GENERATED CODE
753// Command line: sim_cpp11_features.pl bsltf_stdallocatoradaptor.h
754#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
755#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT 14
756#endif
757#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B
758#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
759#endif
760
761#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 0
762 template <class ELEMENT_TYPE>
763 void construct(ELEMENT_TYPE *address);
764#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 0
765
766#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 1
767 template <class ELEMENT_TYPE, class Args_01>
768 void construct(ELEMENT_TYPE *address,
769 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01);
770#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 1
771
772#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 2
773 template <class ELEMENT_TYPE, class Args_01,
774 class Args_02>
775 void construct(ELEMENT_TYPE *address,
776 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
777 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02);
778#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 2
779
780#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 3
781 template <class ELEMENT_TYPE, class Args_01,
782 class Args_02,
783 class Args_03>
784 void construct(ELEMENT_TYPE *address,
785 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
786 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
787 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03);
788#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 3
789
790#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 4
791 template <class ELEMENT_TYPE, class Args_01,
792 class Args_02,
793 class Args_03,
794 class Args_04>
795 void construct(ELEMENT_TYPE *address,
796 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
797 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
798 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
799 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04);
800#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 4
801
802#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 5
803 template <class ELEMENT_TYPE, class Args_01,
804 class Args_02,
805 class Args_03,
806 class Args_04,
807 class Args_05>
808 void construct(ELEMENT_TYPE *address,
809 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
810 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
811 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
812 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
813 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05);
814#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 5
815
816#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 6
817 template <class ELEMENT_TYPE, class Args_01,
818 class Args_02,
819 class Args_03,
820 class Args_04,
821 class Args_05,
822 class Args_06>
823 void construct(ELEMENT_TYPE *address,
824 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
825 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
826 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
827 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
828 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
829 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06);
830#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 6
831
832#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 7
833 template <class ELEMENT_TYPE, class Args_01,
834 class Args_02,
835 class Args_03,
836 class Args_04,
837 class Args_05,
838 class Args_06,
839 class Args_07>
840 void construct(ELEMENT_TYPE *address,
841 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
842 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
843 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
844 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
845 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
846 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
847 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07);
848#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 7
849
850#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 8
851 template <class ELEMENT_TYPE, class Args_01,
852 class Args_02,
853 class Args_03,
854 class Args_04,
855 class Args_05,
856 class Args_06,
857 class Args_07,
858 class Args_08>
859 void construct(ELEMENT_TYPE *address,
860 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
861 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
862 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
863 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
864 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
865 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
866 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
867 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08);
868#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 8
869
870#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 9
871 template <class ELEMENT_TYPE, class Args_01,
872 class Args_02,
873 class Args_03,
874 class Args_04,
875 class Args_05,
876 class Args_06,
877 class Args_07,
878 class Args_08,
879 class Args_09>
880 void construct(ELEMENT_TYPE *address,
881 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
882 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
883 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
884 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
885 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
886 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
887 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
888 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
889 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09);
890#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 9
891
892#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 10
893 template <class ELEMENT_TYPE, class Args_01,
894 class Args_02,
895 class Args_03,
896 class Args_04,
897 class Args_05,
898 class Args_06,
899 class Args_07,
900 class Args_08,
901 class Args_09,
902 class Args_10>
903 void construct(ELEMENT_TYPE *address,
904 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
905 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
906 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
907 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
908 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
909 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
910 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
911 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
912 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
913 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10);
914#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 10
915
916#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 11
917 template <class ELEMENT_TYPE, class Args_01,
918 class Args_02,
919 class Args_03,
920 class Args_04,
921 class Args_05,
922 class Args_06,
923 class Args_07,
924 class Args_08,
925 class Args_09,
926 class Args_10,
927 class Args_11>
928 void construct(ELEMENT_TYPE *address,
929 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
930 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
931 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
932 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
933 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
934 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
935 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
936 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
937 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
938 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
939 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11);
940#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 11
941
942#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 12
943 template <class ELEMENT_TYPE, class Args_01,
944 class Args_02,
945 class Args_03,
946 class Args_04,
947 class Args_05,
948 class Args_06,
949 class Args_07,
950 class Args_08,
951 class Args_09,
952 class Args_10,
953 class Args_11,
954 class Args_12>
955 void construct(ELEMENT_TYPE *address,
956 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
957 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
958 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
959 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
960 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
961 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
962 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
963 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
964 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
965 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
966 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
967 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12);
968#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 12
969
970#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 13
971 template <class ELEMENT_TYPE, class Args_01,
972 class Args_02,
973 class Args_03,
974 class Args_04,
975 class Args_05,
976 class Args_06,
977 class Args_07,
978 class Args_08,
979 class Args_09,
980 class Args_10,
981 class Args_11,
982 class Args_12,
983 class Args_13>
984 void construct(ELEMENT_TYPE *address,
985 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
986 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
987 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
988 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
989 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
990 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
991 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
992 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
993 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
994 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
995 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
996 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
997 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13);
998#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 13
999
1000#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 14
1001 template <class ELEMENT_TYPE, class Args_01,
1002 class Args_02,
1003 class Args_03,
1004 class Args_04,
1005 class Args_05,
1006 class Args_06,
1007 class Args_07,
1008 class Args_08,
1009 class Args_09,
1010 class Args_10,
1011 class Args_11,
1012 class Args_12,
1013 class Args_13,
1014 class Args_14>
1015 void construct(ELEMENT_TYPE *address,
1016 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1017 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1018 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1019 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1020 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1021 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1022 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1023 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1024 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1025 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1026 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1027 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
1028 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
1029 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14);
1030#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_B >= 14
1031
1032#else
1033// The generated code below is a workaround for the absence of perfect
1034// forwarding in some compilers.
1035
1036 template <class ELEMENT_TYPE, class... Args>
1037 void construct(ELEMENT_TYPE *address,
1038 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments);
1039// }}} END GENERATED CODE
1040#endif
1041
1042 // ACCESSORS
1043
1044 /// Return a reference to the non-modifiable allocator instance
1045 /// associated with this standard allocator adaptor.
1046 const ALLOCATOR& allocator() const;
1047
1048 /// Return an allocator adaptor for the allocator object returned by the
1049 /// `select_on_container_copy_construction` class method in the
1050 /// `allocator_traits` class template for the allocator object, of the
1051 /// (template parameter) type `ALLOCATOR`, associated with this adaptor.
1052 /// The `allocator_traits` class template presumably delegates this call
1053 /// to the allocator object if such an operation is supported by the
1054 /// `ALLOCATOR` type, or provides a suitable default behavior if such an
1055 /// operation is not supported.
1056 StdAllocatorAdaptor<ALLOCATOR>
1057 select_on_container_copy_construction() const;
1058};
1059
1060// FREE OPERATORS
1061
1062/// Return `true` if the specified `lhs` and `rhs` adaptors are equal and
1063/// `false` otherwise. Two allocator adaptor instances are equal if their
1064/// associated allocator instances are equal.
1065template <class TYPE1, class TYPE2>
1066bool operator==(const StdAllocatorAdaptor<TYPE1>& lhs,
1067 const StdAllocatorAdaptor<TYPE2>& rhs);
1068
1069/// Return `true` if the specified `lhs` and `rhs` adaptors are not equal
1070/// and `false` otherwise. Two allocator adaptor instances are not equal if
1071/// their associated allocator instances are not equal.
1072template <class TYPE1, class TYPE2>
1073bool operator!=(const StdAllocatorAdaptor<TYPE1>& lhs,
1074 const StdAllocatorAdaptor<TYPE2>& rhs);
1075
1076// ============================================================================
1077// INLINE DEFINITIONS
1078// ============================================================================
1079
1080 // -------------------------
1081 // class StdAllocatorAdaptor
1082 // -------------------------
1083
1084// PRIVATE MANIPULATORS
1085#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
1086// {{{ BEGIN GENERATED CODE
1087// Command line: sim_cpp11_features.pl bsltf_stdallocatoradaptor.h
1088#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
1089#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT 14
1090#endif
1091#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C
1092#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
1093#endif
1094#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 0
1095template <class ALLOCATOR>
1096template <class ELEMENT_TYPE>
1097inline
1098void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1099 bsl::true_type,
1100 ELEMENT_TYPE *address)
1101{
1102 AllocatorTraits::construct(
1103 *this,
1104 address,
1105 *this);
1106}
1107#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 0
1108
1109#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 1
1110template <class ALLOCATOR>
1111template <class ELEMENT_TYPE, class Args_01>
1112inline
1113void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1114 bsl::true_type,
1115 ELEMENT_TYPE *address,
1116 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
1117{
1118 AllocatorTraits::construct(
1119 *this,
1120 address,
1121 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1122 *this);
1123}
1124#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 1
1125
1126#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 2
1127template <class ALLOCATOR>
1128template <class ELEMENT_TYPE, class Args_01,
1129 class Args_02>
1130inline
1131void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1132 bsl::true_type,
1133 ELEMENT_TYPE *address,
1134 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1135 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
1136{
1137 AllocatorTraits::construct(
1138 *this,
1139 address,
1140 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1141 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1142 *this);
1143}
1144#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 2
1145
1146#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 3
1147template <class ALLOCATOR>
1148template <class ELEMENT_TYPE, class Args_01,
1149 class Args_02,
1150 class Args_03>
1151inline
1152void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1153 bsl::true_type,
1154 ELEMENT_TYPE *address,
1155 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1156 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1157 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
1158{
1159 AllocatorTraits::construct(
1160 *this,
1161 address,
1162 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1163 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1164 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1165 *this);
1166}
1167#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 3
1168
1169#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 4
1170template <class ALLOCATOR>
1171template <class ELEMENT_TYPE, class Args_01,
1172 class Args_02,
1173 class Args_03,
1174 class Args_04>
1175inline
1176void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1177 bsl::true_type,
1178 ELEMENT_TYPE *address,
1179 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1180 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1181 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1182 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
1183{
1184 AllocatorTraits::construct(
1185 *this,
1186 address,
1187 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1188 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1189 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1190 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1191 *this);
1192}
1193#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 4
1194
1195#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 5
1196template <class ALLOCATOR>
1197template <class ELEMENT_TYPE, class Args_01,
1198 class Args_02,
1199 class Args_03,
1200 class Args_04,
1201 class Args_05>
1202inline
1203void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1204 bsl::true_type,
1205 ELEMENT_TYPE *address,
1206 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1207 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1208 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1209 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1210 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
1211{
1212 AllocatorTraits::construct(
1213 *this,
1214 address,
1215 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1216 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1217 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1218 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1219 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1220 *this);
1221}
1222#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 5
1223
1224#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 6
1225template <class ALLOCATOR>
1226template <class ELEMENT_TYPE, class Args_01,
1227 class Args_02,
1228 class Args_03,
1229 class Args_04,
1230 class Args_05,
1231 class Args_06>
1232inline
1233void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1234 bsl::true_type,
1235 ELEMENT_TYPE *address,
1236 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1237 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1238 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1239 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1240 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1241 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
1242{
1243 AllocatorTraits::construct(
1244 *this,
1245 address,
1246 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1247 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1248 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1249 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1250 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1251 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1252 *this);
1253}
1254#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 6
1255
1256#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 7
1257template <class ALLOCATOR>
1258template <class ELEMENT_TYPE, class Args_01,
1259 class Args_02,
1260 class Args_03,
1261 class Args_04,
1262 class Args_05,
1263 class Args_06,
1264 class Args_07>
1265inline
1266void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1267 bsl::true_type,
1268 ELEMENT_TYPE *address,
1269 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1270 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1271 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1272 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1273 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1274 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1275 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
1276{
1277 AllocatorTraits::construct(
1278 *this,
1279 address,
1280 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1281 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1282 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1283 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1284 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1285 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1286 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1287 *this);
1288}
1289#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 7
1290
1291#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 8
1292template <class ALLOCATOR>
1293template <class ELEMENT_TYPE, class Args_01,
1294 class Args_02,
1295 class Args_03,
1296 class Args_04,
1297 class Args_05,
1298 class Args_06,
1299 class Args_07,
1300 class Args_08>
1301inline
1302void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1303 bsl::true_type,
1304 ELEMENT_TYPE *address,
1305 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1306 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1307 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1308 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1309 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1310 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1311 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1312 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
1313{
1314 AllocatorTraits::construct(
1315 *this,
1316 address,
1317 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1318 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1319 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1320 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1321 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1322 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1323 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1324 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1325 *this);
1326}
1327#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 8
1328
1329#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 9
1330template <class ALLOCATOR>
1331template <class ELEMENT_TYPE, class Args_01,
1332 class Args_02,
1333 class Args_03,
1334 class Args_04,
1335 class Args_05,
1336 class Args_06,
1337 class Args_07,
1338 class Args_08,
1339 class Args_09>
1340inline
1341void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1342 bsl::true_type,
1343 ELEMENT_TYPE *address,
1344 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1345 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1346 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1347 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1348 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1349 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1350 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1351 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1352 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
1353{
1354 AllocatorTraits::construct(
1355 *this,
1356 address,
1357 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1358 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1359 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1360 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1361 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1362 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1363 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1364 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1365 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1366 *this);
1367}
1368#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 9
1369
1370#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 10
1371template <class ALLOCATOR>
1372template <class ELEMENT_TYPE, class Args_01,
1373 class Args_02,
1374 class Args_03,
1375 class Args_04,
1376 class Args_05,
1377 class Args_06,
1378 class Args_07,
1379 class Args_08,
1380 class Args_09,
1381 class Args_10>
1382inline
1383void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1384 bsl::true_type,
1385 ELEMENT_TYPE *address,
1386 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1387 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1388 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1389 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1390 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1391 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1392 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1393 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1394 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1395 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
1396{
1397 AllocatorTraits::construct(
1398 *this,
1399 address,
1400 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1401 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1402 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1403 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1404 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1405 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1406 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1407 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1408 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1409 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1410 *this);
1411}
1412#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 10
1413
1414#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 11
1415template <class ALLOCATOR>
1416template <class ELEMENT_TYPE, class Args_01,
1417 class Args_02,
1418 class Args_03,
1419 class Args_04,
1420 class Args_05,
1421 class Args_06,
1422 class Args_07,
1423 class Args_08,
1424 class Args_09,
1425 class Args_10,
1426 class Args_11>
1427inline
1428void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1429 bsl::true_type,
1430 ELEMENT_TYPE *address,
1431 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1432 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1433 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1434 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1435 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1436 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1437 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1438 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1439 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1440 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1441 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11)
1442{
1443 AllocatorTraits::construct(
1444 *this,
1445 address,
1446 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1447 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1448 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1449 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1450 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1451 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1452 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1453 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1454 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1455 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1456 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1457 *this);
1458}
1459#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 11
1460
1461#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 12
1462template <class ALLOCATOR>
1463template <class ELEMENT_TYPE, class Args_01,
1464 class Args_02,
1465 class Args_03,
1466 class Args_04,
1467 class Args_05,
1468 class Args_06,
1469 class Args_07,
1470 class Args_08,
1471 class Args_09,
1472 class Args_10,
1473 class Args_11,
1474 class Args_12>
1475inline
1476void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1477 bsl::true_type,
1478 ELEMENT_TYPE *address,
1479 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1480 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1481 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1482 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1483 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1484 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1485 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1486 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1487 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1488 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1489 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1490 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12)
1491{
1492 AllocatorTraits::construct(
1493 *this,
1494 address,
1495 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1496 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1497 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1498 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1499 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1500 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1501 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1502 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1503 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1504 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1505 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1506 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
1507 *this);
1508}
1509#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 12
1510
1511#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 13
1512template <class ALLOCATOR>
1513template <class ELEMENT_TYPE, class Args_01,
1514 class Args_02,
1515 class Args_03,
1516 class Args_04,
1517 class Args_05,
1518 class Args_06,
1519 class Args_07,
1520 class Args_08,
1521 class Args_09,
1522 class Args_10,
1523 class Args_11,
1524 class Args_12,
1525 class Args_13>
1526inline
1527void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1528 bsl::true_type,
1529 ELEMENT_TYPE *address,
1530 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1531 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1532 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1533 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1534 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1535 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1536 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1537 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1538 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1539 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1540 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1541 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
1542 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13)
1543{
1544 AllocatorTraits::construct(
1545 *this,
1546 address,
1547 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1548 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1549 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1550 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1551 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1552 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1553 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1554 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1555 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1556 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1557 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1558 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
1559 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13),
1560 *this);
1561}
1562#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 13
1563
1564#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 14
1565template <class ALLOCATOR>
1566template <class ELEMENT_TYPE, class Args_01,
1567 class Args_02,
1568 class Args_03,
1569 class Args_04,
1570 class Args_05,
1571 class Args_06,
1572 class Args_07,
1573 class Args_08,
1574 class Args_09,
1575 class Args_10,
1576 class Args_11,
1577 class Args_12,
1578 class Args_13,
1579 class Args_14>
1580inline
1581void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1582 bsl::true_type,
1583 ELEMENT_TYPE *address,
1584 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1585 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1586 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1587 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1588 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1589 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1590 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1591 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1592 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1593 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1594 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1595 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
1596 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
1597 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14)
1598{
1599 AllocatorTraits::construct(
1600 *this,
1601 address,
1602 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1603 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1604 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1605 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1606 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1607 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1608 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1609 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1610 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1611 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1612 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1613 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
1614 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13),
1615 BSLS_COMPILERFEATURES_FORWARD(Args_14, arguments_14),
1616 *this);
1617}
1618#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 14
1619
1620
1621#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 0
1622template <class ALLOCATOR>
1623template <class ELEMENT_TYPE>
1624inline
1625void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1626 bsl::false_type,
1627 ELEMENT_TYPE *address)
1628{
1629 AllocatorTraits::construct(
1630 *this, address);
1631}
1632#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 0
1633
1634#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 1
1635template <class ALLOCATOR>
1636template <class ELEMENT_TYPE, class Args_01>
1637inline
1638void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1639 bsl::false_type,
1640 ELEMENT_TYPE *address,
1641 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
1642{
1643 AllocatorTraits::construct(
1644 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
1645}
1646#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 1
1647
1648#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 2
1649template <class ALLOCATOR>
1650template <class ELEMENT_TYPE, class Args_01,
1651 class Args_02>
1652inline
1653void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1654 bsl::false_type,
1655 ELEMENT_TYPE *address,
1656 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1657 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
1658{
1659 AllocatorTraits::construct(
1660 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1661 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
1662}
1663#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 2
1664
1665#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 3
1666template <class ALLOCATOR>
1667template <class ELEMENT_TYPE, class Args_01,
1668 class Args_02,
1669 class Args_03>
1670inline
1671void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1672 bsl::false_type,
1673 ELEMENT_TYPE *address,
1674 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1675 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1676 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
1677{
1678 AllocatorTraits::construct(
1679 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1680 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1681 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
1682}
1683#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 3
1684
1685#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 4
1686template <class ALLOCATOR>
1687template <class ELEMENT_TYPE, class Args_01,
1688 class Args_02,
1689 class Args_03,
1690 class Args_04>
1691inline
1692void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1693 bsl::false_type,
1694 ELEMENT_TYPE *address,
1695 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1696 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1697 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1698 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
1699{
1700 AllocatorTraits::construct(
1701 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1702 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1703 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1704 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
1705}
1706#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 4
1707
1708#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 5
1709template <class ALLOCATOR>
1710template <class ELEMENT_TYPE, class Args_01,
1711 class Args_02,
1712 class Args_03,
1713 class Args_04,
1714 class Args_05>
1715inline
1716void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1717 bsl::false_type,
1718 ELEMENT_TYPE *address,
1719 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1720 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1721 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1722 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1723 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
1724{
1725 AllocatorTraits::construct(
1726 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1727 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1728 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1729 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1730 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
1731}
1732#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 5
1733
1734#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 6
1735template <class ALLOCATOR>
1736template <class ELEMENT_TYPE, class Args_01,
1737 class Args_02,
1738 class Args_03,
1739 class Args_04,
1740 class Args_05,
1741 class Args_06>
1742inline
1743void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1744 bsl::false_type,
1745 ELEMENT_TYPE *address,
1746 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1747 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1748 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1749 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1750 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1751 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
1752{
1753 AllocatorTraits::construct(
1754 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1755 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1756 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1757 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1758 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1759 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
1760}
1761#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 6
1762
1763#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 7
1764template <class ALLOCATOR>
1765template <class ELEMENT_TYPE, class Args_01,
1766 class Args_02,
1767 class Args_03,
1768 class Args_04,
1769 class Args_05,
1770 class Args_06,
1771 class Args_07>
1772inline
1773void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1774 bsl::false_type,
1775 ELEMENT_TYPE *address,
1776 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1777 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1778 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1779 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1780 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1781 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1782 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
1783{
1784 AllocatorTraits::construct(
1785 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1786 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1787 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1788 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1789 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1790 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1791 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
1792}
1793#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 7
1794
1795#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 8
1796template <class ALLOCATOR>
1797template <class ELEMENT_TYPE, class Args_01,
1798 class Args_02,
1799 class Args_03,
1800 class Args_04,
1801 class Args_05,
1802 class Args_06,
1803 class Args_07,
1804 class Args_08>
1805inline
1806void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1807 bsl::false_type,
1808 ELEMENT_TYPE *address,
1809 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1810 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1811 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1812 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1813 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1814 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1815 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1816 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
1817{
1818 AllocatorTraits::construct(
1819 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1820 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1821 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1822 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1823 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1824 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1825 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1826 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
1827}
1828#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 8
1829
1830#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 9
1831template <class ALLOCATOR>
1832template <class ELEMENT_TYPE, class Args_01,
1833 class Args_02,
1834 class Args_03,
1835 class Args_04,
1836 class Args_05,
1837 class Args_06,
1838 class Args_07,
1839 class Args_08,
1840 class Args_09>
1841inline
1842void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1843 bsl::false_type,
1844 ELEMENT_TYPE *address,
1845 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1846 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1847 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1848 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1849 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1850 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1851 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1852 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1853 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
1854{
1855 AllocatorTraits::construct(
1856 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1857 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1858 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1859 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1860 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1861 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1862 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1863 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1864 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
1865}
1866#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 9
1867
1868#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 10
1869template <class ALLOCATOR>
1870template <class ELEMENT_TYPE, class Args_01,
1871 class Args_02,
1872 class Args_03,
1873 class Args_04,
1874 class Args_05,
1875 class Args_06,
1876 class Args_07,
1877 class Args_08,
1878 class Args_09,
1879 class Args_10>
1880inline
1881void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1882 bsl::false_type,
1883 ELEMENT_TYPE *address,
1884 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1885 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1886 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1887 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1888 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1889 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1890 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1891 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1892 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1893 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
1894{
1895 AllocatorTraits::construct(
1896 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1897 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1898 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1899 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1900 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1901 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1902 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1903 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1904 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1905 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
1906}
1907#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 10
1908
1909#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 11
1910template <class ALLOCATOR>
1911template <class ELEMENT_TYPE, class Args_01,
1912 class Args_02,
1913 class Args_03,
1914 class Args_04,
1915 class Args_05,
1916 class Args_06,
1917 class Args_07,
1918 class Args_08,
1919 class Args_09,
1920 class Args_10,
1921 class Args_11>
1922inline
1923void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1924 bsl::false_type,
1925 ELEMENT_TYPE *address,
1926 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1927 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1928 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1929 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1930 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1931 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1932 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1933 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1934 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1935 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1936 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11)
1937{
1938 AllocatorTraits::construct(
1939 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1940 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1941 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1942 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1943 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1944 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1945 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1946 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1947 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1948 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1949 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11));
1950}
1951#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 11
1952
1953#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 12
1954template <class ALLOCATOR>
1955template <class ELEMENT_TYPE, class Args_01,
1956 class Args_02,
1957 class Args_03,
1958 class Args_04,
1959 class Args_05,
1960 class Args_06,
1961 class Args_07,
1962 class Args_08,
1963 class Args_09,
1964 class Args_10,
1965 class Args_11,
1966 class Args_12>
1967inline
1968void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
1969 bsl::false_type,
1970 ELEMENT_TYPE *address,
1971 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
1972 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
1973 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
1974 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
1975 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
1976 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
1977 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
1978 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
1979 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
1980 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
1981 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
1982 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12)
1983{
1984 AllocatorTraits::construct(
1985 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
1986 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
1987 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
1988 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
1989 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
1990 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
1991 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
1992 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
1993 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
1994 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
1995 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
1996 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12));
1997}
1998#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 12
1999
2000#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 13
2001template <class ALLOCATOR>
2002template <class ELEMENT_TYPE, class Args_01,
2003 class Args_02,
2004 class Args_03,
2005 class Args_04,
2006 class Args_05,
2007 class Args_06,
2008 class Args_07,
2009 class Args_08,
2010 class Args_09,
2011 class Args_10,
2012 class Args_11,
2013 class Args_12,
2014 class Args_13>
2015inline
2016void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
2017 bsl::false_type,
2018 ELEMENT_TYPE *address,
2019 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2020 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2021 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2022 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2023 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2024 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2025 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2026 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2027 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2028 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2029 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2030 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
2031 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13)
2032{
2033 AllocatorTraits::construct(
2034 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2035 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2036 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2037 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2038 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2039 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2040 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2041 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2042 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2043 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2044 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2045 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
2046 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13));
2047}
2048#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 13
2049
2050#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 14
2051template <class ALLOCATOR>
2052template <class ELEMENT_TYPE, class Args_01,
2053 class Args_02,
2054 class Args_03,
2055 class Args_04,
2056 class Args_05,
2057 class Args_06,
2058 class Args_07,
2059 class Args_08,
2060 class Args_09,
2061 class Args_10,
2062 class Args_11,
2063 class Args_12,
2064 class Args_13,
2065 class Args_14>
2066inline
2067void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
2068 bsl::false_type,
2069 ELEMENT_TYPE *address,
2070 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2071 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2072 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2073 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2074 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2075 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2076 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2077 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2078 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2079 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2080 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2081 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
2082 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
2083 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14)
2084{
2085 AllocatorTraits::construct(
2086 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2087 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2088 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2089 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2090 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2091 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2092 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2093 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2094 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2095 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2096 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2097 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
2098 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13),
2099 BSLS_COMPILERFEATURES_FORWARD(Args_14, arguments_14));
2100}
2101#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_C >= 14
2102
2103#else
2104// The generated code below is a workaround for the absence of perfect
2105// forwarding in some compilers.
2106template <class ALLOCATOR>
2107template <class ELEMENT_TYPE, class... Args>
2108inline
2109void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
2110 bsl::true_type,
2111 ELEMENT_TYPE *address,
2112 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
2113{
2114 AllocatorTraits::construct(
2115 *this,
2116 address,
2117 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...,
2118 *this);
2119}
2120
2121template <class ALLOCATOR>
2122template <class ELEMENT_TYPE, class... Args>
2123inline
2124void StdAllocatorAdaptor<ALLOCATOR>::privateConstruct(
2125 bsl::false_type,
2126 ELEMENT_TYPE *address,
2127 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
2128{
2129 AllocatorTraits::construct(
2130 *this, address, BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
2131}
2132
2133// }}} END GENERATED CODE
2134#endif
2135
2136// CREATORS
2137template <class ALLOCATOR>
2138inline
2139StdAllocatorAdaptor<ALLOCATOR>::StdAllocatorAdaptor()
2140: ALLOCATOR()
2141{
2142}
2143
2144template <class ALLOCATOR>
2145inline
2146StdAllocatorAdaptor<ALLOCATOR>::StdAllocatorAdaptor(const ALLOCATOR& allocator)
2147: ALLOCATOR(allocator)
2148{
2149}
2150
2151template <class ALLOCATOR>
2152inline
2153StdAllocatorAdaptor<ALLOCATOR>::StdAllocatorAdaptor(bsl::nullptr_t)
2154: ALLOCATOR(0)
2155{
2156}
2157
2158template <class ALLOCATOR>
2159template <class ANY_TYPE>
2160inline
2161StdAllocatorAdaptor<ALLOCATOR>::StdAllocatorAdaptor(
2162 const StdAllocatorAdaptor<ANY_TYPE>& other)
2163: ALLOCATOR(other)
2164{
2165}
2166
2167// MANIPULATORS
2168#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
2169// {{{ BEGIN GENERATED CODE
2170// Command line: sim_cpp11_features.pl bsltf_stdallocatoradaptor.h
2171#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
2172#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT 14
2173#endif
2174#ifndef BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D
2175#define BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT
2176#endif
2177#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 0
2178template <class ALLOCATOR>
2179template <class ELEMENT_TYPE>
2180inline void
2181StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address)
2182{
2183 enum { k_PassSelfAtEnd =
2184 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2185 ! bsl::is_convertible<StdAllocatorAdaptor *,
2186 bsl::allocator<value_type> *>::value
2187 };
2188
2189 privateConstruct(
2190 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2191 address);
2192}
2193#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 0
2194
2195#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 1
2196template <class ALLOCATOR>
2197template <class ELEMENT_TYPE, class Args_01>
2198inline void
2199StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2200 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01)
2201{
2202 enum { k_PassSelfAtEnd =
2203 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2204 ! bsl::is_convertible<StdAllocatorAdaptor *,
2205 bsl::allocator<value_type> *>::value
2206 };
2207
2208 privateConstruct(
2209 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2210 address,
2211 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01));
2212}
2213#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 1
2214
2215#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 2
2216template <class ALLOCATOR>
2217template <class ELEMENT_TYPE, class Args_01,
2218 class Args_02>
2219inline void
2220StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2221 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2222 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02)
2223{
2224 enum { k_PassSelfAtEnd =
2225 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2226 ! bsl::is_convertible<StdAllocatorAdaptor *,
2227 bsl::allocator<value_type> *>::value
2228 };
2229
2230 privateConstruct(
2231 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2232 address,
2233 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2234 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02));
2235}
2236#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 2
2237
2238#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 3
2239template <class ALLOCATOR>
2240template <class ELEMENT_TYPE, class Args_01,
2241 class Args_02,
2242 class Args_03>
2243inline void
2244StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2245 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2246 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2247 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03)
2248{
2249 enum { k_PassSelfAtEnd =
2250 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2251 ! bsl::is_convertible<StdAllocatorAdaptor *,
2252 bsl::allocator<value_type> *>::value
2253 };
2254
2255 privateConstruct(
2256 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2257 address,
2258 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2259 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2260 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03));
2261}
2262#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 3
2263
2264#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 4
2265template <class ALLOCATOR>
2266template <class ELEMENT_TYPE, class Args_01,
2267 class Args_02,
2268 class Args_03,
2269 class Args_04>
2270inline void
2271StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2272 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2273 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2274 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2275 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04)
2276{
2277 enum { k_PassSelfAtEnd =
2278 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2279 ! bsl::is_convertible<StdAllocatorAdaptor *,
2280 bsl::allocator<value_type> *>::value
2281 };
2282
2283 privateConstruct(
2284 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2285 address,
2286 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2287 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2288 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2289 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04));
2290}
2291#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 4
2292
2293#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 5
2294template <class ALLOCATOR>
2295template <class ELEMENT_TYPE, class Args_01,
2296 class Args_02,
2297 class Args_03,
2298 class Args_04,
2299 class Args_05>
2300inline void
2301StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2302 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2303 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2304 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2305 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2306 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05)
2307{
2308 enum { k_PassSelfAtEnd =
2309 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2310 ! bsl::is_convertible<StdAllocatorAdaptor *,
2311 bsl::allocator<value_type> *>::value
2312 };
2313
2314 privateConstruct(
2315 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2316 address,
2317 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2318 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2319 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2320 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2321 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05));
2322}
2323#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 5
2324
2325#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 6
2326template <class ALLOCATOR>
2327template <class ELEMENT_TYPE, class Args_01,
2328 class Args_02,
2329 class Args_03,
2330 class Args_04,
2331 class Args_05,
2332 class Args_06>
2333inline void
2334StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2335 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2336 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2337 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2338 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2339 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2340 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06)
2341{
2342 enum { k_PassSelfAtEnd =
2343 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2344 ! bsl::is_convertible<StdAllocatorAdaptor *,
2345 bsl::allocator<value_type> *>::value
2346 };
2347
2348 privateConstruct(
2349 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2350 address,
2351 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2352 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2353 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2354 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2355 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2356 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06));
2357}
2358#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 6
2359
2360#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 7
2361template <class ALLOCATOR>
2362template <class ELEMENT_TYPE, class Args_01,
2363 class Args_02,
2364 class Args_03,
2365 class Args_04,
2366 class Args_05,
2367 class Args_06,
2368 class Args_07>
2369inline void
2370StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2371 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2372 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2373 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2374 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2375 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2376 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2377 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07)
2378{
2379 enum { k_PassSelfAtEnd =
2380 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2381 ! bsl::is_convertible<StdAllocatorAdaptor *,
2382 bsl::allocator<value_type> *>::value
2383 };
2384
2385 privateConstruct(
2386 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2387 address,
2388 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2389 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2390 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2391 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2392 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2393 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2394 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07));
2395}
2396#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 7
2397
2398#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 8
2399template <class ALLOCATOR>
2400template <class ELEMENT_TYPE, class Args_01,
2401 class Args_02,
2402 class Args_03,
2403 class Args_04,
2404 class Args_05,
2405 class Args_06,
2406 class Args_07,
2407 class Args_08>
2408inline void
2409StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2410 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2411 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2412 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2413 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2414 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2415 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2416 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2417 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08)
2418{
2419 enum { k_PassSelfAtEnd =
2420 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2421 ! bsl::is_convertible<StdAllocatorAdaptor *,
2422 bsl::allocator<value_type> *>::value
2423 };
2424
2425 privateConstruct(
2426 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2427 address,
2428 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2429 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2430 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2431 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2432 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2433 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2434 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2435 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08));
2436}
2437#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 8
2438
2439#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 9
2440template <class ALLOCATOR>
2441template <class ELEMENT_TYPE, class Args_01,
2442 class Args_02,
2443 class Args_03,
2444 class Args_04,
2445 class Args_05,
2446 class Args_06,
2447 class Args_07,
2448 class Args_08,
2449 class Args_09>
2450inline void
2451StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2452 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2453 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2454 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2455 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2456 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2457 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2458 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2459 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2460 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09)
2461{
2462 enum { k_PassSelfAtEnd =
2463 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2464 ! bsl::is_convertible<StdAllocatorAdaptor *,
2465 bsl::allocator<value_type> *>::value
2466 };
2467
2468 privateConstruct(
2469 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2470 address,
2471 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2472 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2473 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2474 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2475 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2476 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2477 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2478 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2479 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09));
2480}
2481#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 9
2482
2483#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 10
2484template <class ALLOCATOR>
2485template <class ELEMENT_TYPE, class Args_01,
2486 class Args_02,
2487 class Args_03,
2488 class Args_04,
2489 class Args_05,
2490 class Args_06,
2491 class Args_07,
2492 class Args_08,
2493 class Args_09,
2494 class Args_10>
2495inline void
2496StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2497 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2498 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2499 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2500 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2501 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2502 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2503 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2504 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2505 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2506 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10)
2507{
2508 enum { k_PassSelfAtEnd =
2509 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2510 ! bsl::is_convertible<StdAllocatorAdaptor *,
2511 bsl::allocator<value_type> *>::value
2512 };
2513
2514 privateConstruct(
2515 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2516 address,
2517 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2518 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2519 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2520 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2521 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2522 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2523 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2524 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2525 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2526 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10));
2527}
2528#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 10
2529
2530#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 11
2531template <class ALLOCATOR>
2532template <class ELEMENT_TYPE, class Args_01,
2533 class Args_02,
2534 class Args_03,
2535 class Args_04,
2536 class Args_05,
2537 class Args_06,
2538 class Args_07,
2539 class Args_08,
2540 class Args_09,
2541 class Args_10,
2542 class Args_11>
2543inline void
2544StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2545 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2546 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2547 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2548 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2549 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2550 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2551 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2552 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2553 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2554 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2555 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11)
2556{
2557 enum { k_PassSelfAtEnd =
2558 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2559 ! bsl::is_convertible<StdAllocatorAdaptor *,
2560 bsl::allocator<value_type> *>::value
2561 };
2562
2563 privateConstruct(
2564 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2565 address,
2566 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2567 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2568 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2569 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2570 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2571 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2572 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2573 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2574 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2575 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2576 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11));
2577}
2578#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 11
2579
2580#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 12
2581template <class ALLOCATOR>
2582template <class ELEMENT_TYPE, class Args_01,
2583 class Args_02,
2584 class Args_03,
2585 class Args_04,
2586 class Args_05,
2587 class Args_06,
2588 class Args_07,
2589 class Args_08,
2590 class Args_09,
2591 class Args_10,
2592 class Args_11,
2593 class Args_12>
2594inline void
2595StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2596 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2597 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2598 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2599 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2600 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2601 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2602 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2603 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2604 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2605 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2606 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2607 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12)
2608{
2609 enum { k_PassSelfAtEnd =
2610 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2611 ! bsl::is_convertible<StdAllocatorAdaptor *,
2612 bsl::allocator<value_type> *>::value
2613 };
2614
2615 privateConstruct(
2616 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2617 address,
2618 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2619 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2620 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2621 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2622 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2623 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2624 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2625 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2626 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2627 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2628 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2629 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12));
2630}
2631#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 12
2632
2633#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 13
2634template <class ALLOCATOR>
2635template <class ELEMENT_TYPE, class Args_01,
2636 class Args_02,
2637 class Args_03,
2638 class Args_04,
2639 class Args_05,
2640 class Args_06,
2641 class Args_07,
2642 class Args_08,
2643 class Args_09,
2644 class Args_10,
2645 class Args_11,
2646 class Args_12,
2647 class Args_13>
2648inline void
2649StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2650 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2651 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2652 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2653 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2654 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2655 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2656 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2657 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2658 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2659 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2660 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2661 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
2662 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13)
2663{
2664 enum { k_PassSelfAtEnd =
2665 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2666 ! bsl::is_convertible<StdAllocatorAdaptor *,
2667 bsl::allocator<value_type> *>::value
2668 };
2669
2670 privateConstruct(
2671 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2672 address,
2673 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2674 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2675 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2676 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2677 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2678 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2679 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2680 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2681 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2682 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2683 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2684 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
2685 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13));
2686}
2687#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 13
2688
2689#if BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 14
2690template <class ALLOCATOR>
2691template <class ELEMENT_TYPE, class Args_01,
2692 class Args_02,
2693 class Args_03,
2694 class Args_04,
2695 class Args_05,
2696 class Args_06,
2697 class Args_07,
2698 class Args_08,
2699 class Args_09,
2700 class Args_10,
2701 class Args_11,
2702 class Args_12,
2703 class Args_13,
2704 class Args_14>
2705inline void
2706StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2707 BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) arguments_01,
2708 BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) arguments_02,
2709 BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) arguments_03,
2710 BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) arguments_04,
2711 BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) arguments_05,
2712 BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) arguments_06,
2713 BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) arguments_07,
2714 BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) arguments_08,
2715 BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) arguments_09,
2716 BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) arguments_10,
2717 BSLS_COMPILERFEATURES_FORWARD_REF(Args_11) arguments_11,
2718 BSLS_COMPILERFEATURES_FORWARD_REF(Args_12) arguments_12,
2719 BSLS_COMPILERFEATURES_FORWARD_REF(Args_13) arguments_13,
2720 BSLS_COMPILERFEATURES_FORWARD_REF(Args_14) arguments_14)
2721{
2722 enum { k_PassSelfAtEnd =
2723 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2724 ! bsl::is_convertible<StdAllocatorAdaptor *,
2725 bsl::allocator<value_type> *>::value
2726 };
2727
2728 privateConstruct(
2729 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2730 address,
2731 BSLS_COMPILERFEATURES_FORWARD(Args_01, arguments_01),
2732 BSLS_COMPILERFEATURES_FORWARD(Args_02, arguments_02),
2733 BSLS_COMPILERFEATURES_FORWARD(Args_03, arguments_03),
2734 BSLS_COMPILERFEATURES_FORWARD(Args_04, arguments_04),
2735 BSLS_COMPILERFEATURES_FORWARD(Args_05, arguments_05),
2736 BSLS_COMPILERFEATURES_FORWARD(Args_06, arguments_06),
2737 BSLS_COMPILERFEATURES_FORWARD(Args_07, arguments_07),
2738 BSLS_COMPILERFEATURES_FORWARD(Args_08, arguments_08),
2739 BSLS_COMPILERFEATURES_FORWARD(Args_09, arguments_09),
2740 BSLS_COMPILERFEATURES_FORWARD(Args_10, arguments_10),
2741 BSLS_COMPILERFEATURES_FORWARD(Args_11, arguments_11),
2742 BSLS_COMPILERFEATURES_FORWARD(Args_12, arguments_12),
2743 BSLS_COMPILERFEATURES_FORWARD(Args_13, arguments_13),
2744 BSLS_COMPILERFEATURES_FORWARD(Args_14, arguments_14));
2745}
2746#endif // BSLTF_STDALLOCATORADAPTOR_VARIADIC_LIMIT_D >= 14
2747
2748#else
2749// The generated code below is a workaround for the absence of perfect
2750// forwarding in some compilers.
2751template <class ALLOCATOR>
2752template <class ELEMENT_TYPE, class... Args>
2753inline void
2754StdAllocatorAdaptor<ALLOCATOR>::construct(ELEMENT_TYPE *address,
2755 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... arguments)
2756{
2757 enum { k_PassSelfAtEnd =
2758 bsl::uses_allocator<ELEMENT_TYPE, StdAllocatorAdaptor>::value &&
2759 ! bsl::is_convertible<StdAllocatorAdaptor *,
2760 bsl::allocator<value_type> *>::value
2761 };
2762
2763 privateConstruct(
2764 bsl::integral_constant<bool, (bool) k_PassSelfAtEnd>(),
2765 address,
2766 BSLS_COMPILERFEATURES_FORWARD(Args, arguments)...);
2767}
2768// }}} END GENERATED CODE
2769#endif
2770
2771// ACCESSORS
2772template <class ALLOCATOR>
2773inline
2774const ALLOCATOR& StdAllocatorAdaptor<ALLOCATOR>::allocator() const
2775{
2776 return *this;
2777}
2778
2779template <class ALLOCATOR>
2780inline
2781StdAllocatorAdaptor<ALLOCATOR>
2782StdAllocatorAdaptor<ALLOCATOR>::select_on_container_copy_construction() const
2783{
2784 return StdAllocatorAdaptor<ALLOCATOR>(
2785 AllocatorTraits::select_on_container_copy_construction(
2786 *reinterpret_cast<const ALLOCATOR *>(this)));
2787}
2788
2789// FREE OPERATORS
2790template <class TYPE1, class TYPE2>
2791inline
2792bool operator==(const bsltf::StdAllocatorAdaptor<TYPE1>& lhs,
2793 const bsltf::StdAllocatorAdaptor<TYPE2>& rhs)
2794{
2795 return lhs.allocator() == rhs.allocator();
2796}
2797
2798template <class TYPE1, class TYPE2>
2799inline
2800bool operator!=(const bsltf::StdAllocatorAdaptor<TYPE1>& lhs,
2801 const bsltf::StdAllocatorAdaptor<TYPE2>& rhs)
2802{
2803 return lhs.allocator() != rhs.allocator();
2804}
2805
2806} // close package namespace
2807
2808
2809#else // if ! defined(DEFINED_BSLTF_STDALLOCATORADAPTOR_H)
2810# error Not valid except when included from bsltf_stdallocatoradaptor.h
2811#endif // ! defined(COMPILING_BSLTF_STDALLOCATORADAPTOR_H)
2812
2813#endif // ! defined(INCLUDED_BSLTF_STDALLOCATORADAPTOR_CPP03)
2814
2815// ----------------------------------------------------------------------------
2816// Copyright 2016 Bloomberg Finance L.P.
2817//
2818// Licensed under the Apache License, Version 2.0 (the "License");
2819// you may not use this file except in compliance with the License.
2820// You may obtain a copy of the License at
2821//
2822// http://www.apache.org/licenses/LICENSE-2.0
2823//
2824// Unless required by applicable law or agreed to in writing, software
2825// distributed under the License is distributed on an "AS IS" BASIS,
2826// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2827// See the License for the specific language governing permissions and
2828// limitations under the License.
2829// ----------------------------- END-OF-FILE ----------------------------------
2830
2831/** @} */
2832/** @} */
2833/** @} */
BSLMF_NESTED_TRAIT_DECLARATION
#define BSLMF_NESTED_TRAIT_DECLARATION(t_TYPE, t_TRAIT)
Definition bslmf_nestedtraitdeclaration.h:231
bsl::allocator
Definition bslma_bslallocator.h:580
bsltf::StdAllocatorAdaptor
Definition bsltf_stdallocatoradaptor.h:168
bsltf::StdAllocatorAdaptor::size_type
ALLOCATOR::size_type size_type
Definition bsltf_stdallocatoradaptor.h:200
bsltf::StdAllocatorAdaptor::allocator
const ALLOCATOR & allocator() const
Definition bsltf_stdallocatoradaptor.h:409
bsltf::StdAllocatorAdaptor::select_on_container_copy_construction
StdAllocatorAdaptor< ALLOCATOR > select_on_container_copy_construction() const
Definition bsltf_stdallocatoradaptor.h:417
bsltf::StdAllocatorAdaptor::construct
void construct(ELEMENT_TYPE *address, Args &&... arguments)
Definition bsltf_stdallocatoradaptor.h:383
bsltf::StdAllocatorAdaptor::difference_type
ALLOCATOR::difference_type difference_type
Definition bsltf_stdallocatoradaptor.h:201
bsltf::StdAllocatorAdaptor::reference
ALLOCATOR::reference reference
Definition bsltf_stdallocatoradaptor.h:204
bsltf::StdAllocatorAdaptor::operator=
StdAllocatorAdaptor & operator=(const StdAllocatorAdaptor &rhs)=default
bsltf::StdAllocatorAdaptor::pointer
ALLOCATOR::pointer pointer
Definition bsltf_stdallocatoradaptor.h:202
bsltf::StdAllocatorAdaptor::const_reference
ALLOCATOR::const_reference const_reference
Definition bsltf_stdallocatoradaptor.h:205
bsltf::StdAllocatorAdaptor::StdAllocatorAdaptor
StdAllocatorAdaptor()
Definition bsltf_stdallocatoradaptor.h:350
bsltf::StdAllocatorAdaptor::value_type
ALLOCATOR::value_type value_type
Definition bsltf_stdallocatoradaptor.h:206
bsltf::StdAllocatorAdaptor::const_pointer
ALLOCATOR::const_pointer const_pointer
Definition bsltf_stdallocatoradaptor.h:203
BSLS_COMPILERFEATURES_FORWARD_REF
#define BSLS_COMPILERFEATURES_FORWARD_REF(T)
Definition bsls_compilerfeatures.h:2012
BSLS_COMPILERFEATURES_FORWARD
#define BSLS_COMPILERFEATURES_FORWARD(T, V)
Definition bsls_compilerfeatures.h:2018
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:281
bsltf
Definition bsltf_allocargumenttype.h:92
bsl::allocator_traits
Definition bslma_allocatortraits.h:1061
bsl::integral_constant< bool, true >
bsl::is_convertible
Definition bslmf_isconvertible.h:867
bsl::uses_allocator
Definition bslmf_usesallocator.h:165
bslma::IsStdAllocator
Definition bslma_isstdallocator.h:201
bsltf::StdAllocatorAdaptor::rebind::other
StdAllocatorAdaptor< typename ALLOCATOR::template rebind< BDE_OTHER_TYPE >::other > other
Definition bsltf_stdallocatoradaptor.h:219