BDE 4.39.x Production Release
Loading...
Searching...
No Matches
bslma_managedptr_cpp03.h
Go to the documentation of this file.
1/// @file bslma_managedptr_cpp03.h
2///
3/// The content of this file has been pre-processed for Doxygen.
4///
5
6
7// bslma_managedptr_cpp03.h -*-C++-*-
8
9// Automatically generated file. **DO NOT EDIT**
10
11#ifndef INCLUDED_BSLMA_MANAGEDPTR_CPP03
12#define INCLUDED_BSLMA_MANAGEDPTR_CPP03
13
14/// @defgroup bslma_managedptr_cpp03 bslma_managedptr_cpp03
15/// @brief Provide C++03 implementation for bslma_managedptr.h
16/// @addtogroup bsl
17/// @{
18/// @addtogroup bslma
19/// @{
20/// @addtogroup bslma_managedptr_cpp03
21/// @{
22///
23/// <h1> Outline </h1>
24/// * <a href="#bslma_managedptr_cpp03-purpose"> Purpose</a>
25/// * <a href="#bslma_managedptr_cpp03-classes"> Classes </a>
26/// * <a href="#bslma_managedptr_cpp03-description"> Description </a>
27///
28/// # Purpose {#bslma_managedptr_cpp03-purpose}
29/// Provide C++03 implementation for bslma_managedptr.h
30///
31/// # Classes {#bslma_managedptr_cpp03-classes}
32/// See bslma_managedptr.h for list of classes
33///
34/// @see bslma_managedptr
35///
36/// # Description {#bslma_managedptr_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 Mon May 11 14:26:38 2026
48/// Command line: sim_cpp11_features.pl bslma_managedptr.h
49/// @}
50/** @} */
51/** @} */
52
53/** @addtogroup bsl
54 * @{
55 */
56/** @addtogroup bslma
57 * @{
58 */
59/** @addtogroup bslma_managedptr_cpp03
60 * @{
61 */
62
63#ifdef COMPILING_BSLMA_MANAGEDPTR_H
64
65
66namespace bslma {
67
68 // ============================
69 // private class ManagedPtr_Ref
70 // ============================
71
72/// This class holds a managed pointer reference, returned by the implicit
73/// conversion operator in the class `ManagedPtr`. This class is used to
74/// allow the construction of managed pointers from temporary managed
75/// pointer objects, since temporaries cannot bind to the reference to a
76/// modifiable object used in the copy constructor and copy-assignment operator for `ManagedPtr`.
77///
78/// \note Note that while no members or methods of
79/// this class template depend on the specified `TARGET_TYPE`, it is
80/// important to carry this type into conversions to support passing
81/// ownership of `ManagedPtr_Members` pointers when assigning or
82/// constructing `ManagedPtr` objects.
83///
84/// See @ref bslma_managedptr_cpp03
85template <class TARGET_TYPE>
86class ManagedPtr_Ref {
87
88 // DATA
89 ManagedPtr_Members *d_base_p; // non-null pointer to the managed state of
90 // a 'ManagedPtr' object
91
92 TARGET_TYPE *d_cast_p; // safely-cast pointer to the referenced
93 // object
94
95 public:
96 // CREATORS
97
98 /// Create a `ManagedPtr_Ref` object having the specified `base` value
99 /// for its `base` attribute, and the specified `target` for its `target` attribute.
100 ///
101 /// \note Note that `target` (but not `base`) may be
102 /// null.
103 ManagedPtr_Ref(ManagedPtr_Members *base, TARGET_TYPE *target);
104
105 ManagedPtr_Ref(const ManagedPtr_Ref& original) = default;
106 // Create a 'ManagedPtr_Ref' object having the same 'd_base_p' value as
107 // the specified 'original'. Note that this trivial constructor's
108 // definition is compiler generated.
109
110 /// Destroy this object.
111 /// \note Note that the referenced managed object is
112 /// *not* destroyed.
113 ~ManagedPtr_Ref();
114
115 // MANIPULATORS
116 ManagedPtr_Ref& operator=(const ManagedPtr_Ref& original) = default;
117 // Create a 'ManagedPtr_Ref' object having the same 'd_base_p' as the
118 // specified 'original'. Note that this trivial copy-assignment
119 // operator's definition is compiler generated.
120
121 // ACCESSORS
122
123 /// Return a pointer to the managed state of a `ManagedPtr` object.
124 ManagedPtr_Members *base() const;
125
126 /// Return a pointer to the referenced object.
127 TARGET_TYPE *target() const;
128};
129
130 // =========================================
131 // private struct ManagedPtr_TraitConstraint
132 // =========================================
133
134/// This `struct` is an empty type that exists solely to enable constructor
135/// access to be constrained by type trait.
136///
137/// See @ref bslma_managedptr_cpp03
138struct ManagedPtr_TraitConstraint {
139};
140 // ================
141 // class ManagedPtr
142 // ================
143
144/// This class is a "smart pointer" that refers to a *target* object
145/// accessed via a pointer to the specified parameter type, `TARGET_TYPE`,
146/// and that supports sole ownership of a *managed* object that is
147/// potentially of a different type, and may be an entirely different object
148/// from the target object. A managed pointer ensures that the object it
149/// manages is destroyed when the managed pointer is destroyed (or
150/// re-assigned), using the "deleter" supplied along with the managed
151/// object. The target object referenced by a managed pointer may be
152/// accessed using either the `->` operator, or the dereference operator
153/// (`operator *`). The specified `TARGET_TYPE` may be `const`-qualified,
154/// but may not be `volatile`-qualified, nor may it be a reference type.
155///
156/// A managed pointer may be *empty*, in which case it neither refers to a
157/// target object nor owns a managed object. An empty managed pointer is
158/// the equivalent of a null pointer: Such a managed pointer is not
159/// de-referenceable, and tests as `false` in boolean expressions.
160///
161/// A managed pointer for which the managed object is not the same object as
162/// the target is said to *alias* the managed object (see the section
163/// "Aliasing" in the component-level documentation).
164///
165/// See @ref bslma_managedptr_cpp03
166template <class TARGET_TYPE>
167class ManagedPtr {
168
169 public:
170 // INTERFACE TYPES
171
172 /// Alias for a function-pointer type for functions used to destroy the
173 /// object managed by a `ManagedPtr` object.
174 typedef ManagedPtrDeleter::Deleter DeleterFunc;
175
176 /// Alias to the `TARGET_TYPE` template parameter.
177 typedef TARGET_TYPE element_type;
178
179 private:
180 // PRIVATE TYPES
181
182 /// `BoolType` is an alias for an unspecified type that is implicitly
183 /// convertible to `bool`, but will not promote to `int`. This (opaque)
184 /// type can be used as an "unspecified boolean type" for converting a
185 /// managed pointer to `bool` in contexts such as `if (mp) { ... }`
186 /// without actually having a conversion to `bool` or being less-than
187 /// comparable (either of which would also enable undesirable implicit
188 /// comparisons of managed pointers to `int` and less-than comparisons).
189 typedef typename bsls::UnspecifiedBool<ManagedPtr>::BoolType BoolType;
190
191 /// This `typedef` is a convenient alias for the utility associated with
192 /// movable references.
193 typedef bslmf::MovableRefUtil MoveUtil;
194
195 // DATA
196 ManagedPtr_Members d_members; // state managed by this object
197
198 // PRIVATE CLASS METHODS
199
200 /// Return the value of the specified `ptr` as a `void *`, after
201 /// stripping all `const` and `volatile` qualifiers from `TARGET_TYPE`.
202 /// This function avoids accidental type-safety errors when performing the necessary sequence of casts.
203 ///
204 /// \note Note that calling this function
205 /// implies a conversion of the calling pointer to `TARGET_TYPE *`,
206 /// which, in rare cases, may involve some adjustment of the pointer
207 /// value, e.g., in the case of multiple inheritance where `TARGET_TYPE`
208 /// is not a left-most base of the complete object type.
209 static void *stripBasePointerType(TARGET_TYPE *ptr);
210
211 /// Return the value of the specified `ptr` as a `void *`, after
212 /// stripping all `const` and `volatile` qualifiers from `MANAGED_TYPE`.
213 /// This function avoids accidental type-safety errors when performing
214 /// the necessary sequence of casts.
215 template <class MANAGED_TYPE>
216 static void *stripCompletePointerType(MANAGED_TYPE *ptr);
217
218 // PRIVATE MANIPULATORS
219
220 /// Destroy the currently managed object, if any. Then, set the target
221 /// object of this managed pointer to be that referenced by the
222 /// specified `ptr`, take ownership of `*ptr` as the currently managed
223 /// object, and set a deleter that will invoke the specified `deleter`
224 /// with the address of the currently managed object, and with the
225 /// specified `cookie` (that the deleter can use for its own purposes),
226 /// unless `0 == ptr`, in which case reset this managed pointer to empty.
227 ///
228 /// \pre The behavior is undefined if `ptr` is already managed by
229 /// another object, or if `0 == deleter && 0 != ptr`.
230 template <class MANAGED_TYPE>
231 void loadImp(MANAGED_TYPE *ptr, void *cookie, DeleterFunc deleter);
232
233 private:
234 // NOT IMPLEMENTED
235
236 /// It is never defined behavior to pass a null pointer literal as a
237 /// factory, unless the specified `ptr` is also a null pointer literal.
238 template <class MANAGED_TYPE>
239 ManagedPtr(MANAGED_TYPE *, bsl::nullptr_t);
240
241 private:
242 // NOT IMPLEMENTED
243
244 /// It is never defined behavior to pass a null literal as a deleter,
245 /// unless the `object` pointer is also a null pointer literal.
246 template <class MANAGED_TYPE, class COOKIE_TYPE>
247 ManagedPtr(MANAGED_TYPE *, COOKIE_TYPE *, bsl::nullptr_t);
248
249 private:
250 // NOT IMPLEMENTED
251
252 /// It is never defined behavior to pass a null literal as a deleter,
253 /// unless the `object` pointer is also a null pointer literal.
254 template <class MANAGED_TYPE>
255 void load(MANAGED_TYPE *, bsl::nullptr_t, bsl::nullptr_t);
256 template <class COOKIE_TYPE>
257 void load(TARGET_TYPE *, COOKIE_TYPE *, bsl::nullptr_t);
258
259 private:
260 // NOT IMPLEMENTED
261
262 /// These two operator overloads are declared as `private` but never
263 /// defined in order to eliminate accidental equality comparisons that
264 /// would occur through the implicit conversion to `BoolType`.
265 ///
266 /// \note Note that the return type of `void` is chosen as it will often produce a
267 /// clearer error message than relying on the `private` control failure.
268 /// Also note that these private operators will not be needed with
269 /// C++11, where an `explicit operator bool()` conversion operator would
270 /// be preferred.
271 void operator==(const ManagedPtr&) const;
272 void operator!=(const ManagedPtr&) const;
273
274 // FRIENDS
275 template <class ALIASED_TYPE>
276 friend class ManagedPtr; // required only for alias support
277
278 public:
279 // CREATORS
280
281 /// Create an empty managed pointer.
282 ManagedPtr();
283 ManagedPtr(bsl::nullptr_t); // IMPLICIT
284
285 /// Create a managed pointer having a target object referenced by the
286 /// specified `ptr`, owning the managed object `*ptr`, and having a
287 /// deleter that will call `delete ptr` to destroy the managed object
288 /// when invoked (e.g., when this managed pointer object is destroyed),
289 /// unless `0 == ptr`, in which case create an empty managed pointer.
290 /// The deleter will invoke the destructor of `MANAGED_TYPE` rather than
291 /// the destructor of `TARGET_TYPE`. This constructor will not compile
292 /// unless `MANAGED_TYPE *` is convertible to `TARGET_TYPE *`.
293 ///
294 /// \note Note that this behavior allows `ManagedPtr` to be defined for `void`
295 /// pointers, and to call the correct destructor for the managed object,
296 /// even if the destructor for `TARGET_TYPE` is not declared as `virtual`.
297 ///
298 /// \pre The behavior is undefined unless the managed object (if
299 /// any) can be destroyed by `delete`, or if the lifetime of the managed
300 /// object is already managed by another object.
301 template <class MANAGED_TYPE>
302 explicit ManagedPtr(MANAGED_TYPE *ptr);
303
304 /// Create a managed pointer having the same target object as the
305 /// managed pointer referenced by the specified `ref`, transfer
306 /// ownership of the managed object owned by the managed pointer
307 /// referenced by `ref`, and reset the managed pointer referenced by
308 /// `ref` to empty. This constructor is used to create a managed
309 /// pointer from a managed pointer rvalue, or from a managed pointer to
310 /// a "compatible" type, where "compatible" means a built-in conversion
311 /// from `COMPATIBLE_TYPE *` to `TARGET_TYPE *` is defined, e.g.,
312 /// `derived *` to `base *`, `T *` to `const T *`, or `T *` to `void *`.
313 ManagedPtr(ManagedPtr_Ref<TARGET_TYPE> ref)
314 BSLS_KEYWORD_NOEXCEPT; // IMPLICIT
315
316 ManagedPtr(ManagedPtr& original) BSLS_KEYWORD_NOEXCEPT;
317
318 /// Create a managed pointer having the same target object as the
319 /// specified `original`, transfer ownership of the object managed by
320 /// `original` (if any) to this managed pointer, and reset `original` to
321 /// empty.
322 ManagedPtr(bslmf::MovableRef<ManagedPtr> original) BSLS_KEYWORD_NOEXCEPT;
323
324 /// Create a managed pointer having the same target object as the specified
325 /// `original`, transfer ownership of the object managed by `original` (if
326 /// any) to this managed pointer, and reset `original` to empty.
327 /// `TARGET_TYPE` must be an accessible and unambiguous base of
328 /// `BDE_OTHER_TYPE`
329#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
330 template <class BDE_OTHER_TYPE>
331 ManagedPtr(ManagedPtr<BDE_OTHER_TYPE>&& original,
332 typename bsl::enable_if<
333 bsl::is_convertible<BDE_OTHER_TYPE *, TARGET_TYPE *>::value,
334 ManagedPtr_TraitConstraint>::type =
335 ManagedPtr_TraitConstraint())
336 BSLS_KEYWORD_NOEXCEPT;
337#elif defined(BSLS_PLATFORM_CMP_SUN) && BSLS_PLATFORM_CMP_VERSION < 0x5130
338 // sun compiler version 12.3 and earlier
339 template <class BDE_OTHER_TYPE>
340 ManagedPtr(bslmf::MovableRef<ManagedPtr<BDE_OTHER_TYPE> > original)
341 BSLS_KEYWORD_NOEXCEPT;
342#else // c++03 except old (version <= 12.3) sun compilers
343 template <class BDE_OTHER_TYPE>
344 ManagedPtr(bslmf::MovableRef<ManagedPtr<BDE_OTHER_TYPE> > original,
345 typename bsl::enable_if<
346 bsl::is_convertible<BDE_OTHER_TYPE *, TARGET_TYPE *>::value,
347 ManagedPtr_TraitConstraint>::type =
348 ManagedPtr_TraitConstraint())
349 BSLS_KEYWORD_NOEXCEPT;
350#endif
351
352 /// Create a managed pointer that takes ownership of the object managed
353 /// by the specified `alias`, but which uses the specified `ptr` to
354 /// refer to its target object, unless `0 == ptr`, in which case create
355 /// an empty managed pointer. Reset `alias` to empty if ownership of its managed object is transferred.
356 ///
357 /// \pre The behavior is undefined if `alias` is empty, but `0 != ptr`.
358 ///
359 /// \note Note that destroying or
360 /// re-assigning a managed pointer created with this constructor will
361 /// destroy the object originally managed by `alias` (unless `release`
362 /// is called first); the destructor for `*ptr` is not called directly.
363 template <class ALIASED_TYPE>
364 ManagedPtr(ManagedPtr<ALIASED_TYPE>& alias, TARGET_TYPE *ptr);
365 template <class ALIASED_TYPE>
366#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
367 ManagedPtr(ManagedPtr<ALIASED_TYPE>&& alias,
368#else
369 ManagedPtr(bslmf::MovableRef<ManagedPtr<ALIASED_TYPE> > alias,
370#endif
371 TARGET_TYPE *ptr);
372
373 /// Create a managed pointer having a target object referenced by the
374 /// specified `ptr`, owning the managed object `*ptr`, and having a
375 /// deleter that will call `factory->deleteObject(ptr)` to destroy the
376 /// managed object when invoked (e.g., when this managed pointer object
377 /// is destroyed), unless `0 == ptr`, in which case create an empty
378 /// managed pointer. The deleter will invoke the destructor of
379 /// `MANAGED_TYPE` rather than the destructor of `TARGET_TYPE`. This
380 /// constructor will not compile unless `MANAGED_TYPE *` is convertible to `TARGET_TYPE *`.
381 ///
382 /// \pre The behavior is undefined unless the managed
383 /// object (if any) can be destroyed by the specified `factory`, or if
384 /// `0 == factory && 0 != ptr`, or if the lifetime of the managed object is already managed by another object.
385 ///
386 /// \note Note that `bslma::Allocator`,
387 /// and any class publicly and unambiguously derived from
388 /// `bslma::Allocator`, meets the requirements for `FACTORY_TYPE`.
389 template <class MANAGED_TYPE, class FACTORY_TYPE>
390 ManagedPtr(MANAGED_TYPE *ptr, FACTORY_TYPE *factory);
391
392 /// Create an empty managed pointer.
393 /// \note Note that this constructor is
394 /// necessary to match null-pointer literal arguments, in order to break
395 /// ambiguities and provide valid type deduction with the other
396 /// constructor templates in this class.
397 explicit ManagedPtr(bsl::nullptr_t, bsl::nullptr_t);
398
399 /// Create an empty managed pointer.
400 /// \note Note that the specified `factory`
401 /// is ignored, as an empty managed pointer does not call its deleter.
402 template <class FACTORY_TYPE>
403 ManagedPtr(bsl::nullptr_t, FACTORY_TYPE *factory);
404
405 /// Create a managed pointer having a target object referenced by the
406 /// specified `ptr`, owning the managed object `*ptr`, and having a
407 /// deleter that will invoke the specified `deleter` with the address of
408 /// the currently managed object, and with the specified `cookie` (that
409 /// the deleter can use for its own purposes), unless `0 == ptr`, in
410 /// which case create an empty managed pointer.
411 ///
412 /// \pre The behavior is undefined if `ptr` is already managed by another object, or if `0 == deleter && 0 != ptr`.
413 ///
414 /// \note Note that this constructor is required
415 /// only because the deprecated overloads cause an ambiguity in its
416 /// absence; it should be removed when the deprecated overloads are
417 /// removed.
418 ManagedPtr(TARGET_TYPE *ptr, void *cookie, DeleterFunc deleter);
419
420 /// Create a managed pointer having a target object referenced by the
421 /// specified `ptr`, owning the managed object `*ptr`, and having a
422 /// deleter that will invoke the specified `deleter` with the address of
423 /// the currently managed object, and with the specified `cookie` (that
424 /// the deleter can use for its own purposes), unless `0 == ptr`, in
425 /// which case create an empty managed pointer. This constructor will
426 /// not compile unless `MANAGED_TYPE *` is convertible to
427 /// `TARGET_TYPE *`. The deleter will invoke the destructor of
428 /// `MANAGED_TYPE` rather than the destructor of `TARGET_TYPE`.
429 ///
430 /// \pre The behavior is undefined if `ptr` is already managed by another object,
431 /// or if `0 == deleter && 0 != ptr`.
432 template <class MANAGED_TYPE>
433 ManagedPtr(MANAGED_TYPE *ptr, void *cookie, DeleterFunc deleter);
434
435#ifndef BDE_OMIT_INTERNAL_DEPRECATED
436 /// Create a managed pointer having a target object referenced by the
437 /// specified `ptr`, owning the managed object `*ptr`, and having a
438 /// deleter that will invoke the specified `deleter` with the address of
439 /// the currently managed object, and with the specified `cookie` (that
440 /// the deleter can use for its own purposes), unless `0 == ptr`, in
441 /// which case create an empty managed pointer. This constructor will
442 /// not compile unless `MANAGED_TYPE *` is convertible to
443 /// `TARGET_TYPE *`, and `MANAGED_TYPE *` is convertible to
444 /// `MANAGED_BASE *`. The deleter will invoke the destructor of
445 /// `MANAGED_TYPE` rather than the destructor of `TARGET_TYPE`.
446 ///
447 /// \pre The behavior is undefined if `ptr` is already managed by another object, or if `0 == deleter && 0 != ptr`.
448 ///
449 /// \note Note that this constructor is
450 /// needed only to avoid ambiguous type deductions when passing a null
451 /// pointer literal as the `cookie` when the user passes a deleter
452 /// taking a type other than `void *` for its object type. Also note
453 /// that this function is *deprecated* as it relies on undefined
454 /// compiler behavior for its implementation (that luckily performs as
455 /// required on every platform supported by BDE).
456 ///
457 /// @deprecated Instead, use:
458 /// @code
459 /// template <class MANAGED_TYPE>
460 /// ManagedPtr(MANAGED_TYPE *ptr, void *cookie, DeleterFunc deleter);
461 /// @endcode
462 template <class MANAGED_TYPE, class MANAGED_BASE>
463 ManagedPtr(MANAGED_TYPE *ptr,
464 void *cookie,
465 void (*deleter)(MANAGED_BASE *, void *));
466
467 /// Create a managed pointer having a target object referenced by the
468 /// specified `ptr`, owning the managed object `*ptr`, and having a
469 /// deleter that will invoke the specified `deleter` with the address of
470 /// the currently managed object, and with the specified `cookie` (that
471 /// the deleter can use for its own purposes), unless `0 == ptr`, in
472 /// which case create an empty managed pointer. This constructor will
473 /// not compile unless `MANAGED_TYPE *` is convertible to
474 /// `TARGET_TYPE *`, and `MANAGED_TYPE *` is convertible to
475 /// `MANAGED_BASE *`. The deleter will invoke the destructor of
476 /// `MANAGED_TYPE` rather than the destructor of `TARGET_TYPE`.
477 ///
478 /// \pre The behavior is undefined if `ptr` is already managed by another object, or if `0 == deleter && 0 != ptr`.
479 ///
480 /// \note Note that this function is
481 /// *deprecated* as it relies on undefined compiler behavior for its
482 /// implementation (that luckily performs as required on every platform
483 /// supported by BDE).
484 ///
485 /// @deprecated Instead, use:
486 /// @code
487 /// template <class MANAGED_TYPE>
488 /// ManagedPtr(MANAGED_TYPE *ptr, void *cookie, DeleterFunc deleter);
489 /// @endcode
490 template <class MANAGED_TYPE,
491 class MANAGED_BASE,
492 class COOKIE_TYPE,
493 class COOKIE_BASE>
494 ManagedPtr(MANAGED_TYPE *ptr,
495 COOKIE_TYPE *cookie,
496 void (*deleter)(MANAGED_BASE *, COOKIE_BASE *));
497#endif // BDE_OMIT_INTERNAL_DEPRECATED
498
499 /// Destroy this managed pointer object. Destroy the object managed by
500 /// this managed pointer by invoking the user-supplied deleter, unless
501 /// this managed pointer is empty, in which case the deleter will *not*
502 /// be called.
503 ~ManagedPtr();
504
505 // MANIPULATORS
506 ManagedPtr& operator=(ManagedPtr& rhs) BSLS_KEYWORD_NOEXCEPT;
507
508 /// If this object and the specified `rhs` manage the same object,
509 /// return a reference to this managed pointer; otherwise, destroy the
510 /// managed object owned by this managed pointer, transfer ownership of
511 /// the managed object owned by `rhs` to this managed pointer, set this
512 /// managed pointer to point to the target object referenced by `rhs`,
513 /// reset `rhs` to empty, and return a reference to this managed
514 /// pointer.
515 ManagedPtr& operator=(bslmf::MovableRef<ManagedPtr> rhs)
516 BSLS_KEYWORD_NOEXCEPT;
517
518 /// If this object and the specified `rhs` manage the same object,
519 /// return a reference to this managed pointer; otherwise, destroy the
520 /// managed object owned by this managed pointer, transfer ownership of
521 /// the managed object owned by `rhs` to this managed pointer, set this
522 /// managed pointer to point to the target object referenced by `rhs`,
523 /// reset `rhs` to empty, and return a reference to this managed
524 /// pointer. `TARGET_TYPE` must be an accessible and unambiguous base
525 /// of `BDE_OTHER_TYPE`
526#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
527 template <class BDE_OTHER_TYPE>
528 typename bsl::enable_if<
529 bsl::is_convertible<BDE_OTHER_TYPE *, TARGET_TYPE *>::value,
530 ManagedPtr<TARGET_TYPE> >::type&
531 operator=(ManagedPtr<BDE_OTHER_TYPE>&& rhs) BSLS_KEYWORD_NOEXCEPT;
532#elif defined(BSLS_PLATFORM_CMP_SUN) && BSLS_PLATFORM_CMP_VERSION < 0x5130
533 // sun compiler version 12.3 and earlier
534 template <class BDE_OTHER_TYPE>
535 ManagedPtr<TARGET_TYPE>&
536 operator=(bslmf::MovableRef<ManagedPtr<BDE_OTHER_TYPE> > rhs)
537 BSLS_KEYWORD_NOEXCEPT;
538#else // c++03 except old (version <= 12.3) sun compilers
539 template <class BDE_OTHER_TYPE>
540 typename bsl::enable_if<
541 bsl::is_convertible<BDE_OTHER_TYPE *, TARGET_TYPE *>::value,
542 ManagedPtr<TARGET_TYPE> >::type&
543 operator=(bslmf::MovableRef<ManagedPtr<BDE_OTHER_TYPE> > rhs)
544 BSLS_KEYWORD_NOEXCEPT;
545#endif
546
547 /// If this object and the managed pointer reference by the specified
548 /// `ref` manage the same object, return a reference to this managed
549 /// pointer; otherwise, destroy the managed object owned by this managed
550 /// pointer, transfer ownership of the managed object owned by the
551 /// managed pointer referenced by `ref`, and set this managed pointer to
552 /// point to the target object currently referenced the managed pointer
553 /// referenced by `ref`; then reset the managed pointer referenced by
554 /// `ref` to empty, and return a reference to this managed pointer.
555 /// This operator is (implicitly) used to assign from a managed pointer
556 /// rvalue, or from a managed pointer to a "compatible" type, where
557 /// "compatible" means a built-in conversion from `MANAGED_TYPE *` to
558 /// `TARGET_TYPE *` is defined, e.g., `derived *` to `base *`, `T *` to
559 /// `const T *`, or `T *` to `void *`.
560 ManagedPtr& operator=(ManagedPtr_Ref<TARGET_TYPE> ref)
561 BSLS_KEYWORD_NOEXCEPT;
562
563 /// Destroy the current managed object (if any) and reset this managed
564 /// pointer to empty.
565 ManagedPtr& operator=(bsl::nullptr_t);
566
567 /// Return a managed pointer reference, referring to this object.
568 ///
569 /// \note Note that this conversion operator is used implicitly to allow the
570 /// construction of managed pointers from rvalues because temporaries
571 /// cannot be passed by references offering modifiable access.
572 template <class REFERENCED_TYPE>
573 operator ManagedPtr_Ref<REFERENCED_TYPE>();
574
575 /// Destroy the current managed object (if any) and reset this managed
576 /// pointer to empty.
577 ///
578 /// @deprecated Use @ref reset instead.
579 void clear();
580
581 /// Destroy the currently managed object, if any. Then, set the target
582 /// object of this managed pointer to be that referenced by the
583 /// specified `ptr`, take ownership of `*ptr` as the currently managed
584 /// object, and set a deleter that uses the currently installed default
585 /// allocator to destroy the managed object when invoked (e.g., when
586 /// this managed pointer object is destroyed), unless `0 == ptr`, in
587 /// which case reset this managed pointer to empty. The deleter will
588 /// invoke the destructor of `MANAGED_TYPE` rather than the destructor
589 /// of `TARGET_TYPE`. This function will not compile unless
590 /// `MANAGED_TYPE *` is convertible to `TARGET_TYPE *`.
591 ///
592 /// \pre The behavior is undefined unless the managed object (if any) can be destroyed by the
593 /// currently installed default allocator, or if the lifetime of the
594 /// managed object is already managed by another object.
595 template <class MANAGED_TYPE>
596 void load(MANAGED_TYPE *ptr);
597
598 /// Destroy the currently managed object, if any. Then, set the target
599 /// object of this managed pointer to be that referenced by the
600 /// specified `ptr`, take ownership of `*ptr` as the currently managed
601 /// object, and set a deleter that calls `factory->deleteObject(ptr)` to
602 /// destroy the managed object when invoked (e.g., when this managed
603 /// pointer object is destroyed), unless `0 == ptr`, in which case reset
604 /// this managed pointer to empty. The deleter will invoke the
605 /// destructor of `MANAGED_TYPE` rather than the destructor of
606 /// `TARGET_TYPE`. This function will not compile unless
607 /// `MANAGED_TYPE *` is convertible to `TARGET_TYPE *`.
608 ///
609 /// \pre The behavior is undefined unless the managed object (if any) can be destroyed by the
610 /// specified `factory`, or if `0 == factory && 0 != ptr`, or if the
611 /// the lifetime of the managed object is already managed by another object.
612 ///
613 /// \note Note that `bslma::Allocator`, and any class publicly and
614 /// unambiguously derived from `bslma::Allocator`, meets the
615 /// requirements for `FACTORY_TYPE`.
616 template <class MANAGED_TYPE, class FACTORY_TYPE>
617 void load(MANAGED_TYPE *ptr, FACTORY_TYPE *factory);
618
619 /// Destroy the currently managed object, if any. Then, set the target
620 /// object of this managed pointer to be that referenced by the
621 /// specified `ptr`, take ownership of `*ptr` as the currently managed
622 /// object, and set a deleter that will invoke the specified `deleter`
623 /// with the address of the currently managed object, and with the
624 /// specified `cookie` (that the deleter can use for its own purposes),
625 /// unless `0 == ptr`, in which case reset this managed pointer to empty.
626 ///
627 /// \pre The behavior is undefined if `ptr` is already managed by another object, or if `0 == deleter && 0 != ptr`.
628 ///
629 /// \note Note that GCC 3.4
630 /// and earlier versions have a bug in template type deduction/overload
631 /// resolution that causes ambiguities if this signature is available.
632 /// This function will be restored on that platform once the deprecated
633 /// signatures are finally removed.
634 template <class MANAGED_TYPE>
635 void load(MANAGED_TYPE *ptr, void *cookie, DeleterFunc deleter);
636
637 /// Destroy the current managed object (if any) and reset this managed pointer to empty.
638 ///
639 /// \note Note that the optionally specified `cookie` and
640 /// `deleter` will be ignored, as empty managed pointers do not invoke a
641 /// deleter.
642 void load(bsl::nullptr_t = 0, void *cookie = 0, DeleterFunc deleter = 0);
643
644#ifndef BDE_OMIT_INTERNAL_DEPRECATED
645 template <class MANAGED_TYPE, class COOKIE_TYPE>
646 void load(MANAGED_TYPE *ptr, COOKIE_TYPE *cookie, DeleterFunc deleter);
647
648 template <class MANAGED_TYPE, class MANAGED_BASE>
649 void load(MANAGED_TYPE *ptr,
650 void *cookie,
651 void (*deleter)(MANAGED_BASE *, void *));
652
653 /// Destroy the currently managed object, if any. Then, set the target
654 /// object of this managed pointer to be that referenced by the
655 /// specified `ptr`, take ownership of `*ptr` as the currently managed
656 /// object, and set a deleter that will invoke the specified `deleter`
657 /// with the address of the currently managed object, and with the
658 /// specified `cookie` (that the deleter can use for its own purposes),
659 /// unless `0 == ptr`, in which case reset this managed pointer to empty.
660 ///
661 /// \pre The behavior is undefined if `ptr` is already managed by another object, or if `0 == deleter && 0 != ptr`.
662 ///
663 /// \note Note that this
664 /// function is *deprecated* as it relies on undefined compiler behavior
665 /// for its implementation, but luckily perform as required for all
666 /// currently supported platforms; on platforms where the non-deprecated
667 /// overload is not available (e.g., GCC 3.4) code should be written as
668 /// if it were available, as an appropriate (deprecated) overload will
669 /// be selected with the correct (non-deprecated) behavior.
670 ///
671 /// @deprecated Instead, use:
672 /// @code
673 /// template <class MANAGED_TYPE>
674 /// void load(MANAGED_TYPE *ptr, void *cookie, DeleterFunc deleter);
675 /// @endcode
676 template <class MANAGED_TYPE,
677 class MANAGED_BASE,
678 class COOKIE_TYPE,
679 class COOKIE_BASE>
680 void load(MANAGED_TYPE *ptr,
681 COOKIE_TYPE *cookie,
682 void (*deleter)(MANAGED_BASE *, COOKIE_BASE *));
683#endif // BDE_OMIT_INTERNAL_DEPRECATED
684
685 /// If the specified `alias` manages the same object as this managed
686 /// pointer, set the target object of this managed pointer to be that
687 /// referenced by the specified `ptr`; otherwise, destroy the currently
688 /// managed object (if any), and if `alias` is empty, reset this managed
689 /// pointer to empty; otherwise, transfer ownership (and the deleter) of
690 /// the object managed by `alias`, and set the target object of this
691 /// managed pointer to be that referenced by `ptr`.
692 ///
693 /// \pre The behavior is undefined if `0 == ptr` and `alias` is not empty, or if `0 != ptr`
694 /// and `alias` is empty, or if `ptr` is already managed by a managed pointer other than `alias`.
695 ///
696 /// \note Note that this establishes a managed
697 /// pointer where `ptr` aliases `alias`. The managed object for `alias`
698 /// will ultimately be destroyed, and the destructor for `ptr` is not
699 /// called directly.
700 template <class ALIASED_TYPE>
701 void loadAlias(ManagedPtr<ALIASED_TYPE>& alias, TARGET_TYPE *ptr);
702
703 /// Return a raw pointer to the current target object (if any) and the
704 /// deleter for the currently managed object, and reset this managed
705 /// pointer to empty. It is undefined behavior to run the returned
706 /// deleter unless the returned pointer to target object is not null.
707 ManagedPtr_PairProxy<TARGET_TYPE, ManagedPtrDeleter> release();
708
709 /// Load the specified `deleter` for the currently managed object and
710 /// reset this managed pointer to empty. Return a raw pointer to the
711 /// target object (if any) managed by this pointer. It is undefined
712 /// behavior to run the returned deleter unless the returned pointer to
713 /// target object is not null.
714 TARGET_TYPE *release(ManagedPtrDeleter *deleter);
715
716 /// Destroy the current managed object (if any) and reset this managed
717 /// pointer to empty.
718 void reset();
719
720 /// Exchange the value and ownership of this managed pointer with the
721 /// specified `other` managed pointer.
722 void swap(ManagedPtr& other);
723
724 // ACCESSORS
725
726 /// Return `true` if this managed pointer is empty, and `false` otherwise.
727 bool operator==(bsl::nullptr_t) const;
728
729 /// Return `false` if this managed pointer is empty, and `true` otherwise.
730 bool operator!=(bsl::nullptr_t) const;
731
732 /// Return a value of "unspecified bool" type that evaluates to `false`
733 /// if this managed pointer is empty, and `true` otherwise.
734 ///
735 /// \note Note that this conversion operator allows a managed pointer to be used within
736 /// a conditional context, such as within an `if` or `while` statement,
737 /// but does *not* allow managed pointers to be compared (e.g., via `<`
738 /// or `>`). Also note that a superior solution is available in C++11
739 /// using the `explicit operator bool()` syntax, that removes the need
740 /// for a special boolean-like type and private equality-comparison
741 /// operators.
742 operator BoolType() const;
743
744 /// Return a reference to the target object.
745 ///
746 /// \pre The behavior is undefined if this managed pointer is empty, or if `TARGET_TYPE` is `void` or
747 /// `const void`.
748 typename bslmf::AddReference<TARGET_TYPE>::Type operator*() const;
749
750 /// Return the address of the target object, or 0 if this managed
751 /// pointer is empty.
752 TARGET_TYPE *operator->() const;
753
754 /// Return a reference to the non-modifiable deleter information associated with this managed pointer.
755 ///
756 /// \pre The behavior is undefined if
757 /// this managed pointer is empty.
758 const ManagedPtrDeleter& deleter() const;
759
760 /// Return the address of the target object, or 0 if this managed
761 /// pointer is empty.
762 TARGET_TYPE *get() const;
763
764 /// Return the address of the target object, or 0 if this managed
765 /// pointer is empty.
766 ///
767 /// @deprecated Use @ref get instead.
768 TARGET_TYPE *ptr() const;
769};
770
771// FREE FUNCTIONS
772
773/// Efficiently exchange the values of the specified `a` and `b` objects.
774/// This function provides the no-throw exception-safety guarantee.
775template <class TARGET_TYPE>
776void swap(ManagedPtr<TARGET_TYPE>& a, ManagedPtr<TARGET_TYPE>& b);
777
778 // =====================
779 // struct ManagedPtrUtil
780 // =====================
781
782/// This utility class provides a general no-op deleter, which is useful
783/// when creating managed pointers to stack-allocated objects.
784///
785/// See @ref bslma_managedptr_cpp03
786struct ManagedPtrUtil {
787
788 // CLASS METHODS
789
790 /// Deleter function that does nothing.
791 static void noOpDeleter(void *, void *);
792
793 /// Make use of `AllocatorUtil::deleteObject` to destroy and deallocate
794 /// the specified `object` using the specified allocator.
795 ///
796 /// \pre The behavior is undefined unless `allocator` is an instance of `bslma::Allocator`
797 /// that was used to supply memory for `object` and `object` points to an
798 /// instance of `ELEMENT_TYPE` that is within its lifetime.
799 template <class ELEMENT_TYPE>
800 static void allocatorDeleter(void *object, void *allocator);
801
802#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
803// {{{ BEGIN GENERATED CODE
804// Command line: sim_cpp11_features.pl bslma_managedptr.h
805#ifndef BSLMA_MANAGEDPTR_VARIADIC_LIMIT
806#define BSLMA_MANAGEDPTR_VARIADIC_LIMIT 14
807#endif
808#ifndef BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A
809#define BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A BSLMA_MANAGEDPTR_VARIADIC_LIMIT
810#endif
811
812#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 0
813 template <class ELEMENT_TYPE>
814 static ManagedPtr<ELEMENT_TYPE>
815 allocateManaged(bslma::Allocator *allocator);
816#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 0
817
818#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 1
819 template <class ELEMENT_TYPE, class ARGS_01>
820 static ManagedPtr<ELEMENT_TYPE>
821 allocateManaged(bslma::Allocator *allocator,
822 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01);
823#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 1
824
825#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 2
826 template <class ELEMENT_TYPE, class ARGS_01,
827 class ARGS_02>
828 static ManagedPtr<ELEMENT_TYPE>
829 allocateManaged(bslma::Allocator *allocator,
830 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
831 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02);
832#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 2
833
834#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 3
835 template <class ELEMENT_TYPE, class ARGS_01,
836 class ARGS_02,
837 class ARGS_03>
838 static ManagedPtr<ELEMENT_TYPE>
839 allocateManaged(bslma::Allocator *allocator,
840 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
841 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
842 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03);
843#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 3
844
845#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 4
846 template <class ELEMENT_TYPE, class ARGS_01,
847 class ARGS_02,
848 class ARGS_03,
849 class ARGS_04>
850 static ManagedPtr<ELEMENT_TYPE>
851 allocateManaged(bslma::Allocator *allocator,
852 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
853 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
854 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
855 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04);
856#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 4
857
858#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 5
859 template <class ELEMENT_TYPE, class ARGS_01,
860 class ARGS_02,
861 class ARGS_03,
862 class ARGS_04,
863 class ARGS_05>
864 static ManagedPtr<ELEMENT_TYPE>
865 allocateManaged(bslma::Allocator *allocator,
866 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
867 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
868 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
869 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
870 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05);
871#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 5
872
873#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 6
874 template <class ELEMENT_TYPE, class ARGS_01,
875 class ARGS_02,
876 class ARGS_03,
877 class ARGS_04,
878 class ARGS_05,
879 class ARGS_06>
880 static ManagedPtr<ELEMENT_TYPE>
881 allocateManaged(bslma::Allocator *allocator,
882 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
883 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
884 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
885 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
886 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
887 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06);
888#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 6
889
890#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 7
891 template <class ELEMENT_TYPE, class ARGS_01,
892 class ARGS_02,
893 class ARGS_03,
894 class ARGS_04,
895 class ARGS_05,
896 class ARGS_06,
897 class ARGS_07>
898 static ManagedPtr<ELEMENT_TYPE>
899 allocateManaged(bslma::Allocator *allocator,
900 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
901 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
902 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
903 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
904 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
905 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
906 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07);
907#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 7
908
909#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 8
910 template <class ELEMENT_TYPE, class ARGS_01,
911 class ARGS_02,
912 class ARGS_03,
913 class ARGS_04,
914 class ARGS_05,
915 class ARGS_06,
916 class ARGS_07,
917 class ARGS_08>
918 static ManagedPtr<ELEMENT_TYPE>
919 allocateManaged(bslma::Allocator *allocator,
920 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
921 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
922 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
923 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
924 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
925 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
926 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
927 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08);
928#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 8
929
930#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 9
931 template <class ELEMENT_TYPE, class ARGS_01,
932 class ARGS_02,
933 class ARGS_03,
934 class ARGS_04,
935 class ARGS_05,
936 class ARGS_06,
937 class ARGS_07,
938 class ARGS_08,
939 class ARGS_09>
940 static ManagedPtr<ELEMENT_TYPE>
941 allocateManaged(bslma::Allocator *allocator,
942 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
943 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
944 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
945 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
946 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
947 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
948 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
949 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
950 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09);
951#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 9
952
953#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 10
954 template <class ELEMENT_TYPE, class ARGS_01,
955 class ARGS_02,
956 class ARGS_03,
957 class ARGS_04,
958 class ARGS_05,
959 class ARGS_06,
960 class ARGS_07,
961 class ARGS_08,
962 class ARGS_09,
963 class ARGS_10>
964 static ManagedPtr<ELEMENT_TYPE>
965 allocateManaged(bslma::Allocator *allocator,
966 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
967 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
968 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
969 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
970 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
971 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
972 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
973 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
974 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
975 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10);
976#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 10
977
978#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 11
979 template <class ELEMENT_TYPE, class ARGS_01,
980 class ARGS_02,
981 class ARGS_03,
982 class ARGS_04,
983 class ARGS_05,
984 class ARGS_06,
985 class ARGS_07,
986 class ARGS_08,
987 class ARGS_09,
988 class ARGS_10,
989 class ARGS_11>
990 static ManagedPtr<ELEMENT_TYPE>
991 allocateManaged(bslma::Allocator *allocator,
992 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
993 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
994 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
995 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
996 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
997 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
998 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
999 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1000 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1001 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1002 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11);
1003#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 11
1004
1005#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 12
1006 template <class ELEMENT_TYPE, class ARGS_01,
1007 class ARGS_02,
1008 class ARGS_03,
1009 class ARGS_04,
1010 class ARGS_05,
1011 class ARGS_06,
1012 class ARGS_07,
1013 class ARGS_08,
1014 class ARGS_09,
1015 class ARGS_10,
1016 class ARGS_11,
1017 class ARGS_12>
1018 static ManagedPtr<ELEMENT_TYPE>
1019 allocateManaged(bslma::Allocator *allocator,
1020 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1021 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1022 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1023 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1024 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1025 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1026 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1027 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1028 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1029 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1030 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
1031 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12);
1032#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 12
1033
1034#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 13
1035 template <class ELEMENT_TYPE, class ARGS_01,
1036 class ARGS_02,
1037 class ARGS_03,
1038 class ARGS_04,
1039 class ARGS_05,
1040 class ARGS_06,
1041 class ARGS_07,
1042 class ARGS_08,
1043 class ARGS_09,
1044 class ARGS_10,
1045 class ARGS_11,
1046 class ARGS_12,
1047 class ARGS_13>
1048 static ManagedPtr<ELEMENT_TYPE>
1049 allocateManaged(bslma::Allocator *allocator,
1050 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1051 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1052 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1053 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1054 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1055 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1056 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1057 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1058 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1059 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1060 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
1061 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
1062 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13);
1063#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 13
1064
1065#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 14
1066 template <class ELEMENT_TYPE, class ARGS_01,
1067 class ARGS_02,
1068 class ARGS_03,
1069 class ARGS_04,
1070 class ARGS_05,
1071 class ARGS_06,
1072 class ARGS_07,
1073 class ARGS_08,
1074 class ARGS_09,
1075 class ARGS_10,
1076 class ARGS_11,
1077 class ARGS_12,
1078 class ARGS_13,
1079 class ARGS_14>
1080 static ManagedPtr<ELEMENT_TYPE>
1081 allocateManaged(bslma::Allocator *allocator,
1082 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1083 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1084 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1085 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1086 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1087 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1088 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1089 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1090 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1091 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1092 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
1093 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
1094 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
1095 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14);
1096#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 14
1097
1098#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 0
1099 template <class ELEMENT_TYPE, class ALLOCATOR>
1100 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1101 ManagedPtr<ELEMENT_TYPE> >::type
1102 allocateManaged(const ALLOCATOR& allocator);
1103#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 0
1104
1105#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 1
1106 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01>
1107 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1108 ManagedPtr<ELEMENT_TYPE> >::type
1109 allocateManaged(const ALLOCATOR& allocator,
1110 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01);
1111#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 1
1112
1113#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 2
1114 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1115 class ARGS_02>
1116 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1117 ManagedPtr<ELEMENT_TYPE> >::type
1118 allocateManaged(const ALLOCATOR& allocator,
1119 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1120 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02);
1121#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 2
1122
1123#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 3
1124 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1125 class ARGS_02,
1126 class ARGS_03>
1127 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1128 ManagedPtr<ELEMENT_TYPE> >::type
1129 allocateManaged(const ALLOCATOR& allocator,
1130 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1131 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1132 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03);
1133#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 3
1134
1135#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 4
1136 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1137 class ARGS_02,
1138 class ARGS_03,
1139 class ARGS_04>
1140 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1141 ManagedPtr<ELEMENT_TYPE> >::type
1142 allocateManaged(const ALLOCATOR& allocator,
1143 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1144 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1145 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1146 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04);
1147#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 4
1148
1149#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 5
1150 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1151 class ARGS_02,
1152 class ARGS_03,
1153 class ARGS_04,
1154 class ARGS_05>
1155 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1156 ManagedPtr<ELEMENT_TYPE> >::type
1157 allocateManaged(const ALLOCATOR& allocator,
1158 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1159 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1160 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1161 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1162 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05);
1163#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 5
1164
1165#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 6
1166 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1167 class ARGS_02,
1168 class ARGS_03,
1169 class ARGS_04,
1170 class ARGS_05,
1171 class ARGS_06>
1172 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1173 ManagedPtr<ELEMENT_TYPE> >::type
1174 allocateManaged(const ALLOCATOR& allocator,
1175 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1176 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1177 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1178 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1179 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1180 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06);
1181#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 6
1182
1183#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 7
1184 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1185 class ARGS_02,
1186 class ARGS_03,
1187 class ARGS_04,
1188 class ARGS_05,
1189 class ARGS_06,
1190 class ARGS_07>
1191 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1192 ManagedPtr<ELEMENT_TYPE> >::type
1193 allocateManaged(const ALLOCATOR& allocator,
1194 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1195 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1196 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1197 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1198 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1199 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1200 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07);
1201#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 7
1202
1203#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 8
1204 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1205 class ARGS_02,
1206 class ARGS_03,
1207 class ARGS_04,
1208 class ARGS_05,
1209 class ARGS_06,
1210 class ARGS_07,
1211 class ARGS_08>
1212 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1213 ManagedPtr<ELEMENT_TYPE> >::type
1214 allocateManaged(const ALLOCATOR& allocator,
1215 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1216 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1217 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1218 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1219 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1220 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1221 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1222 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08);
1223#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 8
1224
1225#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 9
1226 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1227 class ARGS_02,
1228 class ARGS_03,
1229 class ARGS_04,
1230 class ARGS_05,
1231 class ARGS_06,
1232 class ARGS_07,
1233 class ARGS_08,
1234 class ARGS_09>
1235 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1236 ManagedPtr<ELEMENT_TYPE> >::type
1237 allocateManaged(const ALLOCATOR& allocator,
1238 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1239 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1240 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1241 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1242 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1243 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1244 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1245 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1246 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09);
1247#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 9
1248
1249#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 10
1250 template <class ELEMENT_TYPE, class ALLOCATOR, 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 typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1261 ManagedPtr<ELEMENT_TYPE> >::type
1262 allocateManaged(const ALLOCATOR& allocator,
1263 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1264 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1265 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1266 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1267 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1268 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1269 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1270 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1271 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1272 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10);
1273#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 10
1274
1275#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 11
1276 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1277 class ARGS_02,
1278 class ARGS_03,
1279 class ARGS_04,
1280 class ARGS_05,
1281 class ARGS_06,
1282 class ARGS_07,
1283 class ARGS_08,
1284 class ARGS_09,
1285 class ARGS_10,
1286 class ARGS_11>
1287 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1288 ManagedPtr<ELEMENT_TYPE> >::type
1289 allocateManaged(const ALLOCATOR& allocator,
1290 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1291 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1292 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1293 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1294 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1295 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1296 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1297 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1298 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1299 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1300 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11);
1301#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 11
1302
1303#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 12
1304 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1305 class ARGS_02,
1306 class ARGS_03,
1307 class ARGS_04,
1308 class ARGS_05,
1309 class ARGS_06,
1310 class ARGS_07,
1311 class ARGS_08,
1312 class ARGS_09,
1313 class ARGS_10,
1314 class ARGS_11,
1315 class ARGS_12>
1316 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1317 ManagedPtr<ELEMENT_TYPE> >::type
1318 allocateManaged(const ALLOCATOR& allocator,
1319 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1320 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1321 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1322 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1323 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1324 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1325 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1326 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1327 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1328 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1329 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
1330 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12);
1331#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 12
1332
1333#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 13
1334 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1335 class ARGS_02,
1336 class ARGS_03,
1337 class ARGS_04,
1338 class ARGS_05,
1339 class ARGS_06,
1340 class ARGS_07,
1341 class ARGS_08,
1342 class ARGS_09,
1343 class ARGS_10,
1344 class ARGS_11,
1345 class ARGS_12,
1346 class ARGS_13>
1347 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1348 ManagedPtr<ELEMENT_TYPE> >::type
1349 allocateManaged(const ALLOCATOR& allocator,
1350 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1351 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1352 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1353 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1354 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1355 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1356 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1357 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1358 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1359 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1360 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
1361 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
1362 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13);
1363#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 13
1364
1365#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 14
1366 template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
1367 class ARGS_02,
1368 class ARGS_03,
1369 class ARGS_04,
1370 class ARGS_05,
1371 class ARGS_06,
1372 class ARGS_07,
1373 class ARGS_08,
1374 class ARGS_09,
1375 class ARGS_10,
1376 class ARGS_11,
1377 class ARGS_12,
1378 class ARGS_13,
1379 class ARGS_14>
1380 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1381 ManagedPtr<ELEMENT_TYPE> >::type
1382 allocateManaged(const ALLOCATOR& allocator,
1383 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1384 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1385 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1386 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1387 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1388 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1389 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1390 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1391 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1392 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1393 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
1394 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
1395 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
1396 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14);
1397#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 14
1398
1399
1400#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 0
1401 template <class ELEMENT_TYPE>
1402 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1403 );
1404#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 0
1405
1406#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 1
1407 template <class ELEMENT_TYPE, class ARGS_01>
1408 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1409 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01);
1410#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 1
1411
1412#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 2
1413 template <class ELEMENT_TYPE, class ARGS_01,
1414 class ARGS_02>
1415 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1416 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1417 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02);
1418#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 2
1419
1420#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 3
1421 template <class ELEMENT_TYPE, class ARGS_01,
1422 class ARGS_02,
1423 class ARGS_03>
1424 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1425 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1426 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1427 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03);
1428#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 3
1429
1430#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 4
1431 template <class ELEMENT_TYPE, class ARGS_01,
1432 class ARGS_02,
1433 class ARGS_03,
1434 class ARGS_04>
1435 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1436 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1437 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1438 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1439 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04);
1440#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 4
1441
1442#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 5
1443 template <class ELEMENT_TYPE, class ARGS_01,
1444 class ARGS_02,
1445 class ARGS_03,
1446 class ARGS_04,
1447 class ARGS_05>
1448 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1449 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1450 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1451 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1452 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1453 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05);
1454#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 5
1455
1456#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 6
1457 template <class ELEMENT_TYPE, class ARGS_01,
1458 class ARGS_02,
1459 class ARGS_03,
1460 class ARGS_04,
1461 class ARGS_05,
1462 class ARGS_06>
1463 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1464 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1465 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1466 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1467 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1468 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1469 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06);
1470#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 6
1471
1472#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 7
1473 template <class ELEMENT_TYPE, class ARGS_01,
1474 class ARGS_02,
1475 class ARGS_03,
1476 class ARGS_04,
1477 class ARGS_05,
1478 class ARGS_06,
1479 class ARGS_07>
1480 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1481 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1482 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1483 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1484 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1485 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1486 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1487 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07);
1488#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 7
1489
1490#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 8
1491 template <class ELEMENT_TYPE, class ARGS_01,
1492 class ARGS_02,
1493 class ARGS_03,
1494 class ARGS_04,
1495 class ARGS_05,
1496 class ARGS_06,
1497 class ARGS_07,
1498 class ARGS_08>
1499 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1500 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1501 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1502 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1503 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1504 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1505 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1506 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1507 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08);
1508#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 8
1509
1510#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 9
1511 template <class ELEMENT_TYPE, class ARGS_01,
1512 class ARGS_02,
1513 class ARGS_03,
1514 class ARGS_04,
1515 class ARGS_05,
1516 class ARGS_06,
1517 class ARGS_07,
1518 class ARGS_08,
1519 class ARGS_09>
1520 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1521 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1522 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1523 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1524 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1525 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1526 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1527 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1528 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1529 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09);
1530#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 9
1531
1532#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 10
1533 template <class ELEMENT_TYPE, class ARGS_01,
1534 class ARGS_02,
1535 class ARGS_03,
1536 class ARGS_04,
1537 class ARGS_05,
1538 class ARGS_06,
1539 class ARGS_07,
1540 class ARGS_08,
1541 class ARGS_09,
1542 class ARGS_10>
1543 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1544 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1545 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1546 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1547 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1548 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1549 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1550 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1551 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1552 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1553 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10);
1554#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 10
1555
1556#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 11
1557 template <class ELEMENT_TYPE, class ARGS_01,
1558 class ARGS_02,
1559 class ARGS_03,
1560 class ARGS_04,
1561 class ARGS_05,
1562 class ARGS_06,
1563 class ARGS_07,
1564 class ARGS_08,
1565 class ARGS_09,
1566 class ARGS_10,
1567 class ARGS_11>
1568 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1569 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1570 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1571 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1572 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1573 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1574 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1575 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1576 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1577 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1578 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1579 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11);
1580#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 11
1581
1582#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 12
1583 template <class ELEMENT_TYPE, class ARGS_01,
1584 class ARGS_02,
1585 class ARGS_03,
1586 class ARGS_04,
1587 class ARGS_05,
1588 class ARGS_06,
1589 class ARGS_07,
1590 class ARGS_08,
1591 class ARGS_09,
1592 class ARGS_10,
1593 class ARGS_11,
1594 class ARGS_12>
1595 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1596 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1597 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1598 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1599 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1600 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1601 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1602 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1603 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1604 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1605 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1606 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
1607 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12);
1608#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 12
1609
1610#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 13
1611 template <class ELEMENT_TYPE, class ARGS_01,
1612 class ARGS_02,
1613 class ARGS_03,
1614 class ARGS_04,
1615 class ARGS_05,
1616 class ARGS_06,
1617 class ARGS_07,
1618 class ARGS_08,
1619 class ARGS_09,
1620 class ARGS_10,
1621 class ARGS_11,
1622 class ARGS_12,
1623 class ARGS_13>
1624 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1625 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1626 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1627 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1628 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1629 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1630 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1631 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1632 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1633 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1634 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1635 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
1636 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
1637 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13);
1638#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 13
1639
1640#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 14
1641 template <class ELEMENT_TYPE, class ARGS_01,
1642 class ARGS_02,
1643 class ARGS_03,
1644 class ARGS_04,
1645 class ARGS_05,
1646 class ARGS_06,
1647 class ARGS_07,
1648 class ARGS_08,
1649 class ARGS_09,
1650 class ARGS_10,
1651 class ARGS_11,
1652 class ARGS_12,
1653 class ARGS_13,
1654 class ARGS_14>
1655 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1656 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
1657 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
1658 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
1659 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
1660 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
1661 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
1662 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
1663 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
1664 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
1665 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
1666 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
1667 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
1668 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
1669 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14);
1670#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_A >= 14
1671
1672#else
1673// The generated code below is a workaround for the absence of perfect
1674// forwarding in some compilers.
1675
1676 template <class ELEMENT_TYPE, class... ARGS>
1677 static ManagedPtr<ELEMENT_TYPE>
1678 allocateManaged(bslma::Allocator *allocator,
1679 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args);
1680 template <class ELEMENT_TYPE, class ALLOCATOR, class... ARGS>
1681 static typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
1682 ManagedPtr<ELEMENT_TYPE> >::type
1683 allocateManaged(const ALLOCATOR& allocator,
1684 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args);
1685
1686 template <class ELEMENT_TYPE, class... ARGS>
1687 static ManagedPtr<ELEMENT_TYPE> makeManaged(
1688 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args);
1689
1690// }}} END GENERATED CODE
1691#endif
1692};
1693
1694 // ===========================
1695 // struct ManagedPtrNilDeleter
1696 // ===========================
1697
1698/// This utility class provides a general no-op deleter, which is useful
1699/// when creating managed pointers to stack-allocated objects.
1700///
1701/// \note Note that the non-template class `ManagedPtrUtil` should be used in preference to
1702/// this deprecated class, avoiding both template bloat and undefined
1703/// behavior.
1704///
1705/// @deprecated Use @ref ManagedPtrUtil::noOpDeleter instead.
1706///
1707/// See @ref bslma_managedptr_cpp03
1708template <class TARGET_TYPE>
1709struct ManagedPtrNilDeleter {
1710
1711 // CLASS METHODS
1712
1713 /// Deleter function that does nothing.
1714 static void deleter(void *, void *);
1715};
1716
1717 // ===========================================
1718 // private class ManagedPtr_FactoryDeleterType
1719 // ===========================================
1720
1721/// This metafunction class-template provides a means to compute the
1722/// preferred deleter function for a factory class for those methods of
1723/// `ManagedPtr` that supply only a factory, and no additional deleter
1724/// function. The intent is to use a common deleter function for all
1725/// allocators that implement the `bslma::Allocator` protocol, rather than
1726/// create a special deleter function based on the complete type of each
1727/// allocator, each doing the same thing (invoking the virtual function
1728/// `deleteObject`).
1729template <class TARGET_TYPE, class FACTORY_TYPE>
1730struct ManagedPtr_FactoryDeleterType
1731 : bsl::conditional<
1732 bsl::is_convertible<FACTORY_TYPE *, Allocator *>::value,
1733 ManagedPtr_FactoryDeleter<TARGET_TYPE, Allocator>,
1734 ManagedPtr_FactoryDeleter<TARGET_TYPE, FACTORY_TYPE> > {
1735};
1736
1737 // ========================================
1738 // private struct ManagedPtr_DefaultDeleter
1739 // ========================================
1740
1741/// This `struct` provides a function-like managed pointer deleter that
1742/// invokes `delete` with the passed pointer.
1743///
1744/// See @ref bslma_managedptr_cpp03
1745template <class MANAGED_TYPE>
1746struct ManagedPtr_DefaultDeleter {
1747
1748 // CLASS METHODS
1749
1750 /// Cast the specified `ptr` to (template parameter) type
1751 /// `MANAGED_TYPE *`, and then call `delete` with the cast pointer.
1752 static void deleter(void *ptr, void *);
1753};
1754
1755// ============================================================================
1756// INLINE DEFINITIONS
1757// ============================================================================
1758
1759 // ----------------------------
1760 // private class ManagedPtr_Ref
1761 // ----------------------------
1762
1763// CREATORS
1764template <class TARGET_TYPE>
1765inline
1766ManagedPtr_Ref<TARGET_TYPE>::ManagedPtr_Ref(ManagedPtr_Members *base,
1767 TARGET_TYPE *target)
1768: d_base_p(base)
1769, d_cast_p(target)
1770{
1771 BSLS_ASSERT_SAFE(0 != base);
1772}
1773
1774template <class TARGET_TYPE>
1775inline
1776ManagedPtr_Ref<TARGET_TYPE>::~ManagedPtr_Ref()
1777{
1778 BSLS_ASSERT_SAFE(0 != d_base_p);
1779}
1780
1781// ACCESSORS
1782template <class TARGET_TYPE>
1783inline
1784ManagedPtr_Members *ManagedPtr_Ref<TARGET_TYPE>::base() const
1785{
1786 return d_base_p;
1787}
1788
1789template <class TARGET_TYPE>
1790inline
1791TARGET_TYPE *ManagedPtr_Ref<TARGET_TYPE>::target() const
1792{
1793 return d_cast_p;
1794}
1795
1796 // ----------------
1797 // class ManagedPtr
1798 // ----------------
1799
1800template <class TARGET_TYPE>
1801class ManagedPtr<volatile TARGET_TYPE>;
1802 // This specialization is declared but not defined, in order to provide an
1803 // early compile-fail check to catch misuse of managed pointer to
1804 // 'volatile' types, which is explicitly called out as not supported in the
1805 // primary class template contract.
1806
1807template <class TARGET_TYPE>
1808class ManagedPtr<TARGET_TYPE&>;
1809 // This specialization is declared but not defined, in order to provide an
1810 // early compile-fail check to catch misuse of managed pointer to reference
1811 // types, which is explicitly called out as not supported in the primary
1812 // class template contract.
1813
1814#if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES)
1815template <class TARGET_TYPE>
1816class ManagedPtr<TARGET_TYPE&&>;
1817 // This specialization is declared but not defined, in order to provide an
1818 // early compile-fail check to catch misuse of managed pointer to reference
1819 // types, which is explicitly called out as not supported in the primary
1820 // class template contract.
1821#endif
1822
1823// PRIVATE CLASS METHODS
1824template <class TARGET_TYPE>
1825inline
1826void *ManagedPtr<TARGET_TYPE>::stripBasePointerType(TARGET_TYPE *ptr)
1827{
1828 return PointerUtil::voidify(ptr);
1829}
1830
1831template <class TARGET_TYPE>
1832template <class MANAGED_TYPE>
1833inline
1834void *
1835ManagedPtr<TARGET_TYPE>::stripCompletePointerType(MANAGED_TYPE *ptr)
1836{
1837 return PointerUtil::voidify(ptr);
1838}
1839
1840// PRIVATE MANIPULATORS
1841template <class TARGET_TYPE>
1842template <class MANAGED_TYPE>
1843inline
1844void ManagedPtr<TARGET_TYPE>::loadImp(MANAGED_TYPE *ptr,
1845 void *cookie,
1846 DeleterFunc deleter)
1847{
1848 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
1849 BSLS_ASSERT_SAFE(0 != deleter || 0 == ptr);
1850
1851 d_members.runDeleter();
1852 d_members.set(stripCompletePointerType(ptr), cookie, deleter);
1853 d_members.setAliasPtr(stripBasePointerType(ptr));
1854}
1855
1856// CREATORS
1857template <class TARGET_TYPE>
1858inline
1859ManagedPtr<TARGET_TYPE>::ManagedPtr()
1860: d_members()
1861{
1862}
1863
1864template <class TARGET_TYPE>
1865inline
1866ManagedPtr<TARGET_TYPE>::ManagedPtr(bsl::nullptr_t)
1867: d_members()
1868{
1869}
1870
1871template <class TARGET_TYPE>
1872template <class MANAGED_TYPE>
1873inline
1874ManagedPtr<TARGET_TYPE>::ManagedPtr(MANAGED_TYPE *ptr)
1875: d_members(stripCompletePointerType(ptr),
1876 0,
1877 &ManagedPtr_DefaultDeleter<MANAGED_TYPE>::deleter,
1878 stripBasePointerType(ptr))
1879{
1880 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
1881}
1882
1883template <class TARGET_TYPE>
1884inline
1885ManagedPtr<TARGET_TYPE>::ManagedPtr(ManagedPtr_Ref<TARGET_TYPE> ref)
1886 BSLS_KEYWORD_NOEXCEPT
1887: d_members(*ref.base())
1888{
1889 d_members.setAliasPtr(stripBasePointerType(ref.target()));
1890}
1891
1892template <class TARGET_TYPE>
1893inline
1894ManagedPtr<TARGET_TYPE>::ManagedPtr(ManagedPtr& original) BSLS_KEYWORD_NOEXCEPT
1895: d_members(original.d_members)
1896{
1897}
1898
1899template <class TARGET_TYPE>
1900inline
1901ManagedPtr<TARGET_TYPE>::ManagedPtr(bslmf::MovableRef<ManagedPtr> original)
1902 BSLS_KEYWORD_NOEXCEPT
1903: d_members(MoveUtil::access(original).d_members)
1904{
1905}
1906
1907#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
1908 template <class TARGET_TYPE>
1909 template <class BDE_OTHER_TYPE>
1910 inline
1911 ManagedPtr<TARGET_TYPE>::ManagedPtr(
1912 ManagedPtr<BDE_OTHER_TYPE> &&original,
1913 typename bsl::enable_if<bsl::is_convertible<BDE_OTHER_TYPE *,
1914 TARGET_TYPE *>::value,
1915 ManagedPtr_TraitConstraint>::type)
1916 BSLS_KEYWORD_NOEXCEPT
1917 : d_members(original.d_members)
1918#elif defined(BSLS_PLATFORM_CMP_SUN) && BSLS_PLATFORM_CMP_VERSION < 0x5130
1919 // sun compiler version 12.3 and earlier
1920 template <class TARGET_TYPE>
1921 template <class BDE_OTHER_TYPE>
1922 inline
1923 ManagedPtr<TARGET_TYPE>::ManagedPtr(
1924 bslmf::MovableRef<ManagedPtr<BDE_OTHER_TYPE> > original)
1925 BSLS_KEYWORD_NOEXCEPT
1926 : d_members(MoveUtil::access(original).d_members)
1927#else // c++03 except old (version <= 12.3) sun compilers
1928 template <class TARGET_TYPE>
1929 template <class BDE_OTHER_TYPE>
1930 inline
1931 ManagedPtr<TARGET_TYPE>::ManagedPtr(
1932 bslmf::MovableRef<ManagedPtr<BDE_OTHER_TYPE> > original,
1933 typename bsl::enable_if<bsl::is_convertible<BDE_OTHER_TYPE *,
1934 TARGET_TYPE *>::value,
1935 ManagedPtr_TraitConstraint>::type)
1936 BSLS_KEYWORD_NOEXCEPT
1937 : d_members(MoveUtil::access(original).d_members)
1938#endif
1939{
1940 // This constructor cannot be constrained using a type trait on old Sun
1941 // compilers (version <= 12.3), so we need the check here.
1942 #if defined(BSLS_PLATFORM_CMP_SUN) && BSLS_PLATFORM_CMP_VERSION < 0x5130
1943 BSLMF_ASSERT((bsl::is_convertible<BDE_OTHER_TYPE *,
1944 TARGET_TYPE *>::value));
1945 #endif
1946
1947 // To deal with the possibility of multiple inheritance, we need to
1948 // "correct" the target pointer.
1949 d_members.setAliasPtr(
1950 stripBasePointerType(
1951 static_cast<TARGET_TYPE *>(
1952 static_cast<BDE_OTHER_TYPE *>(
1953 d_members.pointer()))));
1954}
1955
1956
1957template <class TARGET_TYPE>
1958template <class ALIASED_TYPE>
1959inline
1960ManagedPtr<TARGET_TYPE>::ManagedPtr(ManagedPtr<ALIASED_TYPE>& alias,
1961 TARGET_TYPE *ptr)
1962: d_members()
1963{
1964 BSLS_ASSERT_SAFE(0 != alias.get() || 0 == ptr);
1965
1966 if (0 != ptr) {
1967 d_members.move(&alias.d_members);
1968 d_members.setAliasPtr(stripBasePointerType(ptr));
1969 }
1970}
1971
1972template <class TARGET_TYPE>
1973template <class ALIASED_TYPE>
1974inline
1975ManagedPtr<TARGET_TYPE>::ManagedPtr(
1976#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
1977 ManagedPtr<ALIASED_TYPE>&& alias,
1978#else
1979 bslmf::MovableRef<ManagedPtr<ALIASED_TYPE> > alias,
1980#endif
1981 TARGET_TYPE *ptr)
1982: d_members()
1983{
1984 ManagedPtr<ALIASED_TYPE>& lvalue = alias;
1985
1986 BSLS_ASSERT_SAFE(0 != lvalue.get() || 0 == ptr);
1987
1988 if (0 != ptr) {
1989 d_members.move(&lvalue.d_members);
1990 d_members.setAliasPtr(stripBasePointerType(ptr));
1991 }
1992}
1993
1994template <class TARGET_TYPE>
1995template <class MANAGED_TYPE, class FACTORY_TYPE>
1996inline
1997ManagedPtr<TARGET_TYPE>::ManagedPtr(MANAGED_TYPE *ptr, FACTORY_TYPE *factory)
1998: d_members(stripCompletePointerType(ptr),
1999 factory,
2000 &ManagedPtr_FactoryDeleterType<MANAGED_TYPE,
2001 FACTORY_TYPE>::type::deleter,
2002 stripBasePointerType(ptr))
2003{
2004 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2005 BSLS_ASSERT_SAFE(0 != factory || 0 == ptr);
2006}
2007
2008template <class TARGET_TYPE>
2009inline
2010ManagedPtr<TARGET_TYPE>::ManagedPtr(bsl::nullptr_t, bsl::nullptr_t)
2011: d_members()
2012{
2013}
2014
2015template <class TARGET_TYPE>
2016template <class FACTORY_TYPE>
2017inline
2018ManagedPtr<TARGET_TYPE>::ManagedPtr(bsl::nullptr_t, FACTORY_TYPE *)
2019: d_members()
2020{
2021}
2022
2023template <class TARGET_TYPE>
2024inline
2025ManagedPtr<TARGET_TYPE>::ManagedPtr(TARGET_TYPE *ptr,
2026 void *cookie,
2027 DeleterFunc deleter)
2028: d_members(stripBasePointerType(ptr), cookie, deleter)
2029{
2030 BSLS_ASSERT_SAFE(0 != deleter || 0 == ptr);
2031}
2032
2033template <class TARGET_TYPE>
2034template <class MANAGED_TYPE>
2035inline
2036ManagedPtr<TARGET_TYPE>::ManagedPtr(MANAGED_TYPE *ptr,
2037 void *cookie,
2038 DeleterFunc deleter)
2039: d_members(stripCompletePointerType(ptr),
2040 cookie,
2041 deleter,
2042 stripBasePointerType(ptr))
2043{
2044 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2045
2046 BSLS_ASSERT_SAFE(0 != deleter || 0 == ptr);
2047}
2048
2049#ifndef BDE_OMIT_INTERNAL_DEPRECATED
2050template <class TARGET_TYPE>
2051template <class MANAGED_TYPE, class MANAGED_BASE>
2052inline
2053ManagedPtr<TARGET_TYPE>::ManagedPtr(
2054 MANAGED_TYPE *ptr,
2055 void *cookie,
2056 void (*deleter)(MANAGED_BASE *, void *))
2057: d_members(stripCompletePointerType(ptr),
2058 cookie,
2059 reinterpret_cast<DeleterFunc>(deleter),
2060 stripBasePointerType(ptr))
2061{
2062 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2063 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *,
2064 const MANAGED_BASE *>::value));
2065
2066 BSLS_ASSERT_SAFE(0 != deleter || 0 == ptr);
2067}
2068
2069template <class TARGET_TYPE>
2070template <class MANAGED_TYPE,
2071 class MANAGED_BASE,
2072 class COOKIE_TYPE,
2073 class COOKIE_BASE>
2074inline
2075ManagedPtr<TARGET_TYPE>::ManagedPtr(
2076 MANAGED_TYPE *ptr,
2077 COOKIE_TYPE *cookie,
2078 void (*deleter)(MANAGED_BASE *, COOKIE_BASE *))
2079: d_members(stripCompletePointerType(ptr),
2080 static_cast<COOKIE_BASE *>(cookie),
2081 reinterpret_cast<DeleterFunc>(deleter),
2082 stripBasePointerType(ptr))
2083{
2084 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2085 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *,
2086 const MANAGED_BASE *>::value));
2087 BSLMF_ASSERT((bsl::is_convertible<COOKIE_TYPE *, COOKIE_BASE *>::value));
2088
2089 // Note that the undefined behavior embodied in the @ref reinterpret_cast
2090 // above could be removed by inserting an additional forwarding function
2091 // truly of type 'DeleterFunc' which @ref reinterpret_cast s each pointer
2092 // argument as part of its forwarding behavior. We choose not to do this
2093 // on the grounds of simple efficiency, and there is currently no known
2094 // supported compiler that we use where this does not work as desired.
2095
2096 BSLS_ASSERT_SAFE(0 != deleter || 0 == ptr);
2097}
2098#endif // BDE_OMIT_INTERNAL_DEPRECATED
2099
2100template <class TARGET_TYPE>
2101inline
2102ManagedPtr<TARGET_TYPE>::~ManagedPtr()
2103{
2104 d_members.runDeleter();
2105}
2106
2107// MANIPULATORS
2108template <class TARGET_TYPE>
2109inline
2110ManagedPtr<TARGET_TYPE>&
2111ManagedPtr<TARGET_TYPE>::operator=(ManagedPtr& rhs) BSLS_KEYWORD_NOEXCEPT
2112{
2113 d_members.moveAssign(&rhs.d_members);
2114 return *this;
2115}
2116
2117template <class TARGET_TYPE>
2118inline
2119ManagedPtr<TARGET_TYPE>&
2120ManagedPtr<TARGET_TYPE>::operator=(bslmf::MovableRef<ManagedPtr> rhs)
2121 BSLS_KEYWORD_NOEXCEPT
2122{
2123 ManagedPtr& lvalue = rhs;
2124 d_members.moveAssign(&lvalue.d_members);
2125 return *this;
2126}
2127
2128#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
2129 template <class TARGET_TYPE>
2130 template <class BDE_OTHER_TYPE>
2131 inline
2132 typename bsl::enable_if<
2133 bsl::is_convertible<BDE_OTHER_TYPE*, TARGET_TYPE*>::value,
2134 ManagedPtr<TARGET_TYPE> >::type&
2135 ManagedPtr<TARGET_TYPE>::operator =(
2136 ManagedPtr<BDE_OTHER_TYPE>&& rhs) BSLS_KEYWORD_NOEXCEPT
2137#elif defined(BSLS_PLATFORM_CMP_SUN) && BSLS_PLATFORM_CMP_VERSION < 0x5130
2138 // sun compiler version 12.3 and earlier
2139 template <class TARGET_TYPE>
2140 template <class BDE_OTHER_TYPE>
2141 inline
2142 ManagedPtr<TARGET_TYPE>&
2143 ManagedPtr<TARGET_TYPE>::operator =(
2144 bslmf::MovableRef<ManagedPtr<BDE_OTHER_TYPE> > rhs)
2145 BSLS_KEYWORD_NOEXCEPT
2146#else // c++03 except old (version <= 12.3) sun compilers
2147 template <class TARGET_TYPE>
2148 template <class BDE_OTHER_TYPE>
2149 inline
2150 typename bsl::enable_if<
2151 bsl::is_convertible<BDE_OTHER_TYPE *, TARGET_TYPE *>::value,
2152 ManagedPtr<TARGET_TYPE> >::type&
2153 ManagedPtr<TARGET_TYPE>::operator =(
2154 bslmf::MovableRef<ManagedPtr<BDE_OTHER_TYPE> > rhs)
2155 BSLS_KEYWORD_NOEXCEPT
2156#endif
2157{
2158 // This operator cannot be constrained using a type trait on Sun, so we
2159 // need the check here.
2160 #if defined(BSLS_PLATFORM_CMP_SUN) && BSLS_PLATFORM_CMP_VERSION < 0x5130
2161 BSLMF_ASSERT((bsl::is_convertible<BDE_OTHER_TYPE *,
2162 TARGET_TYPE *>::value));
2163 #endif
2164
2165 ManagedPtr<BDE_OTHER_TYPE>& lvalue = rhs;
2166 d_members.moveAssign(&lvalue.d_members);
2167
2168 // To deal with the possibility of multiple inheritance, we need to
2169 // "correct" the target pointer.
2170 d_members.setAliasPtr(
2171 stripBasePointerType(
2172 static_cast<TARGET_TYPE *>(
2173 static_cast<BDE_OTHER_TYPE *>(
2174 d_members.pointer()))));
2175
2176 return *this;
2177}
2178
2179template <class TARGET_TYPE>
2180inline
2181ManagedPtr<TARGET_TYPE>&
2182ManagedPtr<TARGET_TYPE>::operator=(ManagedPtr_Ref<TARGET_TYPE> ref)
2183 BSLS_KEYWORD_NOEXCEPT
2184{
2185 d_members.moveAssign(ref.base());
2186 d_members.setAliasPtr(stripBasePointerType(ref.target()));
2187 return *this;
2188}
2189
2190template <class TARGET_TYPE>
2191inline
2192ManagedPtr<TARGET_TYPE>&
2193ManagedPtr<TARGET_TYPE>::operator=(bsl::nullptr_t)
2194{
2195 this->reset();
2196 return *this;
2197}
2198
2199template <class TARGET_TYPE>
2200template <class REFERENCED_TYPE>
2201inline
2202ManagedPtr<TARGET_TYPE>::operator ManagedPtr_Ref<REFERENCED_TYPE>()
2203{
2204 BSLMF_ASSERT((bsl::is_convertible<TARGET_TYPE *,
2205 REFERENCED_TYPE *>::value));
2206
2207 return ManagedPtr_Ref<REFERENCED_TYPE>(&d_members,
2208 static_cast<REFERENCED_TYPE *>(
2209 static_cast<TARGET_TYPE *>(d_members.pointer())));
2210}
2211
2212template <class TARGET_TYPE>
2213inline
2214void ManagedPtr<TARGET_TYPE>::clear()
2215{
2216 reset();
2217}
2218
2219template <class TARGET_TYPE>
2220template <class MANAGED_TYPE>
2221inline
2222void ManagedPtr<TARGET_TYPE>::load(MANAGED_TYPE *ptr)
2223{
2224 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2225
2226 typedef ManagedPtr_FactoryDeleter<MANAGED_TYPE, Allocator> DeleterFactory;
2227 this->loadImp(ptr,
2228 static_cast<void *>(Default::allocator()),
2229 &DeleterFactory::deleter);
2230}
2231
2232template <class TARGET_TYPE>
2233template <class MANAGED_TYPE, class FACTORY_TYPE>
2234inline
2235void ManagedPtr<TARGET_TYPE>::load(MANAGED_TYPE *ptr, FACTORY_TYPE *factory)
2236{
2237 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2238 BSLS_ASSERT_SAFE(0 != factory || 0 == ptr);
2239
2240 typedef typename
2241 ManagedPtr_FactoryDeleterType<MANAGED_TYPE, FACTORY_TYPE>::type
2242 DeleterFactory;
2243
2244 this->loadImp(ptr, static_cast<void *>(factory), &DeleterFactory::deleter);
2245}
2246
2247template <class TARGET_TYPE>
2248template <class MANAGED_TYPE>
2249inline
2250void ManagedPtr<TARGET_TYPE>::load(MANAGED_TYPE *ptr,
2251 void *cookie,
2252 DeleterFunc deleter)
2253{
2254 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2255 BSLS_ASSERT_SAFE(0 != deleter || 0 == ptr);
2256
2257 this->loadImp(ptr, cookie, deleter);
2258}
2259
2260template <class TARGET_TYPE>
2261inline
2262void ManagedPtr<TARGET_TYPE>::load(bsl::nullptr_t, void *, DeleterFunc)
2263{
2264 this->reset();
2265}
2266
2267#ifndef BDE_OMIT_INTERNAL_DEPRECATED
2268template <class TARGET_TYPE>
2269template <class MANAGED_TYPE, class COOKIE_TYPE>
2270inline
2271void ManagedPtr<TARGET_TYPE>::load(MANAGED_TYPE *ptr,
2272 COOKIE_TYPE *cookie,
2273 DeleterFunc deleter)
2274{
2275 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2276 BSLS_ASSERT_SAFE(0 != deleter || 0 == ptr);
2277
2278 this->loadImp(ptr, static_cast<void *>(cookie), deleter);
2279}
2280
2281template <class TARGET_TYPE>
2282template <class MANAGED_TYPE, class MANAGED_BASE>
2283inline
2284void ManagedPtr<TARGET_TYPE>::load(
2285 MANAGED_TYPE *ptr,
2286 void *cookie,
2287 void (*deleter)(MANAGED_BASE *, void *))
2288{
2289 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2290 BSLMF_ASSERT((!bsl::is_void<MANAGED_BASE>::value));
2291 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, MANAGED_BASE *>::value));
2292 BSLS_ASSERT_SAFE(0 != deleter || 0 == ptr);
2293
2294 this->loadImp(ptr, cookie, reinterpret_cast<DeleterFunc>(deleter));
2295}
2296
2297template <class TARGET_TYPE>
2298template <class MANAGED_TYPE,
2299 class MANAGED_BASE,
2300 class COOKIE_TYPE,
2301 class COOKIE_BASE>
2302inline
2303void ManagedPtr<TARGET_TYPE>::load(
2304 MANAGED_TYPE *ptr,
2305 COOKIE_TYPE *cookie,
2306 void (*deleter)(MANAGED_BASE *, COOKIE_BASE *))
2307{
2308 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, TARGET_TYPE *>::value));
2309 BSLMF_ASSERT((bsl::is_convertible<MANAGED_TYPE *, MANAGED_BASE *>::value));
2310 BSLMF_ASSERT((bsl::is_convertible<COOKIE_TYPE *, COOKIE_BASE *>::value));
2311 BSLS_ASSERT_SAFE(0 != deleter || 0 == ptr);
2312
2313 this->loadImp(ptr,
2314 static_cast<void *>(static_cast<COOKIE_BASE *>(cookie)),
2315 reinterpret_cast<DeleterFunc>(deleter));
2316}
2317#endif // BDE_OMIT_INTERNAL_DEPRECATED
2318
2319template <class TARGET_TYPE>
2320template <class ALIASED_TYPE>
2321void ManagedPtr<TARGET_TYPE>::loadAlias(ManagedPtr<ALIASED_TYPE>& alias,
2322 TARGET_TYPE *ptr)
2323{
2324 BSLS_ASSERT_SAFE(!ptr == !alias.get()); // both null or both non-null
2325
2326 if (ptr && alias.d_members.pointer()) {
2327 d_members.moveAssign(&alias.d_members);
2328 d_members.setAliasPtr(stripBasePointerType(ptr));
2329 }
2330 else {
2331 d_members.runDeleter();
2332 d_members.clear();
2333 }
2334}
2335
2336template <class TARGET_TYPE>
2337ManagedPtr_PairProxy<TARGET_TYPE, ManagedPtrDeleter>
2338ManagedPtr<TARGET_TYPE>::release()
2339{
2340 typedef ManagedPtr_PairProxy<TARGET_TYPE, ManagedPtrDeleter> ResultType;
2341
2342 TARGET_TYPE *p = get();
2343
2344 // The behavior would be undefined if 'd_members.deleter()' were called
2345 // when 'p' is null.
2346
2347 if (p) {
2348 ResultType result = { p, d_members.deleter() };
2349 d_members.clear();
2350 return result; // RETURN
2351 }
2352 ResultType result = { p, ManagedPtrDeleter() };
2353 return result;
2354}
2355
2356template <class TARGET_TYPE>
2357TARGET_TYPE *ManagedPtr<TARGET_TYPE>::release(ManagedPtrDeleter *deleter)
2358{
2359 BSLS_ASSERT_SAFE(deleter);
2360
2361 TARGET_TYPE *result = get();
2362
2363 // The behavior is undefined if 'd_members.deleter()' is called when
2364 // 'result' is null.
2365
2366 if (result) {
2367 *deleter = d_members.deleter();
2368 d_members.clear();
2369 }
2370 return result;
2371}
2372
2373template <class TARGET_TYPE>
2374inline
2375void ManagedPtr<TARGET_TYPE>::reset()
2376{
2377 d_members.runDeleter();
2378 d_members.clear();
2379}
2380
2381template <class TARGET_TYPE>
2382inline
2383void ManagedPtr<TARGET_TYPE>::swap(ManagedPtr& other)
2384{
2385 d_members.swap(other.d_members);
2386}
2387
2388// ACCESSORS
2389template <class TARGET_TYPE>
2390inline
2391bool ManagedPtr<TARGET_TYPE>::operator==(bsl::nullptr_t) const
2392{
2393 return !d_members.pointer();
2394}
2395
2396template <class TARGET_TYPE>
2397inline
2398bool ManagedPtr<TARGET_TYPE>::operator!=(bsl::nullptr_t) const
2399{
2400 return d_members.pointer();
2401}
2402
2403template <class TARGET_TYPE>
2404inline
2405#if defined(BSLS_PLATFORM_CMP_IBM) // last confirmed with xlC 12.1
2406ManagedPtr<TARGET_TYPE>::operator typename ManagedPtr::BoolType() const
2407#else
2408ManagedPtr<TARGET_TYPE>::operator BoolType() const
2409#endif
2410{
2411 return d_members.pointer()
2412 ? bsls::UnspecifiedBool<ManagedPtr>::trueValue()
2413 : bsls::UnspecifiedBool<ManagedPtr>::falseValue();
2414}
2415
2416template <class TARGET_TYPE>
2417inline
2418typename bslmf::AddReference<TARGET_TYPE>::Type
2419ManagedPtr<TARGET_TYPE>::operator*() const
2420{
2421 BSLS_ASSERT_SAFE(d_members.pointer());
2422
2423 return *static_cast<TARGET_TYPE *>(d_members.pointer());
2424}
2425
2426template <class TARGET_TYPE>
2427inline
2428TARGET_TYPE *ManagedPtr<TARGET_TYPE>::operator->() const
2429{
2430 return static_cast<TARGET_TYPE *>(d_members.pointer());
2431}
2432
2433template <class TARGET_TYPE>
2434inline
2435const ManagedPtrDeleter& ManagedPtr<TARGET_TYPE>::deleter() const
2436{
2437 BSLS_ASSERT_SAFE(d_members.pointer());
2438
2439 return d_members.deleter();
2440}
2441
2442template <class TARGET_TYPE>
2443inline
2444TARGET_TYPE *ManagedPtr<TARGET_TYPE>::get() const
2445{
2446 return static_cast<TARGET_TYPE *>(d_members.pointer());
2447}
2448
2449template <class TARGET_TYPE>
2450inline
2451TARGET_TYPE *ManagedPtr<TARGET_TYPE>::ptr() const
2452{
2453 return get();
2454}
2455
2456// FREE FUNCTIONS
2457template <class TARGET_TYPE>
2458inline
2459void swap(ManagedPtr<TARGET_TYPE>& a, ManagedPtr<TARGET_TYPE>& b)
2460{
2461 a.swap(b);
2462}
2463
2464 // --------------------
2465 // struct ManagedPtrUtil
2466 // --------------------
2467
2468template <class ELEMENT_TYPE>
2469inline
2470void ManagedPtrUtil::allocatorDeleter(void *object, void *allocator)
2471{
2472 BSLS_ASSERT(0 != object);
2473 BSLS_ASSERT(0 != allocator);
2474
2475 AllocatorUtil::deleteObject(static_cast<Allocator *>(allocator),
2476 static_cast<ELEMENT_TYPE *>(object));
2477}
2478
2479#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
2480// {{{ BEGIN GENERATED CODE
2481// Command line: sim_cpp11_features.pl bslma_managedptr.h
2482#ifndef BSLMA_MANAGEDPTR_VARIADIC_LIMIT
2483#define BSLMA_MANAGEDPTR_VARIADIC_LIMIT 14
2484#endif
2485#ifndef BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B
2486#define BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B BSLMA_MANAGEDPTR_VARIADIC_LIMIT
2487#endif
2488
2489#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 0
2490template <class ELEMENT_TYPE, class ALLOCATOR>
2491inline
2492typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2493 ManagedPtr<ELEMENT_TYPE> >::type
2494ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator)
2495{
2496 return allocateManaged<ELEMENT_TYPE>(
2497 allocator.mechanism());
2498}
2499#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 0
2500
2501#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 1
2502template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01>
2503inline
2504typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2505 ManagedPtr<ELEMENT_TYPE> >::type
2506ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2507 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01)
2508{
2509 return allocateManaged<ELEMENT_TYPE>(
2510 allocator.mechanism(),
2511 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01));
2512}
2513#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 1
2514
2515#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 2
2516template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2517 class ARGS_02>
2518inline
2519typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2520 ManagedPtr<ELEMENT_TYPE> >::type
2521ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2522 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2523 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02)
2524{
2525 return allocateManaged<ELEMENT_TYPE>(
2526 allocator.mechanism(),
2527 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2528 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02));
2529}
2530#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 2
2531
2532#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 3
2533template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2534 class ARGS_02,
2535 class ARGS_03>
2536inline
2537typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2538 ManagedPtr<ELEMENT_TYPE> >::type
2539ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2540 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2541 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2542 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03)
2543{
2544 return allocateManaged<ELEMENT_TYPE>(
2545 allocator.mechanism(),
2546 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2547 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2548 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03));
2549}
2550#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 3
2551
2552#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 4
2553template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2554 class ARGS_02,
2555 class ARGS_03,
2556 class ARGS_04>
2557inline
2558typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2559 ManagedPtr<ELEMENT_TYPE> >::type
2560ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2561 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2562 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2563 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2564 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04)
2565{
2566 return allocateManaged<ELEMENT_TYPE>(
2567 allocator.mechanism(),
2568 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2569 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2570 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2571 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04));
2572}
2573#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 4
2574
2575#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 5
2576template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2577 class ARGS_02,
2578 class ARGS_03,
2579 class ARGS_04,
2580 class ARGS_05>
2581inline
2582typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2583 ManagedPtr<ELEMENT_TYPE> >::type
2584ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2585 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2586 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2587 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2588 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2589 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05)
2590{
2591 return allocateManaged<ELEMENT_TYPE>(
2592 allocator.mechanism(),
2593 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2594 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2595 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2596 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2597 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05));
2598}
2599#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 5
2600
2601#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 6
2602template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2603 class ARGS_02,
2604 class ARGS_03,
2605 class ARGS_04,
2606 class ARGS_05,
2607 class ARGS_06>
2608inline
2609typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2610 ManagedPtr<ELEMENT_TYPE> >::type
2611ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2612 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2613 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2614 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2615 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2616 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
2617 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06)
2618{
2619 return allocateManaged<ELEMENT_TYPE>(
2620 allocator.mechanism(),
2621 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2622 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2623 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2624 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2625 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
2626 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06));
2627}
2628#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 6
2629
2630#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 7
2631template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2632 class ARGS_02,
2633 class ARGS_03,
2634 class ARGS_04,
2635 class ARGS_05,
2636 class ARGS_06,
2637 class ARGS_07>
2638inline
2639typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2640 ManagedPtr<ELEMENT_TYPE> >::type
2641ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2642 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2643 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2644 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2645 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2646 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
2647 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
2648 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07)
2649{
2650 return allocateManaged<ELEMENT_TYPE>(
2651 allocator.mechanism(),
2652 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2653 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2654 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2655 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2656 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
2657 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
2658 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07));
2659}
2660#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 7
2661
2662#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 8
2663template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2664 class ARGS_02,
2665 class ARGS_03,
2666 class ARGS_04,
2667 class ARGS_05,
2668 class ARGS_06,
2669 class ARGS_07,
2670 class ARGS_08>
2671inline
2672typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2673 ManagedPtr<ELEMENT_TYPE> >::type
2674ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2675 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2676 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2677 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2678 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2679 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
2680 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
2681 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
2682 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08)
2683{
2684 return allocateManaged<ELEMENT_TYPE>(
2685 allocator.mechanism(),
2686 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2687 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2688 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2689 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2690 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
2691 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
2692 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
2693 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08));
2694}
2695#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 8
2696
2697#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 9
2698template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2699 class ARGS_02,
2700 class ARGS_03,
2701 class ARGS_04,
2702 class ARGS_05,
2703 class ARGS_06,
2704 class ARGS_07,
2705 class ARGS_08,
2706 class ARGS_09>
2707inline
2708typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2709 ManagedPtr<ELEMENT_TYPE> >::type
2710ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2711 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2712 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2713 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2714 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2715 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
2716 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
2717 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
2718 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
2719 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09)
2720{
2721 return allocateManaged<ELEMENT_TYPE>(
2722 allocator.mechanism(),
2723 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2724 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2725 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2726 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2727 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
2728 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
2729 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
2730 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
2731 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09));
2732}
2733#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 9
2734
2735#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 10
2736template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2737 class ARGS_02,
2738 class ARGS_03,
2739 class ARGS_04,
2740 class ARGS_05,
2741 class ARGS_06,
2742 class ARGS_07,
2743 class ARGS_08,
2744 class ARGS_09,
2745 class ARGS_10>
2746inline
2747typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2748 ManagedPtr<ELEMENT_TYPE> >::type
2749ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2750 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2751 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2752 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2753 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2754 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
2755 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
2756 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
2757 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
2758 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
2759 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10)
2760{
2761 return allocateManaged<ELEMENT_TYPE>(
2762 allocator.mechanism(),
2763 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2764 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2765 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2766 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2767 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
2768 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
2769 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
2770 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
2771 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
2772 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10));
2773}
2774#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 10
2775
2776#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 11
2777template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2778 class ARGS_02,
2779 class ARGS_03,
2780 class ARGS_04,
2781 class ARGS_05,
2782 class ARGS_06,
2783 class ARGS_07,
2784 class ARGS_08,
2785 class ARGS_09,
2786 class ARGS_10,
2787 class ARGS_11>
2788inline
2789typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2790 ManagedPtr<ELEMENT_TYPE> >::type
2791ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2792 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2793 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2794 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2795 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2796 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
2797 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
2798 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
2799 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
2800 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
2801 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
2802 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11)
2803{
2804 return allocateManaged<ELEMENT_TYPE>(
2805 allocator.mechanism(),
2806 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2807 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2808 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2809 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2810 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
2811 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
2812 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
2813 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
2814 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
2815 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
2816 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11));
2817}
2818#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 11
2819
2820#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 12
2821template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2822 class ARGS_02,
2823 class ARGS_03,
2824 class ARGS_04,
2825 class ARGS_05,
2826 class ARGS_06,
2827 class ARGS_07,
2828 class ARGS_08,
2829 class ARGS_09,
2830 class ARGS_10,
2831 class ARGS_11,
2832 class ARGS_12>
2833inline
2834typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2835 ManagedPtr<ELEMENT_TYPE> >::type
2836ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2837 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2838 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2839 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2840 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2841 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
2842 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
2843 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
2844 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
2845 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
2846 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
2847 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
2848 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12)
2849{
2850 return allocateManaged<ELEMENT_TYPE>(
2851 allocator.mechanism(),
2852 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2853 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2854 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2855 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2856 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
2857 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
2858 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
2859 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
2860 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
2861 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
2862 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
2863 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12));
2864}
2865#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 12
2866
2867#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 13
2868template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2869 class ARGS_02,
2870 class ARGS_03,
2871 class ARGS_04,
2872 class ARGS_05,
2873 class ARGS_06,
2874 class ARGS_07,
2875 class ARGS_08,
2876 class ARGS_09,
2877 class ARGS_10,
2878 class ARGS_11,
2879 class ARGS_12,
2880 class ARGS_13>
2881inline
2882typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2883 ManagedPtr<ELEMENT_TYPE> >::type
2884ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2885 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2886 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2887 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2888 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2889 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
2890 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
2891 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
2892 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
2893 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
2894 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
2895 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
2896 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
2897 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13)
2898{
2899 return allocateManaged<ELEMENT_TYPE>(
2900 allocator.mechanism(),
2901 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2902 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2903 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2904 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2905 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
2906 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
2907 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
2908 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
2909 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
2910 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
2911 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
2912 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12),
2913 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, args_13));
2914}
2915#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 13
2916
2917#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 14
2918template <class ELEMENT_TYPE, class ALLOCATOR, class ARGS_01,
2919 class ARGS_02,
2920 class ARGS_03,
2921 class ARGS_04,
2922 class ARGS_05,
2923 class ARGS_06,
2924 class ARGS_07,
2925 class ARGS_08,
2926 class ARGS_09,
2927 class ARGS_10,
2928 class ARGS_11,
2929 class ARGS_12,
2930 class ARGS_13,
2931 class ARGS_14>
2932inline
2933typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
2934 ManagedPtr<ELEMENT_TYPE> >::type
2935ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
2936 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
2937 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
2938 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
2939 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
2940 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
2941 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
2942 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
2943 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
2944 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
2945 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
2946 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
2947 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
2948 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
2949 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14)
2950{
2951 return allocateManaged<ELEMENT_TYPE>(
2952 allocator.mechanism(),
2953 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
2954 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
2955 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
2956 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
2957 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
2958 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
2959 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
2960 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
2961 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
2962 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
2963 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
2964 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12),
2965 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, args_13),
2966 BSLS_COMPILERFEATURES_FORWARD(ARGS_14, args_14));
2967}
2968#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 14
2969
2970
2971#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 0
2972template <class ELEMENT_TYPE>
2973inline
2974ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
2975 )
2976{
2977 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
2978
2979 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
2980
2981 UnqualElem *objPtr =
2982 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
2983
2984 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
2985 defaultAllocator, objPtr);
2986
2987 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
2988 );
2989 proctor.release();
2990
2991 return ManagedPtr<ELEMENT_TYPE>(objPtr,
2992 defaultAllocator,
2993 &allocatorDeleter<UnqualElem>);
2994}
2995#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 0
2996
2997#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 1
2998template <class ELEMENT_TYPE, class ARGS_01>
2999inline
3000ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3001 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01)
3002{
3003 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3004
3005 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3006
3007 UnqualElem *objPtr =
3008 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3009
3010 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3011 defaultAllocator, objPtr);
3012
3013 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3014 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01));
3015 proctor.release();
3016
3017 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3018 defaultAllocator,
3019 &allocatorDeleter<UnqualElem>);
3020}
3021#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 1
3022
3023#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 2
3024template <class ELEMENT_TYPE, class ARGS_01,
3025 class ARGS_02>
3026inline
3027ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3028 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3029 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02)
3030{
3031 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3032
3033 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3034
3035 UnqualElem *objPtr =
3036 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3037
3038 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3039 defaultAllocator, objPtr);
3040
3041 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3042 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3043 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02));
3044 proctor.release();
3045
3046 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3047 defaultAllocator,
3048 &allocatorDeleter<UnqualElem>);
3049}
3050#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 2
3051
3052#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 3
3053template <class ELEMENT_TYPE, class ARGS_01,
3054 class ARGS_02,
3055 class ARGS_03>
3056inline
3057ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3058 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3059 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3060 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03)
3061{
3062 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3063
3064 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3065
3066 UnqualElem *objPtr =
3067 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3068
3069 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3070 defaultAllocator, objPtr);
3071
3072 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3073 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3074 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3075 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03));
3076 proctor.release();
3077
3078 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3079 defaultAllocator,
3080 &allocatorDeleter<UnqualElem>);
3081}
3082#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 3
3083
3084#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 4
3085template <class ELEMENT_TYPE, class ARGS_01,
3086 class ARGS_02,
3087 class ARGS_03,
3088 class ARGS_04>
3089inline
3090ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3091 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3092 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3093 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3094 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04)
3095{
3096 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3097
3098 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3099
3100 UnqualElem *objPtr =
3101 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3102
3103 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3104 defaultAllocator, objPtr);
3105
3106 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3107 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3108 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3109 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3110 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04));
3111 proctor.release();
3112
3113 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3114 defaultAllocator,
3115 &allocatorDeleter<UnqualElem>);
3116}
3117#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 4
3118
3119#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 5
3120template <class ELEMENT_TYPE, class ARGS_01,
3121 class ARGS_02,
3122 class ARGS_03,
3123 class ARGS_04,
3124 class ARGS_05>
3125inline
3126ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3127 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3128 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3129 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3130 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3131 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05)
3132{
3133 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3134
3135 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3136
3137 UnqualElem *objPtr =
3138 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3139
3140 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3141 defaultAllocator, objPtr);
3142
3143 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3144 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3145 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3146 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3147 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3148 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05));
3149 proctor.release();
3150
3151 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3152 defaultAllocator,
3153 &allocatorDeleter<UnqualElem>);
3154}
3155#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 5
3156
3157#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 6
3158template <class ELEMENT_TYPE, class ARGS_01,
3159 class ARGS_02,
3160 class ARGS_03,
3161 class ARGS_04,
3162 class ARGS_05,
3163 class ARGS_06>
3164inline
3165ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3166 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3167 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3168 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3169 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3170 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3171 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06)
3172{
3173 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3174
3175 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3176
3177 UnqualElem *objPtr =
3178 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3179
3180 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3181 defaultAllocator, objPtr);
3182
3183 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3184 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3185 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3186 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3187 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3188 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3189 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06));
3190 proctor.release();
3191
3192 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3193 defaultAllocator,
3194 &allocatorDeleter<UnqualElem>);
3195}
3196#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 6
3197
3198#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 7
3199template <class ELEMENT_TYPE, class ARGS_01,
3200 class ARGS_02,
3201 class ARGS_03,
3202 class ARGS_04,
3203 class ARGS_05,
3204 class ARGS_06,
3205 class ARGS_07>
3206inline
3207ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3208 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3209 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3210 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3211 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3212 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3213 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3214 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07)
3215{
3216 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3217
3218 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3219
3220 UnqualElem *objPtr =
3221 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3222
3223 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3224 defaultAllocator, objPtr);
3225
3226 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3227 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3228 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3229 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3230 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3231 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3232 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3233 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07));
3234 proctor.release();
3235
3236 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3237 defaultAllocator,
3238 &allocatorDeleter<UnqualElem>);
3239}
3240#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 7
3241
3242#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 8
3243template <class ELEMENT_TYPE, class ARGS_01,
3244 class ARGS_02,
3245 class ARGS_03,
3246 class ARGS_04,
3247 class ARGS_05,
3248 class ARGS_06,
3249 class ARGS_07,
3250 class ARGS_08>
3251inline
3252ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3253 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3254 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3255 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3256 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3257 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3258 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3259 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3260 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08)
3261{
3262 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3263
3264 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3265
3266 UnqualElem *objPtr =
3267 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3268
3269 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3270 defaultAllocator, objPtr);
3271
3272 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3273 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3274 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3275 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3276 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3277 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3278 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3279 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3280 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08));
3281 proctor.release();
3282
3283 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3284 defaultAllocator,
3285 &allocatorDeleter<UnqualElem>);
3286}
3287#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 8
3288
3289#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 9
3290template <class ELEMENT_TYPE, class ARGS_01,
3291 class ARGS_02,
3292 class ARGS_03,
3293 class ARGS_04,
3294 class ARGS_05,
3295 class ARGS_06,
3296 class ARGS_07,
3297 class ARGS_08,
3298 class ARGS_09>
3299inline
3300ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3301 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3302 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3303 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3304 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3305 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3306 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3307 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3308 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
3309 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09)
3310{
3311 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3312
3313 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3314
3315 UnqualElem *objPtr =
3316 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3317
3318 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3319 defaultAllocator, objPtr);
3320
3321 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3322 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3323 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3324 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3325 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3326 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3327 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3328 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3329 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
3330 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09));
3331 proctor.release();
3332
3333 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3334 defaultAllocator,
3335 &allocatorDeleter<UnqualElem>);
3336}
3337#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 9
3338
3339#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 10
3340template <class ELEMENT_TYPE, class ARGS_01,
3341 class ARGS_02,
3342 class ARGS_03,
3343 class ARGS_04,
3344 class ARGS_05,
3345 class ARGS_06,
3346 class ARGS_07,
3347 class ARGS_08,
3348 class ARGS_09,
3349 class ARGS_10>
3350inline
3351ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3352 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3353 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3354 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3355 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3356 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3357 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3358 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3359 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
3360 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
3361 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10)
3362{
3363 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3364
3365 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3366
3367 UnqualElem *objPtr =
3368 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3369
3370 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3371 defaultAllocator, objPtr);
3372
3373 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3374 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3375 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3376 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3377 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3378 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3379 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3380 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3381 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
3382 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
3383 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10));
3384 proctor.release();
3385
3386 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3387 defaultAllocator,
3388 &allocatorDeleter<UnqualElem>);
3389}
3390#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 10
3391
3392#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 11
3393template <class ELEMENT_TYPE, class ARGS_01,
3394 class ARGS_02,
3395 class ARGS_03,
3396 class ARGS_04,
3397 class ARGS_05,
3398 class ARGS_06,
3399 class ARGS_07,
3400 class ARGS_08,
3401 class ARGS_09,
3402 class ARGS_10,
3403 class ARGS_11>
3404inline
3405ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3406 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3407 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3408 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3409 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3410 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3411 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3412 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3413 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
3414 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
3415 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
3416 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11)
3417{
3418 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3419
3420 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3421
3422 UnqualElem *objPtr =
3423 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3424
3425 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3426 defaultAllocator, objPtr);
3427
3428 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3429 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3430 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3431 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3432 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3433 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3434 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3435 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3436 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
3437 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
3438 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
3439 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11));
3440 proctor.release();
3441
3442 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3443 defaultAllocator,
3444 &allocatorDeleter<UnqualElem>);
3445}
3446#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 11
3447
3448#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 12
3449template <class ELEMENT_TYPE, class ARGS_01,
3450 class ARGS_02,
3451 class ARGS_03,
3452 class ARGS_04,
3453 class ARGS_05,
3454 class ARGS_06,
3455 class ARGS_07,
3456 class ARGS_08,
3457 class ARGS_09,
3458 class ARGS_10,
3459 class ARGS_11,
3460 class ARGS_12>
3461inline
3462ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3463 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3464 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3465 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3466 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3467 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3468 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3469 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3470 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
3471 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
3472 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
3473 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
3474 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12)
3475{
3476 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3477
3478 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3479
3480 UnqualElem *objPtr =
3481 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3482
3483 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3484 defaultAllocator, objPtr);
3485
3486 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3487 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3488 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3489 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3490 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3491 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3492 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3493 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3494 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
3495 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
3496 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
3497 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
3498 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12));
3499 proctor.release();
3500
3501 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3502 defaultAllocator,
3503 &allocatorDeleter<UnqualElem>);
3504}
3505#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 12
3506
3507#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 13
3508template <class ELEMENT_TYPE, class ARGS_01,
3509 class ARGS_02,
3510 class ARGS_03,
3511 class ARGS_04,
3512 class ARGS_05,
3513 class ARGS_06,
3514 class ARGS_07,
3515 class ARGS_08,
3516 class ARGS_09,
3517 class ARGS_10,
3518 class ARGS_11,
3519 class ARGS_12,
3520 class ARGS_13>
3521inline
3522ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3523 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3524 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3525 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3526 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3527 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3528 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3529 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3530 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
3531 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
3532 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
3533 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
3534 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
3535 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13)
3536{
3537 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3538
3539 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3540
3541 UnqualElem *objPtr =
3542 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3543
3544 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3545 defaultAllocator, objPtr);
3546
3547 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3548 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3549 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3550 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3551 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3552 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3553 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3554 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3555 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
3556 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
3557 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
3558 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
3559 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12),
3560 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, args_13));
3561 proctor.release();
3562
3563 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3564 defaultAllocator,
3565 &allocatorDeleter<UnqualElem>);
3566}
3567#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 13
3568
3569#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 14
3570template <class ELEMENT_TYPE, class ARGS_01,
3571 class ARGS_02,
3572 class ARGS_03,
3573 class ARGS_04,
3574 class ARGS_05,
3575 class ARGS_06,
3576 class ARGS_07,
3577 class ARGS_08,
3578 class ARGS_09,
3579 class ARGS_10,
3580 class ARGS_11,
3581 class ARGS_12,
3582 class ARGS_13,
3583 class ARGS_14>
3584inline
3585ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
3586 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3587 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3588 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3589 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3590 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3591 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3592 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3593 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
3594 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
3595 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
3596 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
3597 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
3598 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
3599 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14)
3600{
3601 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
3602
3603 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3604
3605 UnqualElem *objPtr =
3606 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
3607
3608 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
3609 defaultAllocator, objPtr);
3610
3611 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
3612 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3613 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3614 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3615 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3616 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3617 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3618 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3619 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
3620 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
3621 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
3622 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
3623 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12),
3624 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, args_13),
3625 BSLS_COMPILERFEATURES_FORWARD(ARGS_14, args_14));
3626 proctor.release();
3627
3628 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3629 defaultAllocator,
3630 &allocatorDeleter<UnqualElem>);
3631}
3632#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 14
3633
3634
3635#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 0
3636template <class ELEMENT_TYPE>
3637inline
3638ManagedPtr<ELEMENT_TYPE>
3639ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator)
3640{
3641 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3642
3643 allocator = bslma::Default::allocator(allocator);
3644
3645 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3646 allocator);
3647
3648 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3649 allocator,
3650 &allocatorDeleter<UnqualElem>);
3651}
3652#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 0
3653
3654#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 1
3655template <class ELEMENT_TYPE, class ARGS_01>
3656inline
3657ManagedPtr<ELEMENT_TYPE>
3658ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3659 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01)
3660{
3661 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3662
3663 allocator = bslma::Default::allocator(allocator);
3664
3665 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3666 allocator,
3667 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01));
3668
3669 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3670 allocator,
3671 &allocatorDeleter<UnqualElem>);
3672}
3673#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 1
3674
3675#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 2
3676template <class ELEMENT_TYPE, class ARGS_01,
3677 class ARGS_02>
3678inline
3679ManagedPtr<ELEMENT_TYPE>
3680ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3681 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3682 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02)
3683{
3684 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3685
3686 allocator = bslma::Default::allocator(allocator);
3687
3688 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3689 allocator,
3690 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3691 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02));
3692
3693 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3694 allocator,
3695 &allocatorDeleter<UnqualElem>);
3696}
3697#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 2
3698
3699#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 3
3700template <class ELEMENT_TYPE, class ARGS_01,
3701 class ARGS_02,
3702 class ARGS_03>
3703inline
3704ManagedPtr<ELEMENT_TYPE>
3705ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3706 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3707 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3708 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03)
3709{
3710 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3711
3712 allocator = bslma::Default::allocator(allocator);
3713
3714 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3715 allocator,
3716 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3717 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3718 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03));
3719
3720 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3721 allocator,
3722 &allocatorDeleter<UnqualElem>);
3723}
3724#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 3
3725
3726#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 4
3727template <class ELEMENT_TYPE, class ARGS_01,
3728 class ARGS_02,
3729 class ARGS_03,
3730 class ARGS_04>
3731inline
3732ManagedPtr<ELEMENT_TYPE>
3733ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3734 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3735 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3736 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3737 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04)
3738{
3739 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3740
3741 allocator = bslma::Default::allocator(allocator);
3742
3743 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3744 allocator,
3745 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3746 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3747 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3748 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04));
3749
3750 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3751 allocator,
3752 &allocatorDeleter<UnqualElem>);
3753}
3754#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 4
3755
3756#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 5
3757template <class ELEMENT_TYPE, class ARGS_01,
3758 class ARGS_02,
3759 class ARGS_03,
3760 class ARGS_04,
3761 class ARGS_05>
3762inline
3763ManagedPtr<ELEMENT_TYPE>
3764ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3765 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3766 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3767 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3768 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3769 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05)
3770{
3771 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3772
3773 allocator = bslma::Default::allocator(allocator);
3774
3775 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3776 allocator,
3777 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3778 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3779 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3780 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3781 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05));
3782
3783 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3784 allocator,
3785 &allocatorDeleter<UnqualElem>);
3786}
3787#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 5
3788
3789#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 6
3790template <class ELEMENT_TYPE, class ARGS_01,
3791 class ARGS_02,
3792 class ARGS_03,
3793 class ARGS_04,
3794 class ARGS_05,
3795 class ARGS_06>
3796inline
3797ManagedPtr<ELEMENT_TYPE>
3798ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3799 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3800 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3801 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3802 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3803 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3804 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06)
3805{
3806 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3807
3808 allocator = bslma::Default::allocator(allocator);
3809
3810 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3811 allocator,
3812 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3813 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3814 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3815 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3816 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3817 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06));
3818
3819 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3820 allocator,
3821 &allocatorDeleter<UnqualElem>);
3822}
3823#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 6
3824
3825#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 7
3826template <class ELEMENT_TYPE, class ARGS_01,
3827 class ARGS_02,
3828 class ARGS_03,
3829 class ARGS_04,
3830 class ARGS_05,
3831 class ARGS_06,
3832 class ARGS_07>
3833inline
3834ManagedPtr<ELEMENT_TYPE>
3835ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3836 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3837 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3838 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3839 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3840 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3841 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3842 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07)
3843{
3844 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3845
3846 allocator = bslma::Default::allocator(allocator);
3847
3848 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3849 allocator,
3850 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3851 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3852 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3853 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3854 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3855 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3856 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07));
3857
3858 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3859 allocator,
3860 &allocatorDeleter<UnqualElem>);
3861}
3862#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 7
3863
3864#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 8
3865template <class ELEMENT_TYPE, class ARGS_01,
3866 class ARGS_02,
3867 class ARGS_03,
3868 class ARGS_04,
3869 class ARGS_05,
3870 class ARGS_06,
3871 class ARGS_07,
3872 class ARGS_08>
3873inline
3874ManagedPtr<ELEMENT_TYPE>
3875ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3876 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3877 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3878 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3879 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3880 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3881 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3882 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3883 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08)
3884{
3885 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3886
3887 allocator = bslma::Default::allocator(allocator);
3888
3889 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3890 allocator,
3891 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3892 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3893 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3894 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3895 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3896 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3897 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3898 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08));
3899
3900 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3901 allocator,
3902 &allocatorDeleter<UnqualElem>);
3903}
3904#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 8
3905
3906#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 9
3907template <class ELEMENT_TYPE, class ARGS_01,
3908 class ARGS_02,
3909 class ARGS_03,
3910 class ARGS_04,
3911 class ARGS_05,
3912 class ARGS_06,
3913 class ARGS_07,
3914 class ARGS_08,
3915 class ARGS_09>
3916inline
3917ManagedPtr<ELEMENT_TYPE>
3918ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3919 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3920 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3921 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3922 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3923 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3924 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3925 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3926 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
3927 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09)
3928{
3929 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3930
3931 allocator = bslma::Default::allocator(allocator);
3932
3933 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3934 allocator,
3935 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3936 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3937 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3938 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3939 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3940 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3941 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3942 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
3943 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09));
3944
3945 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3946 allocator,
3947 &allocatorDeleter<UnqualElem>);
3948}
3949#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 9
3950
3951#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 10
3952template <class ELEMENT_TYPE, class ARGS_01,
3953 class ARGS_02,
3954 class ARGS_03,
3955 class ARGS_04,
3956 class ARGS_05,
3957 class ARGS_06,
3958 class ARGS_07,
3959 class ARGS_08,
3960 class ARGS_09,
3961 class ARGS_10>
3962inline
3963ManagedPtr<ELEMENT_TYPE>
3964ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
3965 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
3966 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
3967 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
3968 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
3969 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
3970 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
3971 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
3972 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
3973 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
3974 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10)
3975{
3976 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
3977
3978 allocator = bslma::Default::allocator(allocator);
3979
3980 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
3981 allocator,
3982 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
3983 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
3984 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
3985 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
3986 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
3987 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
3988 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
3989 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
3990 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
3991 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10));
3992
3993 return ManagedPtr<ELEMENT_TYPE>(objPtr,
3994 allocator,
3995 &allocatorDeleter<UnqualElem>);
3996}
3997#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 10
3998
3999#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 11
4000template <class ELEMENT_TYPE, class ARGS_01,
4001 class ARGS_02,
4002 class ARGS_03,
4003 class ARGS_04,
4004 class ARGS_05,
4005 class ARGS_06,
4006 class ARGS_07,
4007 class ARGS_08,
4008 class ARGS_09,
4009 class ARGS_10,
4010 class ARGS_11>
4011inline
4012ManagedPtr<ELEMENT_TYPE>
4013ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
4014 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
4015 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
4016 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
4017 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
4018 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
4019 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
4020 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
4021 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
4022 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
4023 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
4024 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11)
4025{
4026 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
4027
4028 allocator = bslma::Default::allocator(allocator);
4029
4030 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
4031 allocator,
4032 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
4033 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
4034 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
4035 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
4036 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
4037 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
4038 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
4039 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
4040 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
4041 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
4042 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11));
4043
4044 return ManagedPtr<ELEMENT_TYPE>(objPtr,
4045 allocator,
4046 &allocatorDeleter<UnqualElem>);
4047}
4048#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 11
4049
4050#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 12
4051template <class ELEMENT_TYPE, class ARGS_01,
4052 class ARGS_02,
4053 class ARGS_03,
4054 class ARGS_04,
4055 class ARGS_05,
4056 class ARGS_06,
4057 class ARGS_07,
4058 class ARGS_08,
4059 class ARGS_09,
4060 class ARGS_10,
4061 class ARGS_11,
4062 class ARGS_12>
4063inline
4064ManagedPtr<ELEMENT_TYPE>
4065ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
4066 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
4067 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
4068 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
4069 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
4070 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
4071 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
4072 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
4073 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
4074 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
4075 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
4076 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
4077 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12)
4078{
4079 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
4080
4081 allocator = bslma::Default::allocator(allocator);
4082
4083 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
4084 allocator,
4085 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
4086 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
4087 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
4088 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
4089 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
4090 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
4091 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
4092 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
4093 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
4094 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
4095 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
4096 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12));
4097
4098 return ManagedPtr<ELEMENT_TYPE>(objPtr,
4099 allocator,
4100 &allocatorDeleter<UnqualElem>);
4101}
4102#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 12
4103
4104#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 13
4105template <class ELEMENT_TYPE, class ARGS_01,
4106 class ARGS_02,
4107 class ARGS_03,
4108 class ARGS_04,
4109 class ARGS_05,
4110 class ARGS_06,
4111 class ARGS_07,
4112 class ARGS_08,
4113 class ARGS_09,
4114 class ARGS_10,
4115 class ARGS_11,
4116 class ARGS_12,
4117 class ARGS_13>
4118inline
4119ManagedPtr<ELEMENT_TYPE>
4120ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
4121 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
4122 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
4123 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
4124 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
4125 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
4126 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
4127 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
4128 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
4129 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
4130 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
4131 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
4132 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
4133 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13)
4134{
4135 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
4136
4137 allocator = bslma::Default::allocator(allocator);
4138
4139 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
4140 allocator,
4141 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
4142 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
4143 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
4144 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
4145 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
4146 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
4147 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
4148 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
4149 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
4150 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
4151 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
4152 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12),
4153 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, args_13));
4154
4155 return ManagedPtr<ELEMENT_TYPE>(objPtr,
4156 allocator,
4157 &allocatorDeleter<UnqualElem>);
4158}
4159#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 13
4160
4161#if BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 14
4162template <class ELEMENT_TYPE, class ARGS_01,
4163 class ARGS_02,
4164 class ARGS_03,
4165 class ARGS_04,
4166 class ARGS_05,
4167 class ARGS_06,
4168 class ARGS_07,
4169 class ARGS_08,
4170 class ARGS_09,
4171 class ARGS_10,
4172 class ARGS_11,
4173 class ARGS_12,
4174 class ARGS_13,
4175 class ARGS_14>
4176inline
4177ManagedPtr<ELEMENT_TYPE>
4178ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
4179 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
4180 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
4181 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
4182 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
4183 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
4184 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
4185 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
4186 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
4187 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
4188 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
4189 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
4190 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
4191 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
4192 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14)
4193{
4194 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
4195
4196 allocator = bslma::Default::allocator(allocator);
4197
4198 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
4199 allocator,
4200 BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
4201 BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
4202 BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
4203 BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
4204 BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
4205 BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
4206 BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
4207 BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
4208 BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
4209 BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
4210 BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
4211 BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12),
4212 BSLS_COMPILERFEATURES_FORWARD(ARGS_13, args_13),
4213 BSLS_COMPILERFEATURES_FORWARD(ARGS_14, args_14));
4214
4215 return ManagedPtr<ELEMENT_TYPE>(objPtr,
4216 allocator,
4217 &allocatorDeleter<UnqualElem>);
4218}
4219#endif // BSLMA_MANAGEDPTR_VARIADIC_LIMIT_B >= 14
4220
4221#else
4222// The generated code below is a workaround for the absence of perfect
4223// forwarding in some compilers.
4224
4225template <class ELEMENT_TYPE, class ALLOCATOR, class... ARGS>
4226inline
4227typename bsl::enable_if<bsl::is_class<ALLOCATOR>::value,
4228 ManagedPtr<ELEMENT_TYPE> >::type
4229ManagedPtrUtil::allocateManaged(const ALLOCATOR& allocator,
4230 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args)
4231{
4232 return allocateManaged<ELEMENT_TYPE>(
4233 allocator.mechanism(),
4234 BSLS_COMPILERFEATURES_FORWARD(ARGS, args)...);
4235}
4236
4237template <class ELEMENT_TYPE, class... ARGS>
4238inline
4239ManagedPtr<ELEMENT_TYPE> ManagedPtrUtil::makeManaged(
4240 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args)
4241{
4242 bslma::Allocator *defaultAllocator = bslma::Default::defaultAllocator();
4243
4244 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
4245
4246 UnqualElem *objPtr =
4247 bslma::AllocatorUtil::allocateObject<UnqualElem>(defaultAllocator);
4248
4249 bslma::DeallocateObjectProctor<bslma::Allocator *, UnqualElem> proctor(
4250 defaultAllocator, objPtr);
4251
4252 ::new (PointerUtil::voidify(objPtr)) ELEMENT_TYPE(
4253 BSLS_COMPILERFEATURES_FORWARD(ARGS, args)...);
4254 proctor.release();
4255
4256 return ManagedPtr<ELEMENT_TYPE>(objPtr,
4257 defaultAllocator,
4258 &allocatorDeleter<UnqualElem>);
4259}
4260
4261template <class ELEMENT_TYPE, class... ARGS>
4262inline
4263ManagedPtr<ELEMENT_TYPE>
4264ManagedPtrUtil::allocateManaged(bslma::Allocator *allocator,
4265 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args)
4266{
4267 typedef typename bsl::remove_cv<ELEMENT_TYPE>::type UnqualElem;
4268
4269 allocator = bslma::Default::allocator(allocator);
4270
4271 ELEMENT_TYPE *objPtr = bslma::AllocatorUtil::newObject<UnqualElem>(
4272 allocator,
4273 BSLS_COMPILERFEATURES_FORWARD(ARGS, args)...);
4274
4275 return ManagedPtr<ELEMENT_TYPE>(objPtr,
4276 allocator,
4277 &allocatorDeleter<UnqualElem>);
4278}
4279
4280// }}} END GENERATED CODE
4281#endif
4282
4283 // --------------------------
4284 // class ManagedPtrNilDeleter
4285 // --------------------------
4286
4287// CLASS METHODS
4288template <class TARGET_TYPE>
4289inline
4290void ManagedPtrNilDeleter<TARGET_TYPE>::deleter(void *, void *)
4291{
4292}
4293
4294 // ----------------------------------------
4295 // private struct ManagedPtr_DefaultDeleter
4296 // ----------------------------------------
4297
4298// CLASS METHODS
4299template <class MANAGED_TYPE>
4300inline
4301void ManagedPtr_DefaultDeleter<MANAGED_TYPE>::deleter(void *ptr, void *)
4302{
4303 delete reinterpret_cast<MANAGED_TYPE *>(ptr);
4304}
4305
4306} // close package namespace
4307
4308// ============================================================================
4309// TYPE TRAITS
4310// ============================================================================
4311
4312namespace bslmf {
4313
4314template <class TARGET_TYPE>
4315struct HasPointerSemantics<bslma::ManagedPtr<TARGET_TYPE> > : bsl::true_type
4316{
4317};
4318
4319template <class TARGET_TYPE>
4320struct IsBitwiseMoveable<bslma::ManagedPtr<TARGET_TYPE> > : bsl::true_type
4321{
4322};
4323
4324} // close namespace bslmf
4325
4326
4327namespace bsl {
4328
4329template <class TARGET_TYPE>
4330struct is_nothrow_move_constructible<
4331 BloombergLP::bslma::ManagedPtr<TARGET_TYPE> > : bsl::true_type
4332{
4333};
4334
4335} // close namespace bsl
4336
4337#else // if ! defined(DEFINED_BSLMA_MANAGEDPTR_H)
4338# error Not valid except when included from bslma_managedptr.h
4339#endif // ! defined(COMPILING_BSLMA_MANAGEDPTR_H)
4340
4341#endif // ! defined(INCLUDED_BSLMA_MANAGEDPTR_CPP03)
4342
4343// ----------------------------------------------------------------------------
4344// Copyright 2016 Bloomberg Finance L.P.
4345//
4346// Licensed under the Apache License, Version 2.0 (the "License");
4347// you may not use this file except in compliance with the License.
4348// You may obtain a copy of the License at
4349//
4350// http://www.apache.org/licenses/LICENSE-2.0
4351//
4352// Unless required by applicable law or agreed to in writing, software
4353// distributed under the License is distributed on an "AS IS" BASIS,
4354// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4355// See the License for the specific language governing permissions and
4356// limitations under the License.
4357// ----------------------------- END-OF-FILE ----------------------------------
4358
4359/** @} */
4360/** @} */
4361/** @} */
bslma::Allocator
Definition bslma_allocator.h:545
bslma::DeallocateObjectProctor
Definition bslma_deallocateobjectproctor.h:273
bslma::ManagedPtrDeleter::Deleter
void(* Deleter)(void *managedObject, void *cookie)
Deleter function prototype used to destroy the managed pointer.
Definition bslma_managedptrdeleter.h:120
bslma::ManagedPtr_Ref::~ManagedPtr_Ref
~ManagedPtr_Ref()
Definition bslma_managedptr.h:1928
bslma::ManagedPtr_Ref::operator=
ManagedPtr_Ref & operator=(const ManagedPtr_Ref &original)=default
bslma::ManagedPtr_Ref::target
TARGET_TYPE * target() const
Return a pointer to the referenced object.
Definition bslma_managedptr.h:1943
bslma::ManagedPtr_Ref::ManagedPtr_Ref
ManagedPtr_Ref(ManagedPtr_Members *base, TARGET_TYPE *target)
Definition bslma_managedptr.h:1918
bslma::ManagedPtr_Ref::base
ManagedPtr_Members * base() const
Return a pointer to the managed state of a ManagedPtr object.
Definition bslma_managedptr.h:1936
bslma::ManagedPtr
Definition bslma_managedptr.h:1173
bslma::ManagedPtr::get
TARGET_TYPE * get() const
Definition bslma_managedptr.h:2596
bslma::ManagedPtr::ptr
TARGET_TYPE * ptr() const
Definition bslma_managedptr.h:2603
bslma::ManagedPtr::~ManagedPtr
~ManagedPtr()
Definition bslma_managedptr.h:2254
bslma::ManagedPtr::operator*
bslmf::AddReference< TARGET_TYPE >::Type operator*() const
Definition bslma_managedptr.h:2571
bslma::ManagedPtr::deleter
const ManagedPtrDeleter & deleter() const
Definition bslma_managedptr.h:2587
bslma::ManagedPtr::swap
void swap(ManagedPtr &other)
Definition bslma_managedptr.h:2535
bslma::ManagedPtr::operator->
TARGET_TYPE * operator->() const
Definition bslma_managedptr.h:2580
bslma::ManagedPtr::clear
void clear()
Definition bslma_managedptr.h:2366
bslma::ManagedPtr::operator=
ManagedPtr & operator=(ManagedPtr &rhs) BSLS_KEYWORD_NOEXCEPT
Definition bslma_managedptr.h:2263
bslma::ManagedPtr::element_type
TARGET_TYPE element_type
Alias to the TARGET_TYPE template parameter.
Definition bslma_managedptr.h:1183
bslma::ManagedPtr::release
ManagedPtr_PairProxy< TARGET_TYPE, ManagedPtrDeleter > release()
Definition bslma_managedptr.h:2490
bslma::ManagedPtr::ManagedPtr
friend class ManagedPtr
Definition bslma_managedptr.h:1282
bslma::ManagedPtr::reset
void reset()
Definition bslma_managedptr.h:2527
bslma::ManagedPtr::loadAlias
void loadAlias(ManagedPtr< ALIASED_TYPE > &alias, TARGET_TYPE *ptr)
Definition bslma_managedptr.h:2473
bslma::ManagedPtr::DeleterFunc
ManagedPtrDeleter::Deleter DeleterFunc
Definition bslma_managedptr.h:1180
bslmf::MovableRef
Definition bslmf_movableref.h:752
bsls::UnspecifiedBool::trueValue
static BoolType trueValue()
Return a value that converts to the bool value true.
Definition bsls_unspecifiedbool.h:223
bsls::UnspecifiedBool::BoolType
int UnspecifiedBool::* BoolType
Definition bsls_unspecifiedbool.h:190
BSLMF_ASSERT
#define BSLMF_ASSERT(expr)
Definition bslmf_assert.h:231
BSLS_ASSERT
#define BSLS_ASSERT(X)
Definition bsls_assert.h:1976
BSLS_ASSERT_SAFE
#define BSLS_ASSERT_SAFE(X)
Definition bsls_assert.h:1917
BSLS_COMPILERFEATURES_FORWARD_REF
#define BSLS_COMPILERFEATURES_FORWARD_REF(T)
Definition bsls_compilerfeatures.h:2343
BSLS_COMPILERFEATURES_FORWARD
#define BSLS_COMPILERFEATURES_FORWARD(T, V)
Definition bsls_compilerfeatures.h:2349
BSLS_KEYWORD_NOEXCEPT
#define BSLS_KEYWORD_NOEXCEPT
Definition bsls_keyword.h:674
balcl::swap
void swap(OptionValue &a, OptionValue &b)
bdlat_ValueTypeFunctions::reset
void reset(TYPE *object)
Reset the value of the specified object to its default value.
bsl
Definition bdlat_valuetypefunctions.h:939
bsl::nullptr_t
BloombergLP::bsls::Nullptr_Impl::Type nullptr_t
Definition bsls_nullptr.h:283
bsl::get
BSLS_KEYWORD_CONSTEXPR_CPP14 TYPE & get(array< TYPE, SIZE > &a) BSLS_KEYWORD_NOEXCEPT
bsl::ref
reference_wrapper< T > ref(T &object)
Return a reference wrapper that represents the specified object.
bsl::rhs
ALLOCATOR const STRING_VIEW_LIKE_TYPE & rhs
Definition bslstl_string.h:3918
bslma
Definition baljsn_encoder_testtypes.h:76
bslmf
Definition bdlbb_blob.h:579
bsls
Definition bdlt_iso8601util.h:707
bsl::conditional
Definition bslmf_conditional.h:123
bsl::enable_if
Definition bslmf_enableif.h:530
bsl::integral_constant< bool, true >
bsl::is_convertible
Definition bslmf_isconvertible.h:875
bsl::is_void
Definition bslmf_isvoid.h:138
bsl::remove_cv::type
remove_const< typenameremove_volatile< t_TYPE >::type >::type type
Definition bslmf_removecv.h:128
bslma::Default::allocator
static Allocator * allocator(Allocator *basicAllocator=0)
Definition bslma_default.h:913
bslma::Default::defaultAllocator
static Allocator * defaultAllocator()
Definition bslma_default.h:905
bslma::ManagedPtrNilDeleter::deleter
static void deleter(void *, void *)
Deleter function that does nothing.
Definition bslma_managedptr.h:2697
bslma::ManagedPtrUtil::makeManaged
static ManagedPtr< ELEMENT_TYPE > makeManaged(ARGS &&... args)
Definition bslma_managedptr.h:2646
bslma::ManagedPtrUtil::allocatorDeleter
static void allocatorDeleter(void *object, void *allocator)
Definition bslma_managedptr.h:2622
bslma::ManagedPtrUtil::allocateManaged
static ManagedPtr< ELEMENT_TYPE > allocateManaged(bslma::Allocator *allocator, ARGS &&... args)
Definition bslma_managedptr.h:2673
bslma::ManagedPtrUtil::noOpDeleter
static void noOpDeleter(void *, void *)
Deleter function that does nothing.
bslma::ManagedPtr_DefaultDeleter::deleter
static void deleter(void *ptr, void *)
Definition bslma_managedptr.h:2708
bslmf::AddReference::Type
bsl::add_lvalue_reference< t_TYPE >::type Type
Definition bslmf_addreference.h:191
bslmf::MovableRefUtil
Definition bslmf_movableref.h:795