BDE 4.14.0 Production release
Loading...
Searching...
No Matches
bslma_bslallocator_cpp03.h
Go to the documentation of this file.
1/// @file bslma_bslallocator_cpp03.h
2///
3/// The content of this file has been pre-processed for Doxygen.
4///
5
6
7// bslma_bslallocator_cpp03.h -*-C++-*-
8
9// Automatically generated file. **DO NOT EDIT**
10
11#ifndef INCLUDED_BSLMA_BSLALLOCATOR_CPP03
12#define INCLUDED_BSLMA_BSLALLOCATOR_CPP03
13
14/// @defgroup bslma_bslallocator_cpp03 bslma_bslallocator_cpp03
15/// @brief Provide C++03 implementation for bslma_bslallocator.h
16/// @addtogroup bsl
17/// @{
18/// @addtogroup bslma
19/// @{
20/// @addtogroup bslma_bslallocator_cpp03
21/// @{
22///
23/// <h1> Outline </h1>
24/// * <a href="#bslma_bslallocator_cpp03-purpose"> Purpose</a>
25/// * <a href="#bslma_bslallocator_cpp03-classes"> Classes </a>
26/// * <a href="#bslma_bslallocator_cpp03-description"> Description </a>
27///
28/// # Purpose {#bslma_bslallocator_cpp03-purpose}
29/// Provide C++03 implementation for bslma_bslallocator.h
30///
31/// # Classes {#bslma_bslallocator_cpp03-classes}
32/// See bslma_bslallocator.h for list of classes
33///
34/// @see bslma_bslallocator
35///
36/// # Description {#bslma_bslallocator_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 09:58:46 2024
48/// Command line: sim_cpp11_features.pl bslma_bslallocator.h
49/// @}
50/** @} */
51/** @} */
52
53/** @addtogroup bsl
54 * @{
55 */
56/** @addtogroup bslma
57 * @{
58 */
59/** @addtogroup bslma_bslallocator_cpp03
60 * @{
61 */
62
63#ifdef COMPILING_BSLMA_BSLALLOCATOR_H
64
65#define BSLMA_BSLALLOCATOR_DEPRECATE_ASSIGN \
66 BSLS_DEPRECATE_FEATURE("bsl", "bsl_allocator_assign", \
67 "Do not assign allocators.")
68
69
70namespace bslma {
71
72// FORWARD DECLARATIONS
73struct BslAllocator_Voidish;
74 // Object type that will be placeholder for 'void'
75
76} // close package namespace
77
78
79namespace bsl {
80
81 // ===============
82 // class allocator
83 // ===============
84
85/// An STL-compatible allocator that forwards allocation calls to an
86/// underlying mechanism object of a type derived from `bslma::Allocator`.
87/// This class template adheres to the allocator requirements defined in
88/// section [allocator.requirements] and implements a superset of the
89/// `std::pmr::polymorphic_allocator` class template described in section
90/// [mem.poly.allocator.class] of the C++ standard and may be used to
91/// instantiate any [container] class template that follows the STL
92/// allocator protocol. The allocation mechanism is chosen at run-time,
93/// giving the programmer run-time control over how a container allocates
94/// and frees memory.
95///
96/// See @ref bslma_bslallocator_cpp03
97template <class TYPE = polymorphic_allocator<>::value_type>
98class allocator : public polymorphic_allocator<TYPE> {
99
100 // PRIVATE TYPES
101 typedef polymorphic_allocator<TYPE> Base;
102 typedef allocator_traits<Base> BaseTraits;
103
104 public:
105 // TRAITS
106 // Note that `allocator` is not trivially copyable because its assignment
107 // operator is not trivial.
108 BSLMF_NESTED_TRAIT_DECLARATION(allocator,
109 BloombergLP::bslmf::IsBitwiseCopyable);
110 BSLMF_NESTED_TRAIT_DECLARATION(allocator,
111 BloombergLP::bslmf::IsBitwiseEqualityComparable);
112
113 // PUBLIC TYPES
114 typedef TYPE value_type;
115 typedef value_type& reference;
116 typedef value_type const& const_reference;
117 typedef typename BaseTraits::size_type size_type;
118 typedef typename BaseTraits::difference_type difference_type;
119 typedef typename BaseTraits::pointer pointer;
120 typedef typename BaseTraits::const_pointer const_pointer;
121 typedef typename BaseTraits::void_pointer void_pointer;
122 typedef typename BaseTraits::const_void_pointer const_void_pointer;
123
124 /// This nested `struct` template, parameterized by `ANY_TYPE`, provides
125 /// a namespace for an `other` type alias, which is this template
126 /// instantiated with `ANY_TYPE` instead of `TYPE`. Note that this
127 /// allocator type is convertible to and from `other` for any type,
128 /// including `void`.
129 template <class ANY_TYPE>
130 struct rebind {
131
132 typedef allocator<ANY_TYPE> other;
133 };
134
135 // CREATORS
136
137 /// Create an allocator that will forward allocation calls to the
138 /// object pointed to by `bslma::Default::defaultAllocator()`.
139 /// Postcondition:
140 /// @code
141 /// this->mechanism() == bslma::Default::defaultAllocator()
142 /// @endcode
143 allocator();
144
145 /// Convert a `bslma::Allocator` pointer to an `allocator` object that
146 /// forwards allocation calls to the object pointed to by the specified
147 /// `mechanism`. If `mechanism` is 0, then the currently installed
148 /// default allocator is used instead. Postcondition:
149 /// @code
150 /// this->mechanism() == bslma::Default::allocator(mechanism)
151 /// @endcode
152 allocator(BloombergLP::bslma::Allocator *mechanism); // IMPLICIT
153
154#ifdef BSLS_COMPILERFEATURES_SUPPORT_DEFAULTED_FUNCTIONS
155 allocator(const allocator& original) BSLS_KEYWORD_NOEXCEPT = default;
156#else
157 allocator(const allocator& original) BSLS_KEYWORD_NOEXCEPT;
158#endif
159 /// Create an allocator sharing the same mechanism object as the
160 /// specified `original`. The newly constructed allocator will compare
161 /// equal to `original`, even though they may be instantiated on
162 /// different types. Postconditions:
163 /// @code
164 /// *this == original
165 /// this->mechanism() == original.mechanism()
166 /// @endcode
167 template <class ANY_TYPE>
168 allocator(const allocator<ANY_TYPE>& original) BSLS_KEYWORD_NOEXCEPT;
169
170 ~allocator() = default;
171 // Destroy this object. Note that this destructor does not delete the
172 // object pointed to by 'mechanism()'.
173
174 // MANIPULATORS
175 BSLMA_BSLALLOCATOR_DEPRECATE_ASSIGN
176 /// **DEPRECATED** `bsl::allocator` should not be assigned. Modify this
177 /// allocator to use the same mechanism as the specified `rhs` allocator
178 /// and return a modifiable reference to this object. Note that
179 /// `bsl::allocator` objects should never be assigned at runtime, but,
180 /// in the absence of `if constexpr`, such assignments can sometimes be
181 /// found legitimately in dead branches (branches that are never taken
182 /// at runtime) within function templates; ideally, such code would be
183 /// replaced by more sophisticated metaprogramming that avoided calls to
184 /// this operator entirely. Invoking this assignment will result in a
185 /// review error unless `rhs == *this`, i.e., when the assignment would
186 /// be a no-op. In the future, the review error may be replaced with an
187 /// a hard assertion failure.
188 allocator& operator=(const allocator& rhs);
189
190 /// Return a block of memory having sufficient size and alignment to
191 /// hold the specified `n` objects of `value_type`, allocated from the
192 /// memory resource held by this allocator. Optionally specify a
193 /// `hint`, which is ignored by this allocator type but theoretically
194 /// used by other allocators as an aid for optimizing locality.
195 BSLS_ANNOTATION_NODISCARD
196 pointer allocate(size_type n, const void *hint = 0);
197
198 /// Deallocate a block of memory at the specified `p` address by
199 /// returning it to the memory resource held by this allocator.
200 /// Optionally specify the number of objects, `n`, to deallocate. The
201 /// behavior is undefined unless `p` is the address of a block
202 /// previously allocated by a call to `allocate` with the same `n` from
203 /// a copy of this allocator having the same `value_type` and not yet
204 /// deallocated.
205 void deallocate(TYPE *p, std::size_t n = 1);
206
207 /// Create a default-constructed object of (template parameter)
208 /// `ELEMENT_TYPE` at the specified `address`. If `ELEMENT_TYPE`
209 /// supports `bslma`-style allocation, this allocator passes itself to
210 /// the extended default constructor. If the constructor throws, the
211 /// memory at `address` is left in an unspecified state. The behavior
212 /// is undefined unless `address` refers to a block of sufficient size
213 /// and properly aligned for objects of `ELEMENT_TYPE`.
214 template <class ELEMENT_TYPE>
215 void construct(ELEMENT_TYPE *address);
216
217#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
218// {{{ BEGIN GENERATED CODE
219// Command line: sim_cpp11_features.pl bslma_bslallocator.h
220#ifndef BSLMA_BSLALLOCATOR_VARIADIC_LIMIT
221#define BSLMA_BSLALLOCATOR_VARIADIC_LIMIT 14
222#endif
223#ifndef BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A
224#define BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A BSLMA_BSLALLOCATOR_VARIADIC_LIMIT
225#endif
226
227#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 0
228 template <class ELEMENT_TYPE, class ARG1>
229 void construct(ELEMENT_TYPE *address,
230 ARG1& argument1);
231#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 0
232
233#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 1
234 template <class ELEMENT_TYPE, class ARG1, class ARGS_01>
235 void construct(ELEMENT_TYPE *address,
236 ARG1& argument1,
237 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01);
238#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 1
239
240#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 2
241 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
242 class ARGS_02>
243 void construct(ELEMENT_TYPE *address,
244 ARG1& argument1,
245 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
246 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02);
247#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 2
248
249#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 3
250 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
251 class ARGS_02,
252 class ARGS_03>
253 void construct(ELEMENT_TYPE *address,
254 ARG1& argument1,
255 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
256 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
257 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03);
258#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 3
259
260#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 4
261 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
262 class ARGS_02,
263 class ARGS_03,
264 class ARGS_04>
265 void construct(ELEMENT_TYPE *address,
266 ARG1& argument1,
267 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
268 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
269 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
270 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04);
271#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 4
272
273#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 5
274 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
275 class ARGS_02,
276 class ARGS_03,
277 class ARGS_04,
278 class ARGS_05>
279 void construct(ELEMENT_TYPE *address,
280 ARG1& argument1,
281 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
282 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
283 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
284 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
285 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05);
286#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 5
287
288#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 6
289 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
290 class ARGS_02,
291 class ARGS_03,
292 class ARGS_04,
293 class ARGS_05,
294 class ARGS_06>
295 void construct(ELEMENT_TYPE *address,
296 ARG1& argument1,
297 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
298 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
299 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
300 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
301 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
302 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06);
303#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 6
304
305#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 7
306 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
307 class ARGS_02,
308 class ARGS_03,
309 class ARGS_04,
310 class ARGS_05,
311 class ARGS_06,
312 class ARGS_07>
313 void construct(ELEMENT_TYPE *address,
314 ARG1& argument1,
315 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
316 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
317 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
318 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
319 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
320 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
321 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07);
322#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 7
323
324#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 8
325 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
326 class ARGS_02,
327 class ARGS_03,
328 class ARGS_04,
329 class ARGS_05,
330 class ARGS_06,
331 class ARGS_07,
332 class ARGS_08>
333 void construct(ELEMENT_TYPE *address,
334 ARG1& argument1,
335 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
336 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
337 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
338 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
339 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
340 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
341 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
342 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08);
343#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 8
344
345#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 9
346 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
347 class ARGS_02,
348 class ARGS_03,
349 class ARGS_04,
350 class ARGS_05,
351 class ARGS_06,
352 class ARGS_07,
353 class ARGS_08,
354 class ARGS_09>
355 void construct(ELEMENT_TYPE *address,
356 ARG1& argument1,
357 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
358 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
359 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
360 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
361 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
362 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
363 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
364 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
365 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09);
366#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 9
367
368#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 10
369 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
370 class ARGS_02,
371 class ARGS_03,
372 class ARGS_04,
373 class ARGS_05,
374 class ARGS_06,
375 class ARGS_07,
376 class ARGS_08,
377 class ARGS_09,
378 class ARGS_10>
379 void construct(ELEMENT_TYPE *address,
380 ARG1& argument1,
381 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
382 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
383 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
384 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
385 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
386 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
387 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
388 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
389 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
390 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10);
391#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 10
392
393#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 11
394 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
395 class ARGS_02,
396 class ARGS_03,
397 class ARGS_04,
398 class ARGS_05,
399 class ARGS_06,
400 class ARGS_07,
401 class ARGS_08,
402 class ARGS_09,
403 class ARGS_10,
404 class ARGS_11>
405 void construct(ELEMENT_TYPE *address,
406 ARG1& argument1,
407 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
408 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
409 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
410 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
411 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
412 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
413 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
414 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
415 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
416 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
417 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11);
418#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 11
419
420#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 12
421 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
422 class ARGS_02,
423 class ARGS_03,
424 class ARGS_04,
425 class ARGS_05,
426 class ARGS_06,
427 class ARGS_07,
428 class ARGS_08,
429 class ARGS_09,
430 class ARGS_10,
431 class ARGS_11,
432 class ARGS_12>
433 void construct(ELEMENT_TYPE *address,
434 ARG1& argument1,
435 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
436 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
437 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
438 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
439 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
440 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
441 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
442 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
443 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
444 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
445 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
446 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12);
447#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 12
448
449#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 13
450 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
451 class ARGS_02,
452 class ARGS_03,
453 class ARGS_04,
454 class ARGS_05,
455 class ARGS_06,
456 class ARGS_07,
457 class ARGS_08,
458 class ARGS_09,
459 class ARGS_10,
460 class ARGS_11,
461 class ARGS_12,
462 class ARGS_13>
463 void construct(ELEMENT_TYPE *address,
464 ARG1& argument1,
465 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
466 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
467 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
468 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
469 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
470 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
471 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
472 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
473 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
474 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
475 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
476 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
477 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13);
478#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 13
479
480#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 14
481 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
482 class ARGS_02,
483 class ARGS_03,
484 class ARGS_04,
485 class ARGS_05,
486 class ARGS_06,
487 class ARGS_07,
488 class ARGS_08,
489 class ARGS_09,
490 class ARGS_10,
491 class ARGS_11,
492 class ARGS_12,
493 class ARGS_13,
494 class ARGS_14>
495 void construct(ELEMENT_TYPE *address,
496 ARG1& argument1,
497 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
498 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
499 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
500 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
501 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
502 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
503 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
504 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
505 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
506 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
507 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
508 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
509 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13,
510 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) arguments_14);
511#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 14
512
513#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 0
514 template <class ELEMENT_TYPE, class ARG1>
515 void construct(ELEMENT_TYPE *address,
516 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1);
517#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 0
518
519#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 1
520 template <class ELEMENT_TYPE, class ARG1, class ARGS_01>
521 void construct(ELEMENT_TYPE *address,
522 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
523 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01);
524#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 1
525
526#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 2
527 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
528 class ARGS_02>
529 void construct(ELEMENT_TYPE *address,
530 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
531 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
532 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02);
533#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 2
534
535#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 3
536 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
537 class ARGS_02,
538 class ARGS_03>
539 void construct(ELEMENT_TYPE *address,
540 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
541 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
542 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
543 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03);
544#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 3
545
546#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 4
547 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
548 class ARGS_02,
549 class ARGS_03,
550 class ARGS_04>
551 void construct(ELEMENT_TYPE *address,
552 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
553 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
554 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
555 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
556 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04);
557#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 4
558
559#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 5
560 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
561 class ARGS_02,
562 class ARGS_03,
563 class ARGS_04,
564 class ARGS_05>
565 void construct(ELEMENT_TYPE *address,
566 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
567 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
568 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
569 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
570 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
571 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05);
572#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 5
573
574#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 6
575 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
576 class ARGS_02,
577 class ARGS_03,
578 class ARGS_04,
579 class ARGS_05,
580 class ARGS_06>
581 void construct(ELEMENT_TYPE *address,
582 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
583 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
584 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
585 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
586 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
587 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
588 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06);
589#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 6
590
591#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 7
592 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
593 class ARGS_02,
594 class ARGS_03,
595 class ARGS_04,
596 class ARGS_05,
597 class ARGS_06,
598 class ARGS_07>
599 void construct(ELEMENT_TYPE *address,
600 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
601 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
602 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
603 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
604 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
605 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
606 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
607 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07);
608#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 7
609
610#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 8
611 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
612 class ARGS_02,
613 class ARGS_03,
614 class ARGS_04,
615 class ARGS_05,
616 class ARGS_06,
617 class ARGS_07,
618 class ARGS_08>
619 void construct(ELEMENT_TYPE *address,
620 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
621 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
622 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
623 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
624 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
625 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
626 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
627 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
628 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08);
629#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 8
630
631#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 9
632 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
633 class ARGS_02,
634 class ARGS_03,
635 class ARGS_04,
636 class ARGS_05,
637 class ARGS_06,
638 class ARGS_07,
639 class ARGS_08,
640 class ARGS_09>
641 void construct(ELEMENT_TYPE *address,
642 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
643 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
644 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
645 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
646 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
647 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
648 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
649 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
650 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
651 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09);
652#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 9
653
654#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 10
655 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
656 class ARGS_02,
657 class ARGS_03,
658 class ARGS_04,
659 class ARGS_05,
660 class ARGS_06,
661 class ARGS_07,
662 class ARGS_08,
663 class ARGS_09,
664 class ARGS_10>
665 void construct(ELEMENT_TYPE *address,
666 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
667 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
668 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
669 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
670 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
671 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
672 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
673 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
674 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
675 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
676 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10);
677#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 10
678
679#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 11
680 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
681 class ARGS_02,
682 class ARGS_03,
683 class ARGS_04,
684 class ARGS_05,
685 class ARGS_06,
686 class ARGS_07,
687 class ARGS_08,
688 class ARGS_09,
689 class ARGS_10,
690 class ARGS_11>
691 void construct(ELEMENT_TYPE *address,
692 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
693 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
694 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
695 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
696 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
697 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
698 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
699 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
700 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
701 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
702 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
703 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11);
704#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 11
705
706#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 12
707 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
708 class ARGS_02,
709 class ARGS_03,
710 class ARGS_04,
711 class ARGS_05,
712 class ARGS_06,
713 class ARGS_07,
714 class ARGS_08,
715 class ARGS_09,
716 class ARGS_10,
717 class ARGS_11,
718 class ARGS_12>
719 void construct(ELEMENT_TYPE *address,
720 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
721 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
722 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
723 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
724 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
725 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
726 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
727 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
728 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
729 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
730 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
731 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
732 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12);
733#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 12
734
735#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 13
736 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
737 class ARGS_02,
738 class ARGS_03,
739 class ARGS_04,
740 class ARGS_05,
741 class ARGS_06,
742 class ARGS_07,
743 class ARGS_08,
744 class ARGS_09,
745 class ARGS_10,
746 class ARGS_11,
747 class ARGS_12,
748 class ARGS_13>
749 void construct(ELEMENT_TYPE *address,
750 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
751 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
752 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
753 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
754 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
755 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
756 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
757 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
758 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
759 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
760 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
761 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
762 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
763 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13);
764#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 13
765
766#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 14
767 template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
768 class ARGS_02,
769 class ARGS_03,
770 class ARGS_04,
771 class ARGS_05,
772 class ARGS_06,
773 class ARGS_07,
774 class ARGS_08,
775 class ARGS_09,
776 class ARGS_10,
777 class ARGS_11,
778 class ARGS_12,
779 class ARGS_13,
780 class ARGS_14>
781 void construct(ELEMENT_TYPE *address,
782 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
783 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
784 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
785 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
786 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
787 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
788 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
789 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
790 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
791 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
792 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
793 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
794 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
795 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13,
796 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) arguments_14);
797#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_A >= 14
798
799#else
800// The generated code below is a workaround for the absence of perfect
801// forwarding in some compilers.
802
803 template <class ELEMENT_TYPE, class ARG1, class... ARGS>
804 void construct(ELEMENT_TYPE *address,
805 ARG1& argument1,
806 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... arguments);
807 template <class ELEMENT_TYPE, class ARG1, class... ARGS>
808 void construct(ELEMENT_TYPE *address,
809 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
810 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... arguments);
811// }}} END GENERATED CODE
812#endif
813
814 /// Call the `TYPE` destructor for the object pointed to by the
815 /// specified `address`. Do not directly deallocate any memory.
816 template <class ELEMENT_TYPE>
817 void destroy(ELEMENT_TYPE *address);
818
819 // ACCESSORS
820
821 /// Return the address of the object referred to by the specified `x`
822 /// reference, even if the (template parameter) `TYPE` overloads the
823 /// unary `operator&`.
824 pointer address(reference x) const;
825 const_pointer address(const_reference x) const;
826
827 /// Return the maximum number of elements of (template parameter) `TYPE`
828 /// that can be allocated using this allocator. Note that there is no
829 /// guarantee that attempts at allocating fewer elements than the value
830 /// returned by @ref max_size will not throw.
831 BSLS_KEYWORD_CONSTEXPR
832 size_type max_size() const;
833
834 /// Return a pointer to the mechanism object to which this proxy
835 /// forwards allocation and deallocation calls.
836 BloombergLP::bslma::Allocator *mechanism() const;
837
838 /// Return a default-constructed allocator.
839 allocator select_on_container_copy_construction() const;
840};
841
842 // =====================
843 // class allocator<void>
844 // =====================
845
846/// Specialization of `allocator<T>` where `T` is `void`. Does not contain
847/// members that are unrepresentable for `void`. Note that this
848/// specialization may be removed in the future. Use `allocator<>` or
849/// `allocator<char>` instead.
850template <>
851class allocator<void>
852 : public allocator<BloombergLP::bslma::BslAllocator_Voidish>
853{
854
855 // PRIVATE TYPES
856 typedef allocator<BloombergLP::bslma::BslAllocator_Voidish> Base;
857
858 // NOT DEFINED
859 void allocate(); // Hide name inherited from base class
860 void deallocate(); // Hide name inherited from base class
861 void construct(); // Hide name inherited from base class
862 void destroy(); // Hide name inherited from base class
863 void max_size(int); // Hide name inherited from base class
864
865 public:
866 // TRAITS
867 // Note that `allocator` is not trivially copyable because its assignment
868 // operator is not trivial.
869 BSLMF_NESTED_TRAIT_DECLARATION(allocator,
870 BloombergLP::bslmf::IsBitwiseCopyable);
871 BSLMF_NESTED_TRAIT_DECLARATION(allocator,
872 BloombergLP::bslmf::IsBitwiseEqualityComparable);
873
874 // PUBLIC TYPES
875 typedef void *pointer;
876 typedef const void *const_pointer;
877 typedef void *void_pointer;
878 typedef const void *const_void_pointer;
879 typedef void value_type;
880
881 // CREATORS
882
883 /// Create a proxy object that will forward allocation calls to the
884 /// object pointed to by `bslma::Default::defaultAllocator()`.
885 /// Postcondition:
886 /// @code
887 /// this->mechanism() == bslma::Default::defaultAllocator();
888 /// @endcode
889 allocator();
890
891 /// Convert a `bslma::Allocator` pointer to an `allocator` object that
892 /// forwards allocation calls to the object pointed to by the specified
893 /// `mechanism`. If `mechanism` is 0, then the currently installed
894 /// default allocator is used instead. Postcondition:
895 /// @code
896 /// this->mechanism() == bslma::Default::allocator(mechanism);
897 /// @endcode
898 allocator(BloombergLP::bslma::Allocator *mechanism); // IMPLICIT
899
900#ifdef BSLS_COMPILERFEATURES_SUPPORT_DEFAULTED_FUNCTIONS
901 allocator(const allocator& original) BSLS_KEYWORD_NOEXCEPT = default;
902#else
903 allocator(const allocator& original) BSLS_KEYWORD_NOEXCEPT;
904#endif
905 /// Create a proxy object sharing the same mechanism object as the
906 /// specified `original`. The newly constructed allocator will compare
907 /// equal to `original`, even though they may be instantiated on
908 /// different types. Postcondition:
909 /// @code
910 /// this->mechanism() == original.mechanism();
911 /// @endcode
912 template <class ANY_TYPE>
913 allocator(const allocator<ANY_TYPE>& original) BSLS_KEYWORD_NOEXCEPT;
914
915 /// Destroy this object. Note that this does not delete the object
916 /// pointed to by `mechanism()`. Also note that this method's
917 /// definition is compiler generated.
918 ~allocator();
919
920 // MANIPULATORS
921 allocator& operator=(const allocator& rhs) = default;
922
923 // ACCESSORS
924
925 /// Return a default-constructed allocator.
926 allocator select_on_container_copy_construction() const;
927};
928
929 // ========================================
930 // class allocator_traits<allocator<TYPE> >
931 // ========================================
932
933/// This `struct` template provides a specialization of the
934/// `allocator_traits` class template for `bsl::allocator`. This
935/// specialization is not strictly necessary, but its presence speeds up
936/// compliation by bypassing a significant amount of metaprogramming.
937template <class TYPE>
938struct allocator_traits<allocator<TYPE> > {
939
940 // PUBLIC TYPES
941 typedef allocator<TYPE> allocator_type;
942 typedef TYPE value_type;
943
944 typedef typename allocator_type::pointer pointer;
945 typedef typename allocator_type::const_pointer const_pointer;
946 typedef typename allocator_type::void_pointer void_pointer;
947 typedef typename allocator_type::const_void_pointer const_void_pointer;
948 typedef typename allocator_type::difference_type difference_type;
949 typedef typename allocator_type::size_type size_type;
950
951#ifdef BSLS_COMPILERFEATURES_SUPPORT_ALIAS_TEMPLATES
952 template <class ELEMENT_TYPE>
953 using rebind_alloc = allocator<ELEMENT_TYPE>;
954
955 template <class ELEMENT_TYPE>
956 using rebind_traits = allocator_traits<allocator<ELEMENT_TYPE> >;
957#else
958 template <class ELEMENT_TYPE>
959 struct rebind_alloc : allocator<ELEMENT_TYPE> {
960 rebind_alloc()
961 : allocator<ELEMENT_TYPE>()
962 {
963 }
964
965 // Convert from anything that can be used to cosntruct the base type.
966 // This might be better if SFINAE-ed out using `is_convertible`, but
967 // stressing older compilers more seems unwise.
968 template <typename ARG>
969 rebind_alloc(const ARG& allocatorArg)
970 : allocator<ELEMENT_TYPE>(allocatorArg)
971 {
972 }
973 };
974
975 template <class ELEMENT_TYPE>
976 struct rebind_traits : allocator_traits<allocator<ELEMENT_TYPE> > {
977 };
978#endif
979
980 static pointer allocate(allocator_type& m, size_type n)
981 {
982 return m.allocate(n);
983 }
984
985 static pointer allocate(allocator_type& m,
986 size_type n,
987 const_void_pointer /* hint */)
988 {
989 return m.allocate(n);
990 }
991
992 static void deallocate(allocator_type& m, pointer p, size_type n)
993 {
994 m.deallocate(p, n);
995 }
996
997 template <class TYPE2>
998 static void construct(allocator_type& m,
999 TYPE2 *p)
1000 {
1001 m.construct(p);
1002 }
1003
1004#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
1005// {{{ BEGIN GENERATED CODE
1006// Command line: sim_cpp11_features.pl bslma_bslallocator.h
1007#ifndef BSLMA_BSLALLOCATOR_VARIADIC_LIMIT
1008#define BSLMA_BSLALLOCATOR_VARIADIC_LIMIT 14
1009#endif
1010#ifndef BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B
1011#define BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B BSLMA_BSLALLOCATOR_VARIADIC_LIMIT
1012#endif
1013#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 0
1014 template <class TYPE2, class ARG1>
1015 static void construct(allocator_type& m,
1016 TYPE2 *p,
1017 ARG1& argument1)
1018 {
1019 m.construct(p,
1020 argument1);
1021 }
1022#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 0
1023
1024#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 1
1025 template <class TYPE2, class ARG1, class ARGS_01>
1026 static void construct(allocator_type& m,
1027 TYPE2 *p,
1028 ARG1& argument1,
1029 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01)
1030 {
1031 m.construct(p,
1032 argument1,
1033 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01));
1034 }
1035#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 1
1036
1037#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 2
1038 template <class TYPE2, class ARG1, class ARGS_01,
1039 class ARGS_02>
1040 static void construct(allocator_type& m,
1041 TYPE2 *p,
1042 ARG1& argument1,
1043 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1044 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02)
1045 {
1046 m.construct(p,
1047 argument1,
1048 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1049 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02));
1050 }
1051#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 2
1052
1053#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 3
1054 template <class TYPE2, class ARG1, class ARGS_01,
1055 class ARGS_02,
1056 class ARGS_03>
1057 static void construct(allocator_type& m,
1058 TYPE2 *p,
1059 ARG1& argument1,
1060 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1061 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1062 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03)
1063 {
1064 m.construct(p,
1065 argument1,
1066 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1067 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1068 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03));
1069 }
1070#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 3
1071
1072#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 4
1073 template <class TYPE2, class ARG1, class ARGS_01,
1074 class ARGS_02,
1075 class ARGS_03,
1076 class ARGS_04>
1077 static void construct(allocator_type& m,
1078 TYPE2 *p,
1079 ARG1& argument1,
1080 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1081 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1082 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1083 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04)
1084 {
1085 m.construct(p,
1086 argument1,
1087 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1088 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1089 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1090 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04));
1091 }
1092#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 4
1093
1094#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 5
1095 template <class TYPE2, class ARG1, class ARGS_01,
1096 class ARGS_02,
1097 class ARGS_03,
1098 class ARGS_04,
1099 class ARGS_05>
1100 static void construct(allocator_type& m,
1101 TYPE2 *p,
1102 ARG1& argument1,
1103 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1104 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1105 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1106 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1107 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05)
1108 {
1109 m.construct(p,
1110 argument1,
1111 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1112 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1113 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1114 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1115 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05));
1116 }
1117#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 5
1118
1119#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 6
1120 template <class TYPE2, class ARG1, class ARGS_01,
1121 class ARGS_02,
1122 class ARGS_03,
1123 class ARGS_04,
1124 class ARGS_05,
1125 class ARGS_06>
1126 static void construct(allocator_type& m,
1127 TYPE2 *p,
1128 ARG1& argument1,
1129 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1130 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1131 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1132 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1133 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1134 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06)
1135 {
1136 m.construct(p,
1137 argument1,
1138 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1139 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1140 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1141 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1142 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1143 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06));
1144 }
1145#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 6
1146
1147#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 7
1148 template <class TYPE2, class ARG1, class ARGS_01,
1149 class ARGS_02,
1150 class ARGS_03,
1151 class ARGS_04,
1152 class ARGS_05,
1153 class ARGS_06,
1154 class ARGS_07>
1155 static void construct(allocator_type& m,
1156 TYPE2 *p,
1157 ARG1& argument1,
1158 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1159 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1160 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1161 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1162 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1163 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1164 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07)
1165 {
1166 m.construct(p,
1167 argument1,
1168 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1169 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1170 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1171 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1172 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1173 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1174 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07));
1175 }
1176#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 7
1177
1178#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 8
1179 template <class TYPE2, class ARG1, class ARGS_01,
1180 class ARGS_02,
1181 class ARGS_03,
1182 class ARGS_04,
1183 class ARGS_05,
1184 class ARGS_06,
1185 class ARGS_07,
1186 class ARGS_08>
1187 static void construct(allocator_type& m,
1188 TYPE2 *p,
1189 ARG1& argument1,
1190 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1191 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1192 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1193 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1194 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1195 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1196 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1197 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08)
1198 {
1199 m.construct(p,
1200 argument1,
1201 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1202 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1203 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1204 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1205 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1206 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1207 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1208 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08));
1209 }
1210#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 8
1211
1212#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 9
1213 template <class TYPE2, class ARG1, class ARGS_01,
1214 class ARGS_02,
1215 class ARGS_03,
1216 class ARGS_04,
1217 class ARGS_05,
1218 class ARGS_06,
1219 class ARGS_07,
1220 class ARGS_08,
1221 class ARGS_09>
1222 static void construct(allocator_type& m,
1223 TYPE2 *p,
1224 ARG1& argument1,
1225 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1226 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1227 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1228 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1229 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1230 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1231 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1232 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1233 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09)
1234 {
1235 m.construct(p,
1236 argument1,
1237 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1238 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1239 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1240 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1241 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1242 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1243 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1244 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1245 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09));
1246 }
1247#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 9
1248
1249#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 10
1250 template <class TYPE2, class ARG1, class ARGS_01,
1251 class ARGS_02,
1252 class ARGS_03,
1253 class ARGS_04,
1254 class ARGS_05,
1255 class ARGS_06,
1256 class ARGS_07,
1257 class ARGS_08,
1258 class ARGS_09,
1259 class ARGS_10>
1260 static void construct(allocator_type& m,
1261 TYPE2 *p,
1262 ARG1& argument1,
1263 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1264 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1265 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1266 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1267 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1268 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1269 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1270 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1271 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1272 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10)
1273 {
1274 m.construct(p,
1275 argument1,
1276 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1277 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1278 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1279 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1280 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1281 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1282 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1283 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1284 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1285 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10));
1286 }
1287#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 10
1288
1289#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 11
1290 template <class TYPE2, class ARG1, class ARGS_01,
1291 class ARGS_02,
1292 class ARGS_03,
1293 class ARGS_04,
1294 class ARGS_05,
1295 class ARGS_06,
1296 class ARGS_07,
1297 class ARGS_08,
1298 class ARGS_09,
1299 class ARGS_10,
1300 class ARGS_11>
1301 static void construct(allocator_type& m,
1302 TYPE2 *p,
1303 ARG1& argument1,
1304 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1305 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1306 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1307 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1308 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1309 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1310 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1311 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1312 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1313 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
1314 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11)
1315 {
1316 m.construct(p,
1317 argument1,
1318 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1319 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1320 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1321 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1322 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1323 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1324 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1325 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1326 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1327 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
1328 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11));
1329 }
1330#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 11
1331
1332#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 12
1333 template <class TYPE2, class ARG1, class ARGS_01,
1334 class ARGS_02,
1335 class ARGS_03,
1336 class ARGS_04,
1337 class ARGS_05,
1338 class ARGS_06,
1339 class ARGS_07,
1340 class ARGS_08,
1341 class ARGS_09,
1342 class ARGS_10,
1343 class ARGS_11,
1344 class ARGS_12>
1345 static void construct(allocator_type& m,
1346 TYPE2 *p,
1347 ARG1& argument1,
1348 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1349 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1350 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1351 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1352 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1353 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1354 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1355 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1356 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1357 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
1358 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
1359 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12)
1360 {
1361 m.construct(p,
1362 argument1,
1363 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1364 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1365 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1366 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1367 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1368 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1369 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1370 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1371 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1372 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
1373 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
1374 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12));
1375 }
1376#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 12
1377
1378#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 13
1379 template <class TYPE2, class ARG1, class ARGS_01,
1380 class ARGS_02,
1381 class ARGS_03,
1382 class ARGS_04,
1383 class ARGS_05,
1384 class ARGS_06,
1385 class ARGS_07,
1386 class ARGS_08,
1387 class ARGS_09,
1388 class ARGS_10,
1389 class ARGS_11,
1390 class ARGS_12,
1391 class ARGS_13>
1392 static void construct(allocator_type& m,
1393 TYPE2 *p,
1394 ARG1& argument1,
1395 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1396 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1397 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1398 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1399 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1400 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1401 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1402 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1403 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1404 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
1405 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
1406 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
1407 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13)
1408 {
1409 m.construct(p,
1410 argument1,
1411 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1412 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1413 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1414 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1415 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1416 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1417 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1418 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1419 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1420 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
1421 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
1422 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12),
1423 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, arguments_13));
1424 }
1425#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 13
1426
1427#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 14
1428 template <class TYPE2, class ARG1, class ARGS_01,
1429 class ARGS_02,
1430 class ARGS_03,
1431 class ARGS_04,
1432 class ARGS_05,
1433 class ARGS_06,
1434 class ARGS_07,
1435 class ARGS_08,
1436 class ARGS_09,
1437 class ARGS_10,
1438 class ARGS_11,
1439 class ARGS_12,
1440 class ARGS_13,
1441 class ARGS_14>
1442 static void construct(allocator_type& m,
1443 TYPE2 *p,
1444 ARG1& argument1,
1445 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1446 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1447 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1448 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1449 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1450 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1451 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1452 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1453 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1454 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
1455 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
1456 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
1457 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13,
1458 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) arguments_14)
1459 {
1460 m.construct(p,
1461 argument1,
1462 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1463 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1464 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1465 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1466 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1467 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1468 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1469 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1470 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1471 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
1472 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
1473 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12),
1474 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, arguments_13),
1475 BSLS_COMPILERFEATURES_FORWARD(ARGS_14, arguments_14));
1476 }
1477#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 14
1478
1479
1480#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 0
1481 template <class TYPE2, class ARG1>
1482 static void construct(allocator_type& m,
1483 TYPE2 *p,
1484 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1)
1485 {
1486 m.construct(p,
1487 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1));
1488 }
1489#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 0
1490
1491#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 1
1492 template <class TYPE2, class ARG1, class ARGS_01>
1493 static void construct(allocator_type& m,
1494 TYPE2 *p,
1495 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1496 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01)
1497 {
1498 m.construct(p,
1499 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1500 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01));
1501 }
1502#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 1
1503
1504#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 2
1505 template <class TYPE2, class ARG1, class ARGS_01,
1506 class ARGS_02>
1507 static void construct(allocator_type& m,
1508 TYPE2 *p,
1509 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1510 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1511 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02)
1512 {
1513 m.construct(p,
1514 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1515 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1516 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02));
1517 }
1518#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 2
1519
1520#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 3
1521 template <class TYPE2, class ARG1, class ARGS_01,
1522 class ARGS_02,
1523 class ARGS_03>
1524 static void construct(allocator_type& m,
1525 TYPE2 *p,
1526 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1527 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1528 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1529 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03)
1530 {
1531 m.construct(p,
1532 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1533 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1534 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1535 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03));
1536 }
1537#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 3
1538
1539#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 4
1540 template <class TYPE2, class ARG1, class ARGS_01,
1541 class ARGS_02,
1542 class ARGS_03,
1543 class ARGS_04>
1544 static void construct(allocator_type& m,
1545 TYPE2 *p,
1546 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1547 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1548 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1549 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1550 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04)
1551 {
1552 m.construct(p,
1553 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1554 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1555 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1556 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1557 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04));
1558 }
1559#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 4
1560
1561#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 5
1562 template <class TYPE2, class ARG1, class ARGS_01,
1563 class ARGS_02,
1564 class ARGS_03,
1565 class ARGS_04,
1566 class ARGS_05>
1567 static void construct(allocator_type& m,
1568 TYPE2 *p,
1569 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1570 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1571 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1572 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1573 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1574 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05)
1575 {
1576 m.construct(p,
1577 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1578 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1579 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1580 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1581 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1582 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05));
1583 }
1584#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 5
1585
1586#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 6
1587 template <class TYPE2, class ARG1, class ARGS_01,
1588 class ARGS_02,
1589 class ARGS_03,
1590 class ARGS_04,
1591 class ARGS_05,
1592 class ARGS_06>
1593 static void construct(allocator_type& m,
1594 TYPE2 *p,
1595 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1596 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1597 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1598 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1599 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1600 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1601 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06)
1602 {
1603 m.construct(p,
1604 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1605 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1606 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1607 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1608 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1609 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1610 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06));
1611 }
1612#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 6
1613
1614#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 7
1615 template <class TYPE2, class ARG1, class ARGS_01,
1616 class ARGS_02,
1617 class ARGS_03,
1618 class ARGS_04,
1619 class ARGS_05,
1620 class ARGS_06,
1621 class ARGS_07>
1622 static void construct(allocator_type& m,
1623 TYPE2 *p,
1624 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1625 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1626 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1627 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1628 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1629 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1630 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1631 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07)
1632 {
1633 m.construct(p,
1634 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1635 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1636 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1637 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1638 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1639 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1640 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1641 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07));
1642 }
1643#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 7
1644
1645#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 8
1646 template <class TYPE2, class ARG1, class ARGS_01,
1647 class ARGS_02,
1648 class ARGS_03,
1649 class ARGS_04,
1650 class ARGS_05,
1651 class ARGS_06,
1652 class ARGS_07,
1653 class ARGS_08>
1654 static void construct(allocator_type& m,
1655 TYPE2 *p,
1656 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1657 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1658 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1659 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1660 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1661 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1662 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1663 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1664 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08)
1665 {
1666 m.construct(p,
1667 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1668 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1669 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1670 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1671 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1672 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1673 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1674 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1675 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08));
1676 }
1677#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 8
1678
1679#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 9
1680 template <class TYPE2, class ARG1, class ARGS_01,
1681 class ARGS_02,
1682 class ARGS_03,
1683 class ARGS_04,
1684 class ARGS_05,
1685 class ARGS_06,
1686 class ARGS_07,
1687 class ARGS_08,
1688 class ARGS_09>
1689 static void construct(allocator_type& m,
1690 TYPE2 *p,
1691 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1692 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1693 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1694 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1695 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1696 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1697 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1698 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1699 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1700 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09)
1701 {
1702 m.construct(p,
1703 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1704 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1705 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1706 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1707 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1708 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1709 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1710 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1711 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1712 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09));
1713 }
1714#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 9
1715
1716#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 10
1717 template <class TYPE2, class ARG1, class ARGS_01,
1718 class ARGS_02,
1719 class ARGS_03,
1720 class ARGS_04,
1721 class ARGS_05,
1722 class ARGS_06,
1723 class ARGS_07,
1724 class ARGS_08,
1725 class ARGS_09,
1726 class ARGS_10>
1727 static void construct(allocator_type& m,
1728 TYPE2 *p,
1729 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1730 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1731 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1732 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1733 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1734 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1735 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1736 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1737 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1738 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1739 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10)
1740 {
1741 m.construct(p,
1742 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1743 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1744 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1745 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1746 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1747 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1748 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1749 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1750 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1751 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1752 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10));
1753 }
1754#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 10
1755
1756#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 11
1757 template <class TYPE2, class ARG1, class ARGS_01,
1758 class ARGS_02,
1759 class ARGS_03,
1760 class ARGS_04,
1761 class ARGS_05,
1762 class ARGS_06,
1763 class ARGS_07,
1764 class ARGS_08,
1765 class ARGS_09,
1766 class ARGS_10,
1767 class ARGS_11>
1768 static void construct(allocator_type& m,
1769 TYPE2 *p,
1770 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1771 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1772 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1773 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1774 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1775 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1776 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1777 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1778 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1779 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1780 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
1781 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11)
1782 {
1783 m.construct(p,
1784 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1785 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 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1793 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1794 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
1795 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11));
1796 }
1797#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 11
1798
1799#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 12
1800 template <class TYPE2, class ARG1, class ARGS_01,
1801 class ARGS_02,
1802 class ARGS_03,
1803 class ARGS_04,
1804 class ARGS_05,
1805 class ARGS_06,
1806 class ARGS_07,
1807 class ARGS_08,
1808 class ARGS_09,
1809 class ARGS_10,
1810 class ARGS_11,
1811 class ARGS_12>
1812 static void construct(allocator_type& m,
1813 TYPE2 *p,
1814 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1815 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1816 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1817 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1818 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1819 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1820 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1821 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1822 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1823 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1824 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
1825 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
1826 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12)
1827 {
1828 m.construct(p,
1829 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1830 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1831 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1832 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1833 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1834 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1835 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1836 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1837 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1838 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1839 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
1840 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
1841 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12));
1842 }
1843#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 12
1844
1845#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 13
1846 template <class TYPE2, class ARG1, class ARGS_01,
1847 class ARGS_02,
1848 class ARGS_03,
1849 class ARGS_04,
1850 class ARGS_05,
1851 class ARGS_06,
1852 class ARGS_07,
1853 class ARGS_08,
1854 class ARGS_09,
1855 class ARGS_10,
1856 class ARGS_11,
1857 class ARGS_12,
1858 class ARGS_13>
1859 static void construct(allocator_type& m,
1860 TYPE2 *p,
1861 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1862 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1863 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1864 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1865 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1866 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1867 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1868 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1869 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1870 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1871 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
1872 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
1873 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
1874 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13)
1875 {
1876 m.construct(p,
1877 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1878 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1879 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1880 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1881 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1882 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1883 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1884 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1885 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1886 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1887 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
1888 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
1889 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12),
1890 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, arguments_13));
1891 }
1892#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 13
1893
1894#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 14
1895 template <class TYPE2, class ARG1, class ARGS_01,
1896 class ARGS_02,
1897 class ARGS_03,
1898 class ARGS_04,
1899 class ARGS_05,
1900 class ARGS_06,
1901 class ARGS_07,
1902 class ARGS_08,
1903 class ARGS_09,
1904 class ARGS_10,
1905 class ARGS_11,
1906 class ARGS_12,
1907 class ARGS_13,
1908 class ARGS_14>
1909 static void construct(allocator_type& m,
1910 TYPE2 *p,
1911 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1912 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
1913 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
1914 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
1915 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
1916 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
1917 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
1918 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
1919 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
1920 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
1921 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
1922 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
1923 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
1924 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13,
1925 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) arguments_14)
1926 {
1927 m.construct(p,
1928 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1929 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
1930 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
1931 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
1932 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
1933 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
1934 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
1935 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
1936 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
1937 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
1938 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
1939 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
1940 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12),
1941 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, arguments_13),
1942 BSLS_COMPILERFEATURES_FORWARD(ARGS_14, arguments_14));
1943 }
1944#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_B >= 14
1945
1946#else
1947// The generated code below is a workaround for the absence of perfect
1948// forwarding in some compilers.
1949 template <class TYPE2, class ARG1, class... ARGS>
1950 static void construct(allocator_type& m,
1951 TYPE2 *p,
1952 ARG1& argument1,
1953 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... arguments)
1954 {
1955 m.construct(p,
1956 argument1,
1957 BSLS_COMPILERFEATURES_FORWARD(ARGS, arguments)...);
1958 }
1959
1960 template <class TYPE2, class ARG1, class... ARGS>
1961 static void construct(allocator_type& m,
1962 TYPE2 *p,
1963 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
1964 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... arguments)
1965 {
1966 m.construct(p,
1967 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
1968 BSLS_COMPILERFEATURES_FORWARD(ARGS, arguments)...);
1969 }
1970// }}} END GENERATED CODE
1971#endif
1972
1973 template <class ELEMENT_TYPE>
1974 static void destroy(allocator_type& m, ELEMENT_TYPE *p)
1975 {
1976 m.destroy(p);
1977 }
1978
1979 BSLS_KEYWORD_CONSTEXPR
1980 static size_type max_size(const allocator_type& m)
1981 {
1982 return m.max_size();
1983 }
1984
1985 // Allocator propagation traits
1986 static
1987 allocator_type select_on_container_copy_construction(const allocator_type&)
1988 {
1989 return allocator_type();
1990 }
1991
1992 typedef false_type is_always_equal;
1993
1994 typedef false_type propagate_on_container_copy_assignment;
1995
1996 typedef false_type propagate_on_container_move_assignment;
1997
1998 typedef false_type propagate_on_container_swap;
1999};
2000
2001
2002// ============================================================================
2003// INLINE FUNCTION DEFINITIONS
2004// ============================================================================
2005
2006 // ---------------
2007 // class allocator
2008 // ---------------
2009
2010// CREATORS
2011template <class TYPE>
2012inline
2013allocator<TYPE>::allocator()
2014: Base(BloombergLP::bslma::Default::defaultAllocator())
2015{
2016}
2017
2018template <class TYPE>
2019inline
2020allocator<TYPE>::allocator(BloombergLP::bslma::Allocator *mechanism)
2021: Base(BloombergLP::bslma::Default::allocator(mechanism))
2022{
2023}
2024
2025#ifndef BSLS_COMPILERFEATURES_SUPPORT_DEFAULTED_FUNCTIONS
2026// In C++11 and later, this copy constructor is defaulted.
2027template <class TYPE>
2028inline
2029allocator<TYPE>::allocator(const allocator& original) BSLS_KEYWORD_NOEXCEPT
2030: Base(original)
2031{
2032}
2033#endif
2034
2035template <class TYPE>
2036template <class ANY_TYPE>
2037inline
2038allocator<TYPE>::allocator(const allocator<ANY_TYPE>& original)
2039 BSLS_KEYWORD_NOEXCEPT
2040: Base(original)
2041{
2042}
2043
2044// MANIPULATORS
2045template <class TYPE>
2046inline
2047allocator<TYPE>&
2048allocator<TYPE>::operator=(const allocator& rhs)
2049{
2050 BSLS_REVIEW_OPT(rhs == *this &&
2051 "'bsl::allocator' objects cannot be assigned");
2052
2053 if (this != &rhs) {
2054 // As the base class does not support assignment, the only way to
2055 // change the mechanism is to destroy and re-create this object
2056 this->~allocator();
2057 return *::new(this) allocator(rhs);
2058 }
2059
2060 return *this;
2061}
2062
2063template <class TYPE>
2064inline
2065typename allocator<TYPE>::pointer
2066allocator<TYPE>::allocate(size_type n, const void * /* hint */)
2067{
2068 return Base::allocate(n);
2069}
2070
2071template <class TYPE>
2072inline
2073void allocator<TYPE>::deallocate(TYPE *p, std::size_t n)
2074{
2075 Base::deallocate(p, n);
2076}
2077
2078template <class TYPE>
2079template <class ELEMENT_TYPE>
2080inline
2081void allocator<TYPE>::construct(ELEMENT_TYPE *address)
2082{
2083 BloombergLP::bslma::ConstructionUtil::construct(address, *this);
2084}
2085
2086#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
2087// {{{ BEGIN GENERATED CODE
2088// Command line: sim_cpp11_features.pl bslma_bslallocator.h
2089#ifndef BSLMA_BSLALLOCATOR_VARIADIC_LIMIT
2090#define BSLMA_BSLALLOCATOR_VARIADIC_LIMIT 14
2091#endif
2092#ifndef BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C
2093#define BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C BSLMA_BSLALLOCATOR_VARIADIC_LIMIT
2094#endif
2095#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 0
2096template <class TYPE>
2097template <class ELEMENT_TYPE, class ARG1>
2098inline
2099void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2100 ARG1& argument1)
2101{
2102 BloombergLP::bslma::ConstructionUtil::construct(
2103 address,
2104 *this,
2105 argument1);
2106}
2107#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 0
2108
2109#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 1
2110template <class TYPE>
2111template <class ELEMENT_TYPE, class ARG1, class ARGS_01>
2112inline
2113void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2114 ARG1& argument1,
2115 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01)
2116{
2117 BloombergLP::bslma::ConstructionUtil::construct(
2118 address,
2119 *this,
2120 argument1,
2121 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01));
2122}
2123#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 1
2124
2125#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 2
2126template <class TYPE>
2127template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2128 class ARGS_02>
2129inline
2130void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2131 ARG1& argument1,
2132 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2133 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02)
2134{
2135 BloombergLP::bslma::ConstructionUtil::construct(
2136 address,
2137 *this,
2138 argument1,
2139 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2140 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02));
2141}
2142#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 2
2143
2144#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 3
2145template <class TYPE>
2146template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2147 class ARGS_02,
2148 class ARGS_03>
2149inline
2150void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2151 ARG1& argument1,
2152 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2153 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2154 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03)
2155{
2156 BloombergLP::bslma::ConstructionUtil::construct(
2157 address,
2158 *this,
2159 argument1,
2160 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2161 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2162 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03));
2163}
2164#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 3
2165
2166#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 4
2167template <class TYPE>
2168template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2169 class ARGS_02,
2170 class ARGS_03,
2171 class ARGS_04>
2172inline
2173void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2174 ARG1& argument1,
2175 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2176 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2177 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2178 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04)
2179{
2180 BloombergLP::bslma::ConstructionUtil::construct(
2181 address,
2182 *this,
2183 argument1,
2184 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2185 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2186 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2187 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04));
2188}
2189#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 4
2190
2191#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 5
2192template <class TYPE>
2193template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2194 class ARGS_02,
2195 class ARGS_03,
2196 class ARGS_04,
2197 class ARGS_05>
2198inline
2199void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2200 ARG1& argument1,
2201 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2202 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2203 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2204 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2205 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05)
2206{
2207 BloombergLP::bslma::ConstructionUtil::construct(
2208 address,
2209 *this,
2210 argument1,
2211 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2212 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2213 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2214 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2215 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05));
2216}
2217#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 5
2218
2219#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 6
2220template <class TYPE>
2221template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2222 class ARGS_02,
2223 class ARGS_03,
2224 class ARGS_04,
2225 class ARGS_05,
2226 class ARGS_06>
2227inline
2228void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2229 ARG1& argument1,
2230 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2231 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2232 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2233 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2234 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2235 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06)
2236{
2237 BloombergLP::bslma::ConstructionUtil::construct(
2238 address,
2239 *this,
2240 argument1,
2241 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2242 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2243 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2244 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2245 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2246 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06));
2247}
2248#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 6
2249
2250#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 7
2251template <class TYPE>
2252template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2253 class ARGS_02,
2254 class ARGS_03,
2255 class ARGS_04,
2256 class ARGS_05,
2257 class ARGS_06,
2258 class ARGS_07>
2259inline
2260void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2261 ARG1& argument1,
2262 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2263 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2264 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2265 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2266 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2267 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2268 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07)
2269{
2270 BloombergLP::bslma::ConstructionUtil::construct(
2271 address,
2272 *this,
2273 argument1,
2274 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2275 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2276 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2277 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2278 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2279 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2280 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07));
2281}
2282#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 7
2283
2284#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 8
2285template <class TYPE>
2286template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2287 class ARGS_02,
2288 class ARGS_03,
2289 class ARGS_04,
2290 class ARGS_05,
2291 class ARGS_06,
2292 class ARGS_07,
2293 class ARGS_08>
2294inline
2295void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2296 ARG1& argument1,
2297 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2298 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2299 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2300 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2301 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2302 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2303 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2304 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08)
2305{
2306 BloombergLP::bslma::ConstructionUtil::construct(
2307 address,
2308 *this,
2309 argument1,
2310 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2311 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2312 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2313 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2314 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2315 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2316 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2317 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08));
2318}
2319#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 8
2320
2321#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 9
2322template <class TYPE>
2323template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2324 class ARGS_02,
2325 class ARGS_03,
2326 class ARGS_04,
2327 class ARGS_05,
2328 class ARGS_06,
2329 class ARGS_07,
2330 class ARGS_08,
2331 class ARGS_09>
2332inline
2333void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2334 ARG1& argument1,
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 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2342 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
2343 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09)
2344{
2345 BloombergLP::bslma::ConstructionUtil::construct(
2346 address,
2347 *this,
2348 argument1,
2349 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2350 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2351 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2352 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2353 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2354 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2355 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2356 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
2357 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09));
2358}
2359#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 9
2360
2361#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 10
2362template <class TYPE>
2363template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2364 class ARGS_02,
2365 class ARGS_03,
2366 class ARGS_04,
2367 class ARGS_05,
2368 class ARGS_06,
2369 class ARGS_07,
2370 class ARGS_08,
2371 class ARGS_09,
2372 class ARGS_10>
2373inline
2374void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2375 ARG1& argument1,
2376 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2377 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2378 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2379 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2380 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2381 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2382 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2383 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
2384 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
2385 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10)
2386{
2387 BloombergLP::bslma::ConstructionUtil::construct(
2388 address,
2389 *this,
2390 argument1,
2391 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2392 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2393 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2394 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2395 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2396 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2397 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2398 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
2399 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
2400 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10));
2401}
2402#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 10
2403
2404#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 11
2405template <class TYPE>
2406template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2407 class ARGS_02,
2408 class ARGS_03,
2409 class ARGS_04,
2410 class ARGS_05,
2411 class ARGS_06,
2412 class ARGS_07,
2413 class ARGS_08,
2414 class ARGS_09,
2415 class ARGS_10,
2416 class ARGS_11>
2417inline
2418void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2419 ARG1& argument1,
2420 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2421 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2422 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2423 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2424 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2425 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2426 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2427 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
2428 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
2429 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
2430 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11)
2431{
2432 BloombergLP::bslma::ConstructionUtil::construct(
2433 address,
2434 *this,
2435 argument1,
2436 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2437 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2438 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2439 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2440 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2441 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2442 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2443 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
2444 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
2445 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
2446 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11));
2447}
2448#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 11
2449
2450#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 12
2451template <class TYPE>
2452template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2453 class ARGS_02,
2454 class ARGS_03,
2455 class ARGS_04,
2456 class ARGS_05,
2457 class ARGS_06,
2458 class ARGS_07,
2459 class ARGS_08,
2460 class ARGS_09,
2461 class ARGS_10,
2462 class ARGS_11,
2463 class ARGS_12>
2464inline
2465void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2466 ARG1& argument1,
2467 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2468 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2469 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2470 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2471 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2472 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2473 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2474 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
2475 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
2476 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
2477 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
2478 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12)
2479{
2480 BloombergLP::bslma::ConstructionUtil::construct(
2481 address,
2482 *this,
2483 argument1,
2484 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2485 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2486 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2487 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2488 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2489 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2490 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2491 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
2492 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
2493 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
2494 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
2495 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12));
2496}
2497#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 12
2498
2499#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 13
2500template <class TYPE>
2501template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2502 class ARGS_02,
2503 class ARGS_03,
2504 class ARGS_04,
2505 class ARGS_05,
2506 class ARGS_06,
2507 class ARGS_07,
2508 class ARGS_08,
2509 class ARGS_09,
2510 class ARGS_10,
2511 class ARGS_11,
2512 class ARGS_12,
2513 class ARGS_13>
2514inline
2515void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2516 ARG1& argument1,
2517 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2518 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2519 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2520 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2521 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2522 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2523 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2524 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
2525 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
2526 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
2527 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
2528 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
2529 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13)
2530{
2531 BloombergLP::bslma::ConstructionUtil::construct(
2532 address,
2533 *this,
2534 argument1,
2535 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2536 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2537 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2538 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2539 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2540 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2541 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2542 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
2543 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
2544 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
2545 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
2546 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12),
2547 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, arguments_13));
2548}
2549#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 13
2550
2551#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 14
2552template <class TYPE>
2553template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2554 class ARGS_02,
2555 class ARGS_03,
2556 class ARGS_04,
2557 class ARGS_05,
2558 class ARGS_06,
2559 class ARGS_07,
2560 class ARGS_08,
2561 class ARGS_09,
2562 class ARGS_10,
2563 class ARGS_11,
2564 class ARGS_12,
2565 class ARGS_13,
2566 class ARGS_14>
2567inline
2568void allocator<TYPE>::construct(ELEMENT_TYPE *address,
2569 ARG1& argument1,
2570 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2571 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2572 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2573 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2574 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2575 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2576 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2577 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
2578 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
2579 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
2580 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
2581 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
2582 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13,
2583 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) arguments_14)
2584{
2585 BloombergLP::bslma::ConstructionUtil::construct(
2586 address,
2587 *this,
2588 argument1,
2589 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2590 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2591 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2592 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2593 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2594 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2595 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2596 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
2597 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
2598 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
2599 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
2600 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12),
2601 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, arguments_13),
2602 BSLS_COMPILERFEATURES_FORWARD(ARGS_14, arguments_14));
2603}
2604#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 14
2605
2606
2607#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 0
2608template <class TYPE>
2609template <class ELEMENT_TYPE, class ARG1>
2610inline
2611void allocator<TYPE>::construct(
2612 ELEMENT_TYPE *address,
2613 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1)
2614{
2615 BloombergLP::bslma::ConstructionUtil::construct(
2616 address,
2617 *this,
2618 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1));
2619}
2620#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 0
2621
2622#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 1
2623template <class TYPE>
2624template <class ELEMENT_TYPE, class ARG1, class ARGS_01>
2625inline
2626void allocator<TYPE>::construct(
2627 ELEMENT_TYPE *address,
2628 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2629 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01)
2630{
2631 BloombergLP::bslma::ConstructionUtil::construct(
2632 address,
2633 *this,
2634 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2635 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01));
2636}
2637#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 1
2638
2639#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 2
2640template <class TYPE>
2641template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2642 class ARGS_02>
2643inline
2644void allocator<TYPE>::construct(
2645 ELEMENT_TYPE *address,
2646 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2647 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2648 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02)
2649{
2650 BloombergLP::bslma::ConstructionUtil::construct(
2651 address,
2652 *this,
2653 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2654 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2655 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02));
2656}
2657#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 2
2658
2659#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 3
2660template <class TYPE>
2661template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2662 class ARGS_02,
2663 class ARGS_03>
2664inline
2665void allocator<TYPE>::construct(
2666 ELEMENT_TYPE *address,
2667 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2668 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2669 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2670 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03)
2671{
2672 BloombergLP::bslma::ConstructionUtil::construct(
2673 address,
2674 *this,
2675 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2676 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2677 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2678 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03));
2679}
2680#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 3
2681
2682#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 4
2683template <class TYPE>
2684template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2685 class ARGS_02,
2686 class ARGS_03,
2687 class ARGS_04>
2688inline
2689void allocator<TYPE>::construct(
2690 ELEMENT_TYPE *address,
2691 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2692 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2693 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2694 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2695 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04)
2696{
2697 BloombergLP::bslma::ConstructionUtil::construct(
2698 address,
2699 *this,
2700 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2701 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2702 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2703 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2704 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04));
2705}
2706#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 4
2707
2708#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 5
2709template <class TYPE>
2710template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2711 class ARGS_02,
2712 class ARGS_03,
2713 class ARGS_04,
2714 class ARGS_05>
2715inline
2716void allocator<TYPE>::construct(
2717 ELEMENT_TYPE *address,
2718 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2719 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2720 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2721 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2722 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2723 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05)
2724{
2725 BloombergLP::bslma::ConstructionUtil::construct(
2726 address,
2727 *this,
2728 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2729 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2730 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2731 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2732 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2733 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05));
2734}
2735#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 5
2736
2737#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 6
2738template <class TYPE>
2739template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2740 class ARGS_02,
2741 class ARGS_03,
2742 class ARGS_04,
2743 class ARGS_05,
2744 class ARGS_06>
2745inline
2746void allocator<TYPE>::construct(
2747 ELEMENT_TYPE *address,
2748 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2749 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2750 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2751 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2752 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2753 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2754 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06)
2755{
2756 BloombergLP::bslma::ConstructionUtil::construct(
2757 address,
2758 *this,
2759 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2760 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2761 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2762 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2763 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2764 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2765 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06));
2766}
2767#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 6
2768
2769#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 7
2770template <class TYPE>
2771template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2772 class ARGS_02,
2773 class ARGS_03,
2774 class ARGS_04,
2775 class ARGS_05,
2776 class ARGS_06,
2777 class ARGS_07>
2778inline
2779void allocator<TYPE>::construct(
2780 ELEMENT_TYPE *address,
2781 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2782 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2783 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2784 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2785 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2786 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2787 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2788 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07)
2789{
2790 BloombergLP::bslma::ConstructionUtil::construct(
2791 address,
2792 *this,
2793 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2794 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2795 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2796 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2797 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2798 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2799 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2800 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07));
2801}
2802#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 7
2803
2804#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 8
2805template <class TYPE>
2806template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2807 class ARGS_02,
2808 class ARGS_03,
2809 class ARGS_04,
2810 class ARGS_05,
2811 class ARGS_06,
2812 class ARGS_07,
2813 class ARGS_08>
2814inline
2815void allocator<TYPE>::construct(
2816 ELEMENT_TYPE *address,
2817 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2818 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2819 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2820 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2821 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2822 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2823 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2824 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2825 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08)
2826{
2827 BloombergLP::bslma::ConstructionUtil::construct(
2828 address,
2829 *this,
2830 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2831 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2832 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2833 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2834 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2835 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2836 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2837 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2838 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08));
2839}
2840#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 8
2841
2842#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 9
2843template <class TYPE>
2844template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2845 class ARGS_02,
2846 class ARGS_03,
2847 class ARGS_04,
2848 class ARGS_05,
2849 class ARGS_06,
2850 class ARGS_07,
2851 class ARGS_08,
2852 class ARGS_09>
2853inline
2854void allocator<TYPE>::construct(
2855 ELEMENT_TYPE *address,
2856 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2857 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2858 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2859 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2860 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2861 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2862 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2863 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2864 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
2865 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09)
2866{
2867 BloombergLP::bslma::ConstructionUtil::construct(
2868 address,
2869 *this,
2870 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2871 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2872 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2873 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2874 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2875 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2876 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2877 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2878 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
2879 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09));
2880}
2881#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 9
2882
2883#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 10
2884template <class TYPE>
2885template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2886 class ARGS_02,
2887 class ARGS_03,
2888 class ARGS_04,
2889 class ARGS_05,
2890 class ARGS_06,
2891 class ARGS_07,
2892 class ARGS_08,
2893 class ARGS_09,
2894 class ARGS_10>
2895inline
2896void allocator<TYPE>::construct(
2897 ELEMENT_TYPE *address,
2898 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2899 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2900 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2901 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2902 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2903 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2904 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2905 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2906 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
2907 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
2908 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10)
2909{
2910 BloombergLP::bslma::ConstructionUtil::construct(
2911 address,
2912 *this,
2913 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2914 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2915 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2916 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2917 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2918 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2919 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2920 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2921 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
2922 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
2923 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10));
2924}
2925#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 10
2926
2927#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 11
2928template <class TYPE>
2929template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2930 class ARGS_02,
2931 class ARGS_03,
2932 class ARGS_04,
2933 class ARGS_05,
2934 class ARGS_06,
2935 class ARGS_07,
2936 class ARGS_08,
2937 class ARGS_09,
2938 class ARGS_10,
2939 class ARGS_11>
2940inline
2941void allocator<TYPE>::construct(
2942 ELEMENT_TYPE *address,
2943 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2944 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2945 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2946 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2947 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2948 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2949 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2950 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2951 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
2952 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
2953 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
2954 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11)
2955{
2956 BloombergLP::bslma::ConstructionUtil::construct(
2957 address,
2958 *this,
2959 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
2960 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
2961 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
2962 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
2963 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
2964 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
2965 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
2966 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
2967 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
2968 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
2969 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
2970 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11));
2971}
2972#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 11
2973
2974#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 12
2975template <class TYPE>
2976template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
2977 class ARGS_02,
2978 class ARGS_03,
2979 class ARGS_04,
2980 class ARGS_05,
2981 class ARGS_06,
2982 class ARGS_07,
2983 class ARGS_08,
2984 class ARGS_09,
2985 class ARGS_10,
2986 class ARGS_11,
2987 class ARGS_12>
2988inline
2989void allocator<TYPE>::construct(
2990 ELEMENT_TYPE *address,
2991 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
2992 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
2993 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
2994 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
2995 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
2996 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
2997 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
2998 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
2999 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
3000 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
3001 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
3002 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
3003 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12)
3004{
3005 BloombergLP::bslma::ConstructionUtil::construct(
3006 address,
3007 *this,
3008 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
3009 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
3010 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
3011 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
3012 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
3013 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
3014 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
3015 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
3016 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
3017 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
3018 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
3019 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
3020 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12));
3021}
3022#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 12
3023
3024#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 13
3025template <class TYPE>
3026template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
3027 class ARGS_02,
3028 class ARGS_03,
3029 class ARGS_04,
3030 class ARGS_05,
3031 class ARGS_06,
3032 class ARGS_07,
3033 class ARGS_08,
3034 class ARGS_09,
3035 class ARGS_10,
3036 class ARGS_11,
3037 class ARGS_12,
3038 class ARGS_13>
3039inline
3040void allocator<TYPE>::construct(
3041 ELEMENT_TYPE *address,
3042 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
3043 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
3044 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
3045 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
3046 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
3047 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
3048 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
3049 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
3050 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
3051 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
3052 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
3053 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
3054 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
3055 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13)
3056{
3057 BloombergLP::bslma::ConstructionUtil::construct(
3058 address,
3059 *this,
3060 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
3061 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
3062 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
3063 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
3064 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
3065 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
3066 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
3067 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
3068 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
3069 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
3070 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
3071 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
3072 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12),
3073 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, arguments_13));
3074}
3075#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 13
3076
3077#if BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 14
3078template <class TYPE>
3079template <class ELEMENT_TYPE, class ARG1, class ARGS_01,
3080 class ARGS_02,
3081 class ARGS_03,
3082 class ARGS_04,
3083 class ARGS_05,
3084 class ARGS_06,
3085 class ARGS_07,
3086 class ARGS_08,
3087 class ARGS_09,
3088 class ARGS_10,
3089 class ARGS_11,
3090 class ARGS_12,
3091 class ARGS_13,
3092 class ARGS_14>
3093inline
3094void allocator<TYPE>::construct(
3095 ELEMENT_TYPE *address,
3096 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
3097 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) arguments_01,
3098 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) arguments_02,
3099 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) arguments_03,
3100 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) arguments_04,
3101 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) arguments_05,
3102 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) arguments_06,
3103 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) arguments_07,
3104 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) arguments_08,
3105 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) arguments_09,
3106 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) arguments_10,
3107 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) arguments_11,
3108 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) arguments_12,
3109 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) arguments_13,
3110 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) arguments_14)
3111{
3112 BloombergLP::bslma::ConstructionUtil::construct(
3113 address,
3114 *this,
3115 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
3116 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, arguments_01),
3117 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, arguments_02),
3118 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, arguments_03),
3119 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, arguments_04),
3120 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, arguments_05),
3121 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, arguments_06),
3122 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, arguments_07),
3123 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, arguments_08),
3124 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, arguments_09),
3125 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, arguments_10),
3126 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, arguments_11),
3127 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, arguments_12),
3128 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, arguments_13),
3129 BSLS_COMPILERFEATURES_FORWARD(ARGS_14, arguments_14));
3130}
3131#endif // BSLMA_BSLALLOCATOR_VARIADIC_LIMIT_C >= 14
3132
3133#else
3134// The generated code below is a workaround for the absence of perfect
3135// forwarding in some compilers.
3136template <class TYPE>
3137template <class ELEMENT_TYPE, class ARG1, class... ARGS>
3138inline
3139void allocator<TYPE>::construct(ELEMENT_TYPE *address,
3140 ARG1& argument1,
3141 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... arguments)
3142{
3143 BloombergLP::bslma::ConstructionUtil::construct(
3144 address,
3145 *this,
3146 argument1,
3147 BSLS_COMPILERFEATURES_FORWARD(ARGS, arguments)...);
3148}
3149
3150template <class TYPE>
3151template <class ELEMENT_TYPE, class ARG1, class... ARGS>
3152inline
3153void allocator<TYPE>::construct(
3154 ELEMENT_TYPE *address,
3155 BSLS_COMPILERFEATURES_FORWARD_REF(ARG1) argument1,
3156 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... arguments)
3157{
3158 BloombergLP::bslma::ConstructionUtil::construct(
3159 address,
3160 *this,
3161 BSLS_COMPILERFEATURES_FORWARD(ARG1, argument1),
3162 BSLS_COMPILERFEATURES_FORWARD(ARGS, arguments)...);
3163}
3164// }}} END GENERATED CODE
3165#endif
3166
3167template <class TYPE>
3168template <class ELEMENT_TYPE>
3169inline
3170void allocator<TYPE>::destroy(ELEMENT_TYPE *address)
3171{
3172 BloombergLP::bslma::DestructionUtil::destroy(address);
3173}
3174
3175
3176// ACCESSORS
3177template <class TYPE>
3178inline
3179typename allocator<TYPE>::pointer
3180allocator<TYPE>::address(reference x) const
3181{
3182 return BloombergLP::bsls::Util::addressOf(x);
3183}
3184
3185template <class TYPE>
3186inline
3187typename allocator<TYPE>::const_pointer
3188allocator<TYPE>::address(const_reference x) const
3189{
3190 return BloombergLP::bsls::Util::addressOf(x);
3191}
3192
3193template <class TYPE>
3194BSLS_KEYWORD_CONSTEXPR inline
3195typename allocator<TYPE>::size_type allocator<TYPE>::max_size() const
3196{
3197 // Return the largest value, 'v', such that 'v * sizeof(T)' fits in a
3198 // 'size_type'.
3199
3200 BSLS_KEYWORD_CONSTEXPR
3201 const size_type MAX_NUM_BYTES = ~size_type(0);
3202 BSLS_KEYWORD_CONSTEXPR
3203 const size_type MAX_NUM_ELEMENTS = MAX_NUM_BYTES / sizeof(TYPE);
3204
3205 return MAX_NUM_ELEMENTS;
3206}
3207
3208template <class TYPE>
3209inline
3210BloombergLP::bslma::Allocator *allocator<TYPE>::mechanism() const
3211{
3212 return static_cast<BloombergLP::bslma::Allocator *>(this->resource());
3213}
3214
3215template <class TYPE>
3216inline
3217allocator<TYPE> allocator<TYPE>::select_on_container_copy_construction() const
3218{
3219 return allocator();
3220}
3221
3222
3223 // ---------------------
3224 // class allocator<void>
3225 // ---------------------
3226
3227// CREATORS
3228inline
3229allocator<void>::allocator()
3230{
3231}
3232
3233inline
3234allocator<void>::allocator(BloombergLP::bslma::Allocator *mechanism)
3235: Base(mechanism)
3236{
3237}
3238
3239#ifndef BSLS_COMPILERFEATURES_SUPPORT_DEFAULTED_FUNCTIONS
3240// In C++11 and later, this copy constructor is defaulted.
3241inline
3242allocator<void>::allocator(const allocator& original) BSLS_KEYWORD_NOEXCEPT
3243: Base(original)
3244{
3245}
3246#endif
3247
3248template <class ANY_TYPE>
3249inline
3250allocator<void>::allocator(const allocator<ANY_TYPE>& original)
3251 BSLS_KEYWORD_NOEXCEPT
3252: Base(original)
3253{
3254}
3255
3256inline
3257allocator<void> allocator<void>::select_on_container_copy_construction() const
3258{
3259 return allocator<void>();
3260}
3261
3262} // close namespace bsl
3263
3264#if BSLS_PLATFORM_CMP_MSVC
3265// As of MSVC 19.30.30709 (2022), the following workaround is still needed.
3266// When a fix is released, the above '#if' condition should be updated to apply
3267// only to versions before the fixed one.
3268
3269// These equality and inequality operators should be unnecessary because they
3270// automatically fall back on @ref polymoprhic_allocator . However an odd bug in
3271// MSVC causes it, in the presence of '<bslma_convertibleallocator.h>' to
3272// include the 'bslma::ConvertibleAllocator' "hidden friend" equality operators
3273// in the the lookup set even if neither argument is 'ConvertibleAllocator',
3274// thus making 'operator==' ambiguous when comparing 'bsl::allocator' to
3275// 'bslma::Allocator *'. Strangely 'using namespace bslma' suppresses this
3276// bug, but it is not practical to require clients to do that. The operators
3277// below quash this ambiguity. Although harmless for other platforms, they are
3278// compiled only for affected versions of MSVC and are considered an
3279// implementation detail (not part of the interface for 'bsl::allocator').
3280
3281template <class TYPE>
3282inline
3283bool operator==(const bsl::allocator<TYPE>& a,
3284 BloombergLP::bslma::Allocator *b)
3285{
3286 return a.resource() == b || a.resource()->is_equal(*b);
3287}
3288
3289template <class TYPE>
3290inline
3291bool operator==(BloombergLP::bslma::Allocator *a,
3292 const bsl::allocator<TYPE>& b)
3293{
3294 return a == b.resource() || a->is_equal(*b.resource());
3295}
3296
3297template <class TYPE>
3298inline
3299bool operator!=(const bsl::allocator<TYPE>& a,
3300 BloombergLP::bslma::Allocator *b)
3301{
3302 return ! (a.resource() == b || a.resource()->is_equal(*b));
3303}
3304
3305template <class TYPE>
3306inline
3307bool operator!=(BloombergLP::bslma::Allocator *a,
3308 const bsl::allocator<TYPE>& b)
3309{
3310 return ! (a == b.resource() || a->is_equal(*b.resource()));
3311}
3312#endif
3313
3314// ============================================================================
3315// TYPE TRAITS
3316// ============================================================================
3317
3318
3319namespace bslma {
3320
3321/// An allocator is not *itself* an allocator-aware type, even though it is
3322/// convertible from `bsl::Allocator *`.
3323template <class TYPE>
3324struct UsesBslmaAllocator< ::bsl::allocator<TYPE> > : bsl::false_type {
3325};
3326
3327/// A `bsl::allocator` inherits its `allocate` method from a base class,
3328/// which causes `IsStdAllocator` to fail the auto-detected it.
3329template <class TYPE>
3330struct IsStdAllocator<bsl::allocator<TYPE> > : bsl::true_type {
3331};
3332
3333/// `bsl::allocator<void>` is not an allocator type, even though all other
3334/// instantiations are allocator types.
3335template <>
3336struct IsStdAllocator<bsl::allocator<void> > : bsl::false_type {
3337};
3338
3339} // close namespace bslma
3340
3341
3342#else // if ! defined(DEFINED_BSLMA_BSLALLOCATOR_H)
3343# error Not valid except when included from bslma_bslallocator.h
3344#endif // ! defined(COMPILING_BSLMA_BSLALLOCATOR_H)
3345
3346#endif // ! defined(INCLUDED_BSLMA_BSLALLOCATOR_CPP03)
3347
3348// ----------------------------------------------------------------------------
3349// Copyright 2013 Bloomberg Finance L.P.
3350//
3351// Licensed under the Apache License, Version 2.0 (the "License");
3352// you may not use this file except in compliance with the License.
3353// You may obtain a copy of the License at
3354//
3355// http://www.apache.org/licenses/LICENSE-2.0
3356//
3357// Unless required by applicable law or agreed to in writing, software
3358// distributed under the License is distributed on an "AS IS" BASIS,
3359// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
3360// See the License for the specific language governing permissions and
3361// limitations under the License.
3362// ----------------------------- END-OF-FILE ----------------------------------
3363
3364/** @} */
3365/** @} */
3366/** @} */
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
bsl::allocator::reference
value_type & reference
Definition bslma_bslallocator.h:597
bsl::allocator::mechanism
BloombergLP::bslma::Allocator * mechanism() const
Definition bslma_bslallocator.h:1126
bsl::allocator::destroy
void destroy(ELEMENT_TYPE *address)
Definition bslma_bslallocator.h:1086
bsl::allocator::const_pointer
BaseTraits::const_pointer const_pointer
Definition bslma_bslallocator.h:602
bsl::allocator::value_type
TYPE value_type
Definition bslma_bslallocator.h:596
bsl::allocator::const_reference
value_type const & const_reference
Definition bslma_bslallocator.h:598
bsl::allocator::pointer
BaseTraits::pointer pointer
Definition bslma_bslallocator.h:601
bsl::allocator::operator=
BSLMA_BSLALLOCATOR_DEPRECATE_ASSIGN allocator & operator=(const allocator &rhs)
Definition bslma_bslallocator.h:1014
bsl::allocator::deallocate
void deallocate(TYPE *p, std::size_t n=1)
Definition bslma_bslallocator.h:1039
bsl::allocator::construct
void construct(ELEMENT_TYPE *address)
Definition bslma_bslallocator.h:1047
bsl::allocator::allocate
BSLS_ANNOTATION_NODISCARD pointer allocate(size_type n, const void *hint=0)
Definition bslma_bslallocator.h:1032
bsl::allocator::void_pointer
BaseTraits::void_pointer void_pointer
Definition bslma_bslallocator.h:603
bsl::allocator::address
pointer address(reference x) const
Definition bslma_bslallocator.h:1096
bsl::allocator::select_on_container_copy_construction
allocator select_on_container_copy_construction() const
Return a default-constructed allocator.
Definition bslma_bslallocator.h:1133
bsl::allocator::const_void_pointer
BaseTraits::const_void_pointer const_void_pointer
Definition bslma_bslallocator.h:604
bsl::allocator::~allocator
~allocator()=default
bsl::allocator::difference_type
BaseTraits::difference_type difference_type
Definition bslma_bslallocator.h:600
bsl::allocator::max_size
BSLS_KEYWORD_CONSTEXPR size_type max_size() const
Definition bslma_bslallocator.h:1111
bsl::allocator::allocator
allocator()
Definition bslma_bslallocator.h:979
bsl::allocator::size_type
BaseTraits::size_type size_type
Definition bslma_bslallocator.h:599
bsl::memory_resource::is_equal
bool is_equal(const memory_resource &other) const BSLS_KEYWORD_NOEXCEPT
Definition bslma_memoryresource.h:554
bsl::polymorphic_allocator::resource
memory_resource * resource() const
Return the address of the memory resource supplied on construction.
Definition bslma_polymorphicallocator.h:1048
BSLMA_BSLALLOCATOR_DEPRECATE_ASSIGN
#define BSLMA_BSLALLOCATOR_DEPRECATE_ASSIGN
Definition bslma_bslallocator.h:547
BSLS_ANNOTATION_NODISCARD
#define BSLS_ANNOTATION_NODISCARD
Definition bsls_annotation.h:373
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
BSLS_KEYWORD_CONSTEXPR
#define BSLS_KEYWORD_CONSTEXPR
Definition bsls_keyword.h:588
BSLS_KEYWORD_NOEXCEPT
#define BSLS_KEYWORD_NOEXCEPT
Definition bsls_keyword.h:632
BSLS_REVIEW_OPT
#define BSLS_REVIEW_OPT(X)
Definition bsls_review.h:977
balb::operator!=
bool operator!=(const FileCleanerConfiguration &lhs, const FileCleanerConfiguration &rhs)
balb::operator==
bool operator==(const FileCleanerConfiguration &lhs, const FileCleanerConfiguration &rhs)
bsl
Definition bdlb_printmethods.h:283
bsl::false_type
integral_constant< bool, false > false_type
Definition bslmf_integralconstant.h:297
bslma
Definition balxml_encoderoptions.h:68
bsl::allocator::rebind::other
allocator< ANY_TYPE > other
Definition bslma_bslallocator.h:614
bsl::allocator_traits::rebind_alloc::rebind_alloc
rebind_alloc(const ARG &allocatorArg)
Definition bslma_allocatortraits.h:1193
bsl::allocator_traits::allocate
static pointer allocate(ALLOCATOR_TYPE &basicAllocator, size_type n)
Return basicAllocator.allocate(n).
Definition bslma_allocatortraits.h:1439
bsl::allocator_traits::const_pointer
BloombergLP::bslma::AllocatorTraits_ConstPointerType< ALLOCATOR_TYPE >::type const_pointer
Definition bslma_allocatortraits.h:1152
bsl::allocator_traits::void_pointer
BloombergLP::bslma::AllocatorTraits_VoidPointerType< ALLOCATOR_TYPE >::type void_pointer
Definition bslma_allocatortraits.h:1155
bsl::allocator_traits::propagate_on_container_copy_assignment
BloombergLP::bslma::AllocatorTraits_PropOnCopyAssign< ALLOCATOR_TYPE >::type propagate_on_container_copy_assignment
Definition bslma_allocatortraits.h:1297
bsl::allocator_traits::propagate_on_container_move_assignment
BloombergLP::bslma::AllocatorTraits_PropOnMoveAssign< ALLOCATOR_TYPE >::type propagate_on_container_move_assignment
Definition bslma_allocatortraits.h:1306
bsl::allocator_traits::select_on_container_copy_construction
static ALLOCATOR_TYPE select_on_container_copy_construction(const ALLOCATOR_TYPE &rhs)
Definition bslma_allocatortraits.h:1532
bsl::allocator_traits::size_type
BloombergLP::bslma::AllocatorTraits_SizeType< ALLOCATOR_TYPE >::type size_type
Definition bslma_allocatortraits.h:1165
bsl::allocator_traits::construct
static void construct(ALLOCATOR_TYPE &basicAllocator, ELEMENT_TYPE *elementAddr, Args &&... arguments)
Definition bslma_allocatortraits.h:1472
bsl::allocator_traits::max_size
static size_type max_size(const ALLOCATOR_TYPE &basicAllocator) BSLS_KEYWORD_NOEXCEPT
Definition bslma_allocatortraits.h:1515
bsl::allocator_traits::pointer
BloombergLP::bslma::AllocatorTraits_PointerType< ALLOCATOR_TYPE >::type pointer
Definition bslma_allocatortraits.h:1149
bsl::allocator_traits::destroy
static void destroy(ALLOCATOR_TYPE &basicAllocator, ELEMENT_TYPE *elementAddr)
Definition bslma_allocatortraits.h:1494
bsl::allocator_traits::is_always_equal
BloombergLP::bslma::AllocatorTraits_IsAlwaysEqual< ALLOCATOR_TYPE >::type is_always_equal
Definition bslma_allocatortraits.h:1288
bsl::allocator_traits::deallocate
static void deallocate(ALLOCATOR_TYPE &basicAllocator, pointer elementAddr, size_type n)
Definition bslma_allocatortraits.h:1458
bsl::allocator_traits::propagate_on_container_swap
BloombergLP::bslma::AllocatorTraits_PropOnSwap< ALLOCATOR_TYPE >::type propagate_on_container_swap
Definition bslma_allocatortraits.h:1315
bsl::allocator_traits::allocator_type
ALLOCATOR_TYPE allocator_type
Definition bslma_allocatortraits.h:1144
bsl::allocator_traits::const_void_pointer
BloombergLP::bslma::AllocatorTraits_ConstVoidPointerType< ALLOCATOR_TYPE >::type const_void_pointer
Definition bslma_allocatortraits.h:1158
bsl::allocator_traits::difference_type
BloombergLP::bslma::AllocatorTraits_DifferenceType< ALLOCATOR_TYPE >::type difference_type
Definition bslma_allocatortraits.h:1162
bsl::allocator_traits::value_type
ALLOCATOR_TYPE::value_type value_type
Definition bslma_allocatortraits.h:1145
bsl::integral_constant
Definition bslmf_integralconstant.h:244