bslstl_sharedptr_cpp03.h

Go to the documentation of this file.

/// @file bslstl_sharedptr_cpp03.h
///
/// The content of this file has been pre-processed for Doxygen.
///
 
 
// bslstl_sharedptr_cpp03.h                                           -*-C++-*-
 
// Automatically generated file.  **DO NOT EDIT**
 
#ifndef INCLUDED_BSLSTL_SHAREDPTR_CPP03
#define INCLUDED_BSLSTL_SHAREDPTR_CPP03
 
/// @defgroup bslstl_sharedptr_cpp03 bslstl_sharedptr_cpp03
/// @brief  Provide C++03 implementation for bslstl_sharedptr.h
/// @addtogroup bsl
/// @{
/// @addtogroup bslstl
/// @{
/// @addtogroup bslstl_sharedptr_cpp03
/// @{
///
/// <h1> Outline </h1>
/// * <a href="#bslstl_sharedptr_cpp03-purpose"> Purpose</a>
/// * <a href="#bslstl_sharedptr_cpp03-classes"> Classes </a>
/// * <a href="#bslstl_sharedptr_cpp03-description"> Description </a>
///
/// # Purpose {#bslstl_sharedptr_cpp03-purpose}
/// Provide C++03 implementation for bslstl_sharedptr.h
///
/// # Classes {#bslstl_sharedptr_cpp03-classes}
/// See bslstl_sharedptr.h for list of classes
///
/// @see  bslstl_sharedptr
///
/// # Description {#bslstl_sharedptr_cpp03-description}
///  This component is the C++03 translation of a C++11 component,
/// generated by the 'sim_cpp11_features.pl' program.  If the original header
/// contains any specially delimited regions of C++11 code, then this generated
/// file contains the C++03 equivalent, i.e., with variadic templates expanded
/// and rvalue-references replaced by 'bslmf::MovableRef' objects.  The header
/// code in this file is designed to be '#include'd into the original header
/// when compiling with a C++03 compiler.  If there are no specially delimited
/// regions of C++11 code, then this header contains no code and is not
/// '#include'd in the original header.
///
/// Generated on Sun Sep  1 18:48:19 2024
/// Command line: sim_cpp11_features.pl bslstl_sharedptr.h
/// @}
/** @} */
/** @} */
 
/** @addtogroup bsl
 * @{
 */
/** @addtogroup bslstl
 * @{
 */
/** @addtogroup bslstl_sharedptr_cpp03
 * @{
 */
 
#ifdef COMPILING_BSLSTL_SHAREDPTR_H
 
#if defined(BSLS_PLATFORM_HAS_PRAGMA_GCC_DIAGNOSTIC)
        // Here and throughout the file wherever 'auto_ptr' is used, suspend
        // GCC reporting of deprecated declarations since the use of 'auto_ptr'
        // in this standard interface is required.
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
 
#if defined(BSLS_COMPILERFEATURES_SUPPORT_DEFAULT_TEMPLATE_ARGS) \
 && !(defined(BSLS_PLATFORM_CMP_MSVC) && BSLS_PLATFORM_CMP_VERSION < 1900)
# define BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS 1
 
#if BSLS_PLATFORM_CMP_VERSION >= 1910 &&                                      \
    BSLS_PLATFORM_CMP_VERSION <  1920 &&                                      \
    BSLS_COMPILERFEATURES_CPLUSPLUS >= 201703L
// Visual Studio 2017 in C++17 mode crashes with an internal compiler error on
// the shared pointer SFINAE code.  See {DRQS 148281696}.
# undef BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS
#endif
 
// If the macro 'BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS' is defined, then a
// conforming C++11 compiler will define the constructors in this component in
// such a way that they will not be selected during overload resolution unless
// they would instantiate correctly.  This means that code depending on the
// result of 'is_constructible' and similar traits will have the expected
// behavior.  There is no attempt to support this feature in C++03.
//
// Support for SFINAE-queries on the constructability of a 'shared_ptr' depend
// on a variety of C++11 language features, including "expression-SFINAE".
// However, the main language feature that enables SFINAE elimination of a
// constructor is the ability to use default template arguments in a function
// template.  It is significantly preferred to use the template parameter list,
// rather than add additional default arguments to the constructor signatures,
// as there are so many constructor overloads in this component that there is a
// real risk of introducing ambiguities that would need to be worked around.
// Therefore, the 'BSLS_COMPILERFEATURES_SUPPORT_DEFAULT_TEMPLATE_ARGS' macro
// serves as our proxy for whether SFINAE-constructors are enabled in this
// component.  Note that the MSVC 2015 compiler almost supported
// "expression-SFINAE", to the extent that it works for this component, unlike
// earlier versions of that compiler.  We therefore make a special version-test
// on Microsoft in addition to the feature testing.
#endif
 
#if defined(BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS)
// Note the intentional comma in the first line of the definition of each
// macro, which allows these macros to be applied incrementally, even when the
// alternate definition is empty.  This avoids the problem of introducing new
// template parameters along with the macros in the non-SFINAE-supporting case
// below.
# define BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE ,                            \
    typename enable_if<                                                       \
        BloombergLP::bslstl::SharedPtr_IsPointerConvertible<                  \
                            CONVERTIBLE_TYPE,                                 \
                            ELEMENT_TYPE>::value>::type *                     \
                                                                = nullptr
 
# define BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE ,                             \
    typename enable_if<                                                       \
        BloombergLP::bslstl::SharedPtr_IsPointerConvertible<                  \
                            CONVERTIBLE_TYPE,                                 \
                            ELEMENT_TYPE>::value>::type *
 
 
# define BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE ,                             \
    typename enable_if<                                                       \
        BloombergLP::bslstl::SharedPtr_IsPointerCompatible<                   \
                            COMPATIBLE_TYPE,                                  \
                            ELEMENT_TYPE>::value>::type *                     \
                                                                = nullptr
 
# define BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE ,                              \
    typename enable_if<                                                       \
        BloombergLP::bslstl::SharedPtr_IsPointerCompatible<                   \
                            COMPATIBLE_TYPE,                                  \
                            ELEMENT_TYPE>::value>::type *
 
 
# define BSLSTL_SHAREDPTR_DECLARE_IF_DELETER(FUNCTOR, ARGUMENT) ,             \
    typename enable_if<                                                       \
      BloombergLP::bslstl::SharedPtr_IsCallable  <FUNCTOR,                    \
                                                  ARGUMENT *>::k_VALUE ||     \
      BloombergLP::bslstl::SharedPtr_IsFactoryFor<FUNCTOR,                    \
                                                  ARGUMENT>::k_VALUE>::type * \
                                                                      = nullptr
 
# define BSLSTL_SHAREDPTR_DEFINE_IF_DELETER(FUNCTOR, ARGUMENT) ,              \
    typename enable_if<                                                       \
      BloombergLP::bslstl::SharedPtr_IsCallable  <FUNCTOR,                    \
                                                  ARGUMENT *>::k_VALUE ||     \
      BloombergLP::bslstl::SharedPtr_IsFactoryFor<FUNCTOR,                    \
                                                  ARGUMENT  >::k_VALUE>::type *
 
 
# define BSLSTL_SHAREDPTR_DECLARE_IF_NULLPTR_DELETER(FUNCTOR) ,               \
    typename enable_if<                                                       \
      BloombergLP::bslstl::SharedPtr_IsCallable  <FUNCTOR,                    \
                                                  nullptr_t>::k_VALUE ||      \
      BloombergLP::bslstl::SharedPtr_IsNullableFactory<                       \
                                           FUNCTOR>::k_VALUE>::type * = nullptr
 
# define BSLSTL_SHAREDPTR_DEFINE_IF_NULLPTR_DELETER(FUNCTOR) ,                \
    typename enable_if<                                                       \
      BloombergLP::bslstl::SharedPtr_IsCallable  <FUNCTOR,                    \
                                                  nullptr_t>::k_VALUE ||      \
      BloombergLP::bslstl::SharedPtr_IsNullableFactory<                       \
                                                     FUNCTOR>::k_VALUE>::type *
#else
// Do not attempt to support SFINAE in constructors in a C++03 compiler
# define BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE
# define BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE
 
# define BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE
# define BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE
 
# define BSLSTL_SHAREDPTR_DECLARE_IF_DELETER(FUNCTOR, ARGUMENT)
# define BSLSTL_SHAREDPTR_DEFINE_IF_DELETER(FUNCTOR, ARGUMENT)
 
# define BSLSTL_SHAREDPTR_DECLARE_IF_NULLPTR_DELETER(FUNCTOR)
# define BSLSTL_SHAREDPTR_DEFINE_IF_NULLPTR_DELETER(FUNCTOR)
#endif  // BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS
 
// Some SFINAE checks, when enabled, make use of discarded-value expressions
// (as the left-hand side of a comma operator). Clang compilers based on
// versions of LLVM earlier than 12 contain a bug in which substitution
// failures are not caught in discarded-value expressions when used in SFINAE
// contexts (this includes Clang 11 and earlier, and Apple Clang 13 and
// earlier).  In order to ensure that these compilers catch substitution
// failures in such expressions, this component does not discard them.  Note
// that this is dangerous, because not discarding the expression allows the
// possibility that the comma operator will be overloaded on the type of the
// expression, and so it is preferable to discard the expression where
// possible.
#if defined(BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS)
# if !defined(BSLS_PLATFORM_CMP_CLANG)                             \
  || !defined(__APPLE_CC__) && BSLS_PLATFORM_CMP_VERSION >= 120000 \
  ||  defined(__APPLE_CC__) && BSLS_PLATFORM_CMP_VERSION >  130000
#  define BSLSTL_SHAREDPTR_SFINAE_DISCARD(EXPRESSION) \
     static_cast<void>(EXPRESSION)
# else
#  define BSLSTL_SHAREDPTR_SFINAE_DISCARD(EXPRESSION) \
     (EXPRESSION)
# endif
#endif
 
 
namespace bslstl {
 
/// This `struct` is for internal use only, providing a tag for `shared_ptr`
/// constructors to recognize that a passed `SharedPtrRep` was obtained from
/// an existing `shared_ptr` object.
struct SharedPtr_RepFromExistingSharedPtr {
};
 
/// Forward declaration of `SharedPtr_ImpUtil`. This is needed because this
/// struct is a friend of `enable_shared_from_this` in the `bsl` namespace.
struct SharedPtr_ImpUtil;
 
#if defined(BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS)
/// Forward declaration of component-private type trait to indicate whether
/// an object of (template parameter) type `FUNCTOR` can be called as a
/// function with an argument of (template parameter) type `ARG`
template <class FUNCTOR, class ARG>
struct SharedPtr_IsCallable;
 
/// Forward declaration of component-private type trait to indicate whether
/// a pointer to a `FACTORY` has a `deleteObject` member that can be called
/// as `factory->deleteObject((ARG *)p)`.
template <class FACTORY, class ARG>
struct SharedPtr_IsFactoryFor;
 
/// Forward declaration of component-private type trait to indicate whether
/// a pointer to a `FACTORY` has a `deleteObject` member that can be called
/// as `factory->deleteObject((ARG *)p)`.
template <class FACTORY>
struct SharedPtr_IsNullableFactory;
 
/// Forward declaration of component-private type trait to indicate whether
/// a pointer to a `SOURCE_TYPE` can be converted to a pointer to a
/// `DEST_TYPE`.  [util.smartptr.shared.const]/8 says "either DEST_TYPE is
/// U[N] and SOURCE_TYPE(*)[N] is convertible to DEST_TYPE*, or DEST_TYPE is
/// U[] and SOURCE_TYPE(*)[] is convertible to DEST_TYPE*".
template <class SOURCE_TYPE, class DEST_TYPE>
struct SharedPtr_IsPointerConvertible;
 
/// Forward declaration of component-private type trait to indicate whether
/// a pointer to a `SOURCE_TYPE` is compatible with a pointer to
/// `DEST_TYPE`.  [util.smartptr.shared]/5 says: "for the purposes of ...,
/// a pointer type SOURCE_TYPE* is said to be compatible with a pointer type
/// DEST_TYPE* when either SOURCE_TYPE* is convertible to DEST_TYPE* or
/// SOURCE_TYPE is U[N] and DEST_TYPE is cv U[]."
template <class SOURCE_TYPE, class DEST_TYPE>
struct SharedPtr_IsPointerCompatible;
 
#endif
 
}  // close package namespace
 
 
namespace bsl {
 
template<class ELEMENT_TYPE>
class enable_shared_from_this;
 
template <class ELEMENT_TYPE>
class shared_ptr;
 
template <class ELEMENT_TYPE>
class weak_ptr;
 
                        // ================
                        // class shared_ptr
                        // ================
 
/// This class provides a thread-safe reference-counted "smart pointer" to
/// support "shared ownership" of objects: a shared pointer ensures that the
/// shared object is destroyed, using the appropriate deletion method, only
/// when there are no shared references to it.  The object (of template
/// parameter type `ELEMENT_TYPE`) referred to by a shared pointer may be
/// accessed directly using the `->` operator, or the dereference operator
/// (operator `*`) can be used to obtain a reference to that object.
///
/// Note that the object referred to by a shared pointer representation is
/// usually the same as the object referred to by that shared pointer (of
/// the same `ELEMENT_TYPE`), but this need not always be true in the
/// presence of conversions or "aliasing": the object referred to (of
/// template parameter type `ELEMENT_TYPE`) by the shared pointer may differ
/// from the object of type `COMPATIBLE_TYPE` (see the "Aliasing" section in
/// the component-level documentation) referred to by the shared pointer
/// representation.
///
/// More generally, this class supports a complete set of *in*-*core*
/// pointer semantic operations.
///
/// See @ref bslstl_sharedptr_cpp03 
template <class ELEMENT_TYPE>
class shared_ptr {
 
  public:
    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(shared_ptr<ELEMENT_TYPE>,
                                   bsl::is_nothrow_move_constructible);
 
    // TYPES
 
    /// For shared pointers to non-array types, @ref element_type  is an alias
    /// to the `ELEMENT_TYPE` template parameter.  Otherwise, it is an alias
    /// to the type contained in the array.
    typedef typename bsl::remove_extent<ELEMENT_TYPE>::type element_type;
 
    /// @ref weak_type  is an alias to a weak pointer with the same element type
    /// as this `shared_ptr`.
    typedef weak_ptr<ELEMENT_TYPE> weak_type;
 
  private:
    // DATA
    element_type                     *d_ptr_p; // pointer to the shared object
 
    BloombergLP::bslma::SharedPtrRep *d_rep_p; // pointer to the representation
                                               // object that manages the
                                               // shared object
 
    // PRIVATE TYPES
 
    /// `SelfType` is an alias to this `class`, for compilers that do not
    /// recognize plain `shared_ptr`.
    typedef shared_ptr<ELEMENT_TYPE> SelfType;
 
    typedef typename BloombergLP::bsls::UnspecifiedBool<shared_ptr>::BoolType
                                                                      BoolType;
 
    // FRIENDS
    template <class COMPATIBLE_TYPE>
    friend class shared_ptr;
 
    friend struct BloombergLP::bslstl::SharedPtr_ImpUtil;
 
  private:
    // PRIVATE CLASS METHODS
 
    /// Return the specified `rep`.
    template <class INPLACE_REP>
    static BloombergLP::bslma::SharedPtrRep *makeInternalRep(
                                        ELEMENT_TYPE                     *,
                                        INPLACE_REP                      *,
                                        BloombergLP::bslma::SharedPtrRep *rep);
 
    /// Return the address of a new out-of-place representation for a shared
    /// pointer that manages the specified `ptr` and uses the specified
    /// `allocator` to destroy the object pointed to by `ptr`.  Use
    /// `allocator` to supply memory.
    template <class COMPATIBLE_TYPE, class ALLOCATOR>
    static BloombergLP::bslma::SharedPtrRep *makeInternalRep(
                                     COMPATIBLE_TYPE               *ptr,
                                     ALLOCATOR                     *,
                                     BloombergLP::bslma::Allocator *allocator);
 
    /// Return the address of a new out-of-place representation for a shared
    /// pointer that manages the specified `ptr` and uses the specified
    /// `deleter` to destroy the object pointed to by `ptr`.  Use the
    /// currently installed default allocator to supply memory.
    template <class COMPATIBLE_TYPE, class DELETER>
    static BloombergLP::bslma::SharedPtrRep *makeInternalRep(
                                                      COMPATIBLE_TYPE *ptr,
                                                      DELETER         *deleter,
                                                      ...);
 
  public:
    // CREATORS
 
    /// Create an empty shared pointer, i.e., a shared pointer with no
    /// representation that does not refer to any object and has no
    /// deleter.
    BSLS_KEYWORD_CONSTEXPR
    shared_ptr() BSLS_KEYWORD_NOEXCEPT;
 
    /// Create an empty shared pointer, i.e., a shared pointer with no
    /// representation that does not refer to any object and has no
    /// deleter.
    BSLS_KEYWORD_CONSTEXPR
    shared_ptr(bsl::nullptr_t) BSLS_KEYWORD_NOEXCEPT;               // IMPLICIT
 
    /// Create a shared pointer that manages a modifiable object of
    /// (template parameter) type `CONVERTIBLE_TYPE` and refers to the
    /// specified `(ELEMENT_TYPE *)ptr`.  The currently installed default
    /// allocator is used to allocate and deallocate the internal
    /// representation of the shared pointer.  When all references have been
    /// released, the object pointed to by the managed pointer will be
    /// destroyed by a call to `delete ptr`.  If `CONVERTIBLE_TYPE *` is not
    /// implicitly convertible to `ELEMENT_TYPE *`, then a compiler
    /// diagnostic will be emitted indicating the error.  If `ptr` is 0,
    /// then this shared pointer will still allocate an internal
    /// representation to share ownership of that empty state, which will be
    /// reclaimed when the last reference is destroyed.  If an exception is
    /// thrown allocating storage for the representation, then `delete ptr`
    /// will be called.  Note that if `ptr` is a null-pointer constant, the
    /// compiler will actually select the `shared_ptr(bsl::nullptr_t)`
    /// constructor, resulting in an empty shared pointer.
    template <class CONVERTIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE>
    explicit shared_ptr(CONVERTIBLE_TYPE *ptr);
 
    /// Create a shared pointer that manages a modifiable object of
    /// (template parameter) type `CONVERTIBLE_TYPE` and refers to the
    /// specified `ptr` cast to a pointer to the (template parameter) type
    /// `ELEMENT_TYPE`.  If the specified `basicAllocator` is not 0, then
    /// `basicAllocator` is used to allocate and deallocate the internal
    /// representation of the shared pointer and to destroy the shared
    /// object when all references have been released; otherwise, the
    /// currently installed default allocator is used.  If
    /// `CONVERTIBLE_TYPE *` is not implicitly convertible to
    /// `ELEMENT_TYPE *`, then a compiler diagnostic will be emitted
    /// indicating the error.  If `ptr` is 0, then this shared pointer will
    /// still allocate an internal representation to share ownership of that
    /// empty state, which will be reclaimed when the last reference is
    /// destroyed.  Note that if `ptr` is a null-pointer constant, the
    /// compiler will actually select the
    /// `shared_ptr(bsl::nullptr_t, BloombergLP::bslma::Allocator *)`
    /// constructor, resulting in an empty shared pointer.  Note that if
    /// `basicAllocator` is a pointer to a class derived from
    /// `bslma::Allocator`, the compiler will actually select the following
    /// (more general) constructor that has the same behavior:
    /// @code
    /// template <class CONVERTIBLE_TYPE, class DELETER>
    /// shared_ptr(CONVERTIBLE_TYPE *ptr, DELETER * deleter);
    /// @endcode
    template <class CONVERTIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE>
    shared_ptr(CONVERTIBLE_TYPE              *ptr,
               BloombergLP::bslma::Allocator *basicAllocator);
 
    /// Create a shared pointer that takes ownership of the specified `rep`
    /// and refers to the modifiable object at the specified `ptr` address.
    /// The number of references to `rep` is *NOT* incremented.  Note that
    /// if `rep` is a pointer to a class derived from
    /// `BloombergLP::bslma::SharedPtrRep`, the compiler will actually
    /// select the following (more general) constructor that has the same
    /// behavior:
    /// @code
    /// template <class COMPATIBLE_TYPE, class DELETER>
    /// shared_ptr(COMPATIBLE_TYPE *ptr, DELETER * deleter);
    /// @endcode
    shared_ptr(element_type *ptr, BloombergLP::bslma::SharedPtrRep *rep);
 
    /// Create a shared pointer that takes ownership of the specified `rep`
    /// and refers to the modifiable object at the specified `ptr` address.
    /// The number of references to `rep` is *NOT* incremented.  The
    /// behavior is undefined unless `rep` was previously obtained from an
    /// existing `shared_ptr`, `rep->disposeObject` has not been called, and
    /// `rep->numReferences() > 0`.  Note that this constructor is intended
    /// for use by `weak_ptr::lock`, and it would be surprising to find
    /// another client.  This solves an obscure problem that arises from
    /// unusual use of classes derived from `enable_shared_from_this`.
    /// Further note that the caller is responsible for incrementing the
    /// `numReferences` count prior to calling this constructor, in order to
    /// maintain a consistent reference count when this `shared_ptr` object
    /// releases the shared object from its management.
    shared_ptr(ELEMENT_TYPE                     *ptr,
               BloombergLP::bslma::SharedPtrRep *rep,
               BloombergLP::bslstl::SharedPtr_RepFromExistingSharedPtr);
 
    /// Create a shared pointer that manages a modifiable object of
    /// (template parameter) type `CONVERTIBLE_TYPE`, refers to the
    /// specified `ptr` cast to a pointer to the (template parameter) type
    /// `ELEMENT_TYPE`, and uses the specified `deleter` to delete the
    /// shared object when all references have been released.  Use the
    /// currently installed default allocator to allocate and deallocate the
    /// internal representation of the shared pointer, unless `DELETER` is a
    /// class derived from either `bslma::Allocator` or
    /// `bslma::SharedPtrRep`; if `DELETER` is a class derived from
    /// `bslma::allocator`, create a shared pointer as if calling the
    /// constructor:
    /// @code
    /// template <class CONVERTIBLE_TYPE>
    /// shared_ptr(CONVERTIBLE_TYPE               *ptr,
    ///            BloombergLP::bslma::Allocator *basicAllocator);
    /// @endcode
    /// If `DELETER` is a class derived from `bslma::SharedPtrRep`, create a
    /// shared pointer as if calling the constructor:
    /// @code
    /// shared_ptr(ELEMENT_TYPE                     *ptr,
    ///            BloombergLP::bslma::SharedPtrRep *rep);
    /// @endcode
    /// If `DELETER` does not derive from either `bslma::Allocator` or
    /// `BloombergLP::bslma::SharedPtrRep`, then `deleter` shall be a
    /// pointer to a factory object that exposes a member function that can
    /// be invoked as `deleteObject(ptr)` that will be called to destroy the
    /// object at the `ptr` address (i.e., `deleter->deleteObject(ptr)` will
    /// be called to delete the shared object).  (See the "Deleters" section
    /// in the component-level documentation.)  If `CONVERTIBLE_TYPE *` is
    /// not implicitly convertible to `ELEMENT_TYPE *`, then a compiler
    /// diagnostic will be emitted indicating the error.  If `ptr` is 0,
    /// then the null pointer will be reference counted, and the deleter
    /// will be called when the last reference is destroyed.  If an
    /// exception is thrown when allocating storage for the internal
    /// representation, then `deleter(ptr)` will be called.  Note that this
    /// method is a BDE extension and not part of the C++ standard
    /// interface.
    template <class CONVERTIBLE_TYPE,
              class DELETER
              BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE
              BSLSTL_SHAREDPTR_DECLARE_IF_DELETER(DELETER *, CONVERTIBLE_TYPE)>
    shared_ptr(CONVERTIBLE_TYPE *ptr, DELETER *deleter);
 
    /// Create a shared pointer that manages a modifiable object of
    /// (template parameter) type `CONVERTIBLE_TYPE`, refers to the
    /// specified `(ELEMENT_TYPE *)ptr`, and uses the specified `deleter` to
    /// delete the shared object when all references have been released.
    /// Optionally specify a `basicAllocator` to allocate and deallocate the
    /// internal representation of the shared pointer (including a copy of
    /// `deleter`).  If `basicAllocator` is 0, the currently installed
    /// default allocator is used.  `DELETER` shall be either a function
    /// pointer or a "factory" deleter that may be invoked to destroy the
    /// object referred to by a single argument of type `CONVERTIBLE_TYPE *`
    /// (i.e., `deleter(ptr)` or `deleter->deleteObject(ptr)` will be called
    /// to destroy the shared object).  (See the "Deleters" section in the
    /// component-level documentation.)  If `CONVERTIBLE_TYPE *` is not
    /// implicitly convertible to `ELEMENT_TYPE *`, then this constructor
    /// will not be selected by overload resolution.  If `ptr` is 0, then
    /// the null pointer will be reference counted, and `deleter(ptr)` will
    /// be called when the last reference is destroyed.  If an exception is
    /// thrown when allocating storage for the internal representation, then
    /// `deleter(ptr)` will be called.  The behavior is undefined unless the
    /// constructor making a copy of `deleter` does not throw an exception.
    template <class CONVERTIBLE_TYPE,
              class DELETER
              BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE
              BSLSTL_SHAREDPTR_DECLARE_IF_DELETER(DELETER, CONVERTIBLE_TYPE)>
    shared_ptr(CONVERTIBLE_TYPE              *ptr,
               DELETER                        deleter,
               BloombergLP::bslma::Allocator *basicAllocator = 0);
 
    /// Create a shared pointer that manages a modifiable object of
    /// (template parameter) type `CONVERTIBLE_TYPE`, refers to the
    /// specified `ptr` cast to a pointer to the (template parameter) type
    /// `ELEMENT_TYPE`, and uses the specified `deleter` to delete the
    /// shared object when all references have been released.  Use the
    /// specified `basicAllocator` to allocate and deallocate the internal
    /// representation of the shared pointer (including a copy of the
    /// `deleter`).  The (template parameter) type `DELETER` shall be either
    /// a function pointer or a function-like deleter that may be invoked to
    /// destroy the object referred to by a single argument of type
    /// `CONVERTIBLE_TYPE *` (i.e., `deleter(ptr)` will be called to destroy
    /// the shared object).  (See the "Deleters" section in the component-
    /// level documentation.)  The (template parameter) type `ALLOCATOR`
    /// shall satisfy the Allocator requirements of the C++ standard (C++11
    /// 17.6.3.5, [allocator.requirements]).  If `CONVERTIBLE_TYPE *` is not
    /// implicitly convertible to `ELEMENT_TYPE *`, then a compiler
    /// diagnostic will be emitted indicating the error.  If `ptr` is 0,
    /// then the null pointer will be reference counted, and `deleter(ptr)`
    /// will be called when the last reference is destroyed.  If an
    /// exception is thrown when allocating storage for the internal
    /// representation, then `deleter(ptr)` will be called.  The behavior is
    /// undefined unless the constructor making a copy of `deleter` does not
    /// throw an exception.  Note that the final dummy parameter is a simple
    /// SFINAE check that the (template parameter) `ALLOCATOR` type probably
    /// satisfies the standard allocator requirements; in particular, it
    /// will not match pointer types, so any pointers to `bslma::Allocator`
    /// derived classes will dispatch to the constructor above this, and not
    /// be greedily matched to a generic type parameter.
    template <class CONVERTIBLE_TYPE,
              class DELETER,
              class ALLOCATOR
              BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE
              BSLSTL_SHAREDPTR_DECLARE_IF_DELETER(DELETER, CONVERTIBLE_TYPE)>
    shared_ptr(CONVERTIBLE_TYPE               *ptr,
               DELETER                         deleter,
               ALLOCATOR                       basicAllocator,
               typename ALLOCATOR::value_type * = 0);
 
    /// Create an empty shared pointer.  The specified `nullPointerLiteral`
    /// and `basicAllocator` are not used.  Note that use of this
    /// constructor is equivalent to calling the default constructor.
    shared_ptr(nullptr_t                      nullPointerLiteral,
               BloombergLP::bslma::Allocator *basicAllocator);
 
    /// Create a shared pointer that reference-counts the null pointer, and
    /// calls the specified `deleter` with a null pointer (i.e., invokes
    /// `deleter((ELEMENT_TYPE *)0)`) when the last shared reference is
    /// destroyed.  The specified `nullPointerLiteral` is not used.
    /// Optionally specify a `basicAllocator` to allocate and deallocate the
    /// internal representation of the shared pointer (including a copy of
    /// `deleter`).  If `basicAllocator` is 0, the currently installed
    /// default allocator is used.  If an exception is thrown when
    /// allocating storage for the internal representation, then
    /// `deleter((ELEMENT_TYPE *)0)` will be called.  The behavior is
    /// undefined unless `deleter` can be called with a null pointer, and
    /// unless the constructor making a copy of `deleter` does not throw an
    /// exception.
    template <class DELETER
              BSLSTL_SHAREDPTR_DECLARE_IF_NULLPTR_DELETER(DELETER)>
    shared_ptr(nullptr_t                      nullPointerLiteral,
               DELETER                        deleter,
               BloombergLP::bslma::Allocator *basicAllocator = 0);
 
    /// Create a shared pointer that reference-counts the null pointer,
    /// calls the specified `deleter` with a null pointer (i.e., invokes
    /// `deleter((ELEMENT_TYPE *)0)`) when the last shared reference is
    /// destroyed, and uses the specified `basicAllocator` to allocate and
    /// deallocate the internal representation of the shared pointer
    /// (including a copy of the `deleter`).  The (template parameter) type
    /// `DELETER` shall be either a function pointer or a function-like
    /// deleter (See the "Deleters" section in the component- level
    /// documentation).  The (template parameter) type `ALLOCATOR` shall
    /// satisfy the Allocator requirements of the C++ standard (C++11
    /// 17.6.3.5, [allocator.requirements]).  The specified
    /// `nullPointerLiteral` is not used.  If an exception is thrown when
    /// allocating storage for the internal representation, then
    /// `deleter((ELEMENT_TYPE *)0)` will be called.  The behavior is
    /// undefined unless `deleter` can be called with a null pointer, and
    /// unless the constructor making a copy of `deleter` does not throw an
    /// exception.  Note that the final dummy parameter is a simple SFINAE
    /// check that the `ALLOCATOR` type probably satisfies the standard
    /// allocator requirements; in particular, it will not match pointer
    /// types, so any pointers to `bslma::Allocator` derived classes will
    /// dispatch to the constructor above this, and not be greedily matched
    /// to a generic type parameter.
    template <class DELETER, class ALLOCATOR
              BSLSTL_SHAREDPTR_DECLARE_IF_NULLPTR_DELETER(DELETER)>
    shared_ptr(nullptr_t                       nullPointerLiteral,
               DELETER                         deleter,
               ALLOCATOR                       basicAllocator,
               typename ALLOCATOR::value_type * = 0);
 
    /// Create a shared pointer that takes over the management of the
    /// modifiable object (if any) previously managed by the specified
    /// `managedPtr` to the (template parameter) type `CONVERTIBLE_TYPE`,
    /// and that refers to `(ELEMENT_TYPE *)managedPtr.ptr()`.  The deleter
    /// used in the `managedPtr` will be used to destroy the shared object
    /// when all references have been released.  Optionally specify a
    /// `basicAllocator` used to allocate and deallocate the internal
    /// representation of the shared pointer.  If `basicAllocator` is 0, the
    /// currently installed default allocator is used.  If
    /// `CONVERTIBLE_TYPE *` is not implicitly convertible to
    /// `ELEMENT_TYPE *`, then a compiler diagnostic will be emitted
    /// indicating the error.  Note that if `managedPtr` is empty, then an
    /// empty shared pointer is created and `basicAllocator` is ignored.
    /// Also note that if `managedPtr` owns a reference to another shared
    /// object (due to a previous call to `shared_ptr<T>::managedPtr`) then
    /// no memory will be allocated, and this `shared_ptr` will adopt the
    /// `ManagedPtr`s ownership of that shared object.
    template <class CONVERTIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE>
    shared_ptr(
         BloombergLP::bslma::ManagedPtr<CONVERTIBLE_TYPE>  managedPtr,
         BloombergLP::bslma::Allocator                    *basicAllocator = 0);
                                                                    // IMPLICIT
 
#if defined(BSLS_LIBRARYFEATURES_HAS_CPP98_AUTO_PTR)
    /// Create a shared pointer that takes over the management of the
    /// modifiable object previously managed by the specified `autoPtr` to
    /// the (template parameter) type `CONVERTIBLE_TYPE`, and that refers to
    /// `(ELEMENT_TYPE *)autoPtr.get()`.  `delete(autoPtr.release())` will
    /// be called to destroy the shared object when all references have been
    /// released.  Optionally specify a `basicAllocator` used to allocate
    /// and deallocate the internal representation of the shared pointer.
    /// If `basicAllocator` is 0, the currently installed default allocator
    /// is used.  If `CONVERTIBLE_TYPE *` is not implicitly convertible to
    /// `ELEMENT_TYPE *`, then a compiler diagnostic will be emitted
    /// indicating the error.
    template <class CONVERTIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE>
    explicit shared_ptr(std::auto_ptr<CONVERTIBLE_TYPE>&  autoPtr,
                        BloombergLP::bslma::Allocator    *basicAllocator = 0);
 
    /// Create a shared pointer that takes over the management of the
    /// modifiable object of (template parameter) type `COMPATIBLE_TYPE`
    /// previously managed by the auto pointer object that the specified
    /// `autoRef` refers to; this shared pointer refers to the same object
    /// that it manages, and `delete(get())` will be called to destroy the
    /// shared object when all references have been released.  Optionally
    /// specify a `basicAllocator` used to allocate and deallocate the
    /// internal representation of the shared pointer.  If `basicAllocator`
    /// is 0, the currently installed default allocator is used.  This
    /// function does not exist unless `COMPATIBLE_TYPE *` is convertible to
    /// `ELEMENT_TYPE *`.
    explicit shared_ptr(std::auto_ptr_ref<ELEMENT_TYPE>  autoRef,
                        BloombergLP::bslma::Allocator   *basicAllocator = 0);
#endif
 
#if defined(BSLS_LIBRARYFEATURES_HAS_CPP11_UNIQUE_PTR)
# if defined(BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS)
    /// Create a shared pointer that takes over the management of the
    /// modifiable object previously managed by the specified `adoptee` to
    /// the (template parameter) type `COMPATIBLE_TYPE`, and that refers to
    /// `(ELEMENT_TYPE *)autoPtr.get()`.  `delete(autoPtr.release())` will
    /// be called to destroy the shared object when all references have been
    /// released.  Optionally specify a `basicAllocator` used to allocate
    /// and deallocate the internal representation of the shared pointer.
    /// If `basicAllocator` is 0, the currently installed default allocator
    /// is used.  This function does not exist unless
    /// `unique_ptr<COMPATIBLE_TYPE, DELETER>::pointer` is convertible to
    /// `ELEMENT_TYPE *`.  Note that this function creates a `shared_ptr`
    /// with an unspecified deleter type that has satisfies this contract,
    /// which might not be the deleter of `rhs`, which is specified by the
    /// C++ standard.
    template <class COMPATIBLE_TYPE,
              class UNIQUE_DELETER,
              typename enable_if<is_convertible<
                      typename std::unique_ptr<COMPATIBLE_TYPE,
                                               UNIQUE_DELETER>::pointer,
                      ELEMENT_TYPE *>::value>::type * = nullptr>
     shared_ptr(std::unique_ptr<COMPATIBLE_TYPE,
                                UNIQUE_DELETER>&&  adoptee,
                BloombergLP::bslma::Allocator     *basicAllocator = 0);
                                                                    // IMPLICIT
# else
    /// Create a shared pointer that takes over the management of the
    /// modifiable object previously managed by the specified `adoptee` to
    /// the (template parameter) type `COMPATIBLE_TYPE`, and that refers to
    /// `(ELEMENT_TYPE *)autoPtr.get()`.  `delete(autoPtr.release())` will
    /// be called to destroy the shared object when all references have been
    /// released.  Optionally specify a `basicAllocator` used to allocate
    /// and deallocate the internal representation of the shared pointer.
    /// If `basicAllocator` is 0, the currently installed default allocator
    /// is used.  This function does not exist unless
    /// `unique_ptr<COMPATIBLE_TYPE, DELETER>::pointer` is convertible to
    /// `ELEMENT_TYPE *`.  Note that this function creates a `shared_ptr`
    /// with an unspecified deleter type that has satisfies this contract,
    /// which might not be the deleter of `rhs`, which is specified by the
    /// C++ standard.
    template <class COMPATIBLE_TYPE, class UNIQUE_DELETER>
    shared_ptr(std::unique_ptr<COMPATIBLE_TYPE,
                                UNIQUE_DELETER>&&  adoptee,
               BloombergLP::bslma::Allocator      *basicAllocator = 0,
               typename enable_if<is_convertible<
                      typename std::unique_ptr<COMPATIBLE_TYPE,
                                               UNIQUE_DELETER>::pointer,
                      ELEMENT_TYPE *>::value,
                      BloombergLP::bslstl::SharedPtr_ImpUtil>::type =
                                      BloombergLP::bslstl::SharedPtr_ImpUtil())
                                                                    // IMPLICIT
    : d_ptr_p(adoptee.get())
    , d_rep_p(0)
    {
        // This constructor template must be defined inline inside the class
        // definition, as Microsoft Visual C++ does not recognize the
        // definition as matching this signature when placed out-of-line.
 
        typedef BloombergLP::bslma::SharedPtrInplaceRep<
                        std::unique_ptr<COMPATIBLE_TYPE, UNIQUE_DELETER> > Rep;
 
        if (d_ptr_p) {
            basicAllocator =
                        BloombergLP::bslma::Default::allocator(basicAllocator);
            Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                            BloombergLP::bslmf::MovableRefUtil::move(adoptee));
            d_rep_p = rep;
            BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(
                                                                       d_ptr_p,
                                                                       this);
        }
    }
# endif // BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS
#endif // BSLS_LIBRARYFEATURES_HAS_CPP11_UNIQUE_PTR
 
    /// Create a shared pointer that manages the same modifiable object (if
    /// any) as the specified `source` shared pointer to the (template
    /// parameter) type `ANY_TYPE`, and that refers to the modifiable object
    /// at the specified `object` address.  The resulting shared pointer is
    /// known as an "alias" of `source`.  Note that typically the objects
    /// referred to by `source` and `object` have identical lifetimes (e.g.,
    /// one might be a part of the other), so that the deleter for `source`
    /// will destroy them both, but they do not necessarily have the same
    /// type.  Also note that if `source` is empty, then an empty shared
    /// pointer is created, even if `object` is not null (in which case this
    /// empty shared pointer will refer to the same object as `object`).
    /// Also note that if `object` is null and `source` is not empty, then a
    /// reference-counted null pointer alias will be created.
    template <class ANY_TYPE>
    shared_ptr(const shared_ptr<ANY_TYPE>&  source,
               ELEMENT_TYPE                *object) BSLS_KEYWORD_NOEXCEPT;
 
    /// Create a shared pointer that manages the same modifiable object (if
    /// any) as the specified `other` shared pointer to the (template
    /// parameter) type `COMPATIBLE_TYPE`, uses the same deleter as `other`
    /// to destroy the shared object, and refers to
    /// `(ELEMENT_TYPE*)other.get()`.  If `COMPATIBLE_TYPE *` is not
    /// implicitly convertible to `ELEMENT_TYPE *`, then a compiler
    /// diagnostic will be emitted indicating the error.  Note that if
    /// `other` is empty, then an empty shared pointer is created, which may
    /// still point to an un-managed object if `other` were constructed
    /// through an aliasing constructor.
    template <class COMPATIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE>
    shared_ptr(const shared_ptr<COMPATIBLE_TYPE>& other) BSLS_KEYWORD_NOEXCEPT;
 
    /// Create a shared pointer that refers to and manages the same object
    /// (if any) as the specified `original` shared pointer, and uses the
    /// same deleter as `original` to destroy the shared object.  Note that
    /// if `original` is empty, then an empty shared pointer is created,
    /// which may still point to an un-managed object if `original` were
    /// constructed through an aliasing constructor.
    shared_ptr(const shared_ptr& original) BSLS_KEYWORD_NOEXCEPT;
 
    /// Create a shared pointer that refers to and assumes management of the
    /// same object (if any) as the specified `original` shared pointer,
    /// using the same deleter as `original` to destroy the shared object,
    /// and reset `original` to an empty state, not pointing to any object.
    /// Note that if `original` is empty, then an empty shared pointer is
    /// created, which may still point to an un-managed object if `original`
    /// were constructed through an aliasing constructor.
    shared_ptr(BloombergLP::bslmf::MovableRef<shared_ptr> original)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
    /// Create a shared pointer that refers to and assumes management of the
    /// same object (if any) as the specified `other` shared pointer to the
    /// (template parameter) type `COMPATIBLE_TYPE`, using the same deleter
    /// as `other` to destroy the shared object, and refers to
    /// `(ELEMENT_TYPE*)other.get()`.  If `COMPATIBLE_TYPE *` is not
    /// implicitly convertible to `ELEMENT_TYPE *`, then a compiler
    /// diagnostic will be emitted indicating the error.  Note that if
    /// `other` is empty, then an empty shared pointer is created, which may
    /// still point to an un-managed object if `other` were constructed
    /// through an aliasing constructor.
    template <class COMPATIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE>
    shared_ptr(shared_ptr<COMPATIBLE_TYPE>&& other) BSLS_KEYWORD_NOEXCEPT;
#else
    /// Create a shared pointer that refers to and assumes management of the
    /// same object (if any) as the specified `other` shared pointer to the
    /// (template parameter) type `COMPATIBLE_TYPE`, using the same deleter
    /// as `other` to destroy the shared object, and refers to
    /// `(ELEMENT_TYPE*)other.get()`.  If `COMPATIBLE_TYPE *` is not
    /// implicitly convertible to `ELEMENT_TYPE *`, then a compiler
    /// diagnostic will be emitted indicating the error.  Note that if
    /// `other` is empty, then an empty shared pointer is created, which may
    /// still point to an un-managed object if `other` were constructed
    /// through an aliasing constructor.
    template <class COMPATIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE>
    shared_ptr(
           BloombergLP::bslmf::MovableRef<shared_ptr<COMPATIBLE_TYPE> > other)
                                                         BSLS_KEYWORD_NOEXCEPT;
#endif
 
    /// Create a shared pointer that refers to and manages the same object
    /// as the specified `ptr` if `ptr.expired()` is `false`; otherwise,
    /// create a shared pointer in the empty state.  Note that the
    /// referenced and managed objects may be different if `ptr` was created
    /// from a `shared_ptr` in an aliasing state.
    template<class COMPATIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE>
    explicit shared_ptr(const weak_ptr<COMPATIBLE_TYPE>& ptr);
 
#if !defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
    /// Create a shared pointer that refers to and manages the same object
    /// as the specified `ptr` if  `ptr.expired()` is `false`; otherwise,
    /// create a shared pointer in the empty state.  Note that the
    /// referenced and managed objects may be different if `ptr` was created
    /// from a `shared_ptr` in an aliasing state.  Also note that this
    /// overloaded constructor is necessary only for C++03 compilers that
    /// rely on the BDE move-emulation type, `bslmf::MovableRef`; a C++11
    /// compiler will pass rvalues directly to the constructor taking a
    /// `const weak_ptr&`, rendering this constructor redundant.
    template<class COMPATIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE>
    explicit shared_ptr(
              BloombergLP::bslmf::MovableRef<weak_ptr<COMPATIBLE_TYPE> > ptr);
#endif
 
    /// Destroy this shared pointer.  If this shared pointer refers to a
    /// (possibly shared) object, then release the reference to that object,
    /// and destroy the shared object using its associated deleter if this
    /// shared pointer is the last reference to that object.
    ~shared_ptr();
 
    // MANIPULATORS
 
    /// Make this shared pointer manage the same modifiable object as the
    /// specified `rhs` shared pointer to the (template parameter) type
    /// `COMPATIBLE_TYPE`, use the same deleter as `rhs`, and refer to
    /// `(ELEMENT_TYPE *)rhs.get()`; return a reference providing modifiable
    /// access to this shared pointer.  Note that if `rhs` is empty, then
    /// this shared pointer will also be empty after the assignment.  Also
    /// note that if `*this` is the same object as `rhs`, then this method
    /// has no effect.
    shared_ptr& operator=(const shared_ptr& rhs) BSLS_KEYWORD_NOEXCEPT;
 
    /// Make this shared pointer manage the same modifiable object as the
    /// specified `rhs` shared pointer to the (template parameter) type
    /// `COMPATIBLE_TYPE`, use the same deleter as `rhs`, and refer to
    /// `rhs.get()`; return a reference providing modifiable access to this
    /// shared pointer.  Reset `rhs` to an empty state, not pointing to any
    /// object, unless `*this` is the same object as `rhs`.  Note that if
    /// `rhs` is empty, then this shared pointer will also be empty after
    /// the assignment.
    shared_ptr& operator=(BloombergLP::bslmf::MovableRef<shared_ptr> rhs)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Make this shared pointer refer to and manage the same modifiable
    /// object as the specified `rhs` shared pointer to the (template
    /// parameter) type `COMPATIBLE_TYPE`, using the same deleter as `rhs`
    /// and referring to `(ELEMENT_TYPE *)rhs.get()`, and return a reference
    /// to this modifiable shared pointer.  If this shared pointer is
    /// already managing a (possibly shared) object, then release the shared
    /// reference to that object, and destroy it using its associated
    /// deleter if this shared pointer held the last shared reference to
    /// that object.  Note that if `rhs` is empty, then this shared pointer
    /// will also be empty after the assignment.
    template <class COMPATIBLE_TYPE>
    typename enable_if<
        is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
        shared_ptr&>::type
    operator=(const shared_ptr<COMPATIBLE_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
    /// Make this shared pointer refer to and manage the same modifiable
    /// object as the specified `rhs` shared pointer to the (template
    /// parameter) type `COMPATIBLE_TYPE`, using the same deleter as `rhs`
    /// and referring to `(ELEMENT_TYPE *)rhs.get()`, and return a reference
    /// to this modifiable shared pointer.  If this shared pointer is
    /// already managing a (possibly shared) object, then release the shared
    /// reference to that object, and destroy it using its associated
    /// deleter if this shared pointer held the last shared reference to
    /// that object.  Reset `rhs` to an empty state, not pointing to any
    /// object, unless `*this` is the same object as `rhs`.  This function
    /// does not exist unless a pointer to (template parameter)
    /// `COMPATIBLE_TYPE` is convertible to a pointer to the (template
    /// parameter) `ELEMENT_TYPE` of this `shared_ptr`.  Note that if `rhs`
    /// is empty, then this shared pointer will also be empty after the
    /// assignment.
    template <class COMPATIBLE_TYPE>
    typename
            enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
                      shared_ptr&>::type
    operator=(shared_ptr<COMPATIBLE_TYPE>&& rhs) BSLS_KEYWORD_NOEXCEPT;
#else
    /// Make this shared pointer refer to and manage the same modifiable
    /// object as the specified `rhs` shared pointer to the (template
    /// parameter) type `COMPATIBLE_TYPE`, using the same deleter as `rhs`
    /// and referring to `(ELEMENT_TYPE *)rhs.get()`, and return a reference
    /// to this modifiable shared pointer.  If this shared pointer is
    /// already managing a (possibly shared) object, then release the shared
    /// reference to that object, and destroy it using its associated
    /// deleter if this shared pointer held the last shared reference to
    /// that object.  Reset `rhs` to an empty state, not pointing to any
    /// object, unless `*this` is the same object as `rhs`.  This function
    /// does not exist unless a pointer to (template parameter)
    /// `COMPATIBLE_TYPE` is convertible to a pointer to the (template
    /// parameter) `ELEMENT_TYPE` of this `shared_ptr`.  Note that if `rhs`
    /// is empty, then this shared pointer will also be empty after the
    /// assignment.
    template <class COMPATIBLE_TYPE>
    typename
            enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
                      shared_ptr&>::type
    operator=(BloombergLP::bslmf::MovableRef<shared_ptr<COMPATIBLE_TYPE> > rhs)
                                                         BSLS_KEYWORD_NOEXCEPT;
#endif
 
    /// Transfer, to this shared pointer, ownership of the modifiable object
    /// managed by the specified `rhs` managed pointer to the (template
    /// parameter) type `COMPATIBLE_TYPE`, and make this shared pointer
    /// refer to `(ELEMENT_TYPE *)rhs.ptr()`.  The deleter used in the `rhs`
    /// will be used to destroy the shared object when all references have
    /// been released.  The *default* *allocator* is used to allocate a
    /// `SharedPtrRep`, if needed (users must use the copy-constructor and
    /// swap instead of using this operator to supply an alternative
    /// allocator).  If this shared pointer is already managing a (possibly
    /// shared) object, then release the reference to that shared object,
    /// and destroy it using its associated deleter if this shared pointer
    /// held the last shared reference to that object.  Note that if `rhs`
    /// is empty, then this shared pointer will be empty after the
    /// assignment.  Also note that if `rhs` owns a reference to another
    /// shared object (due to a previous call to
    /// `shared_ptr<T>::managedPtr`) then this `shared_ptr` will adopt the
    /// `ManagedPtr`s ownership of that shared object.
    template <class COMPATIBLE_TYPE>
    typename enable_if<
        is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
        shared_ptr&>::type
    operator=(BloombergLP::bslma::ManagedPtr<COMPATIBLE_TYPE> rhs);
 
#if defined(BSLS_LIBRARYFEATURES_HAS_CPP98_AUTO_PTR)
    /// Transfer, to this shared pointer, ownership of the modifiable object
    /// managed by the specified `rhs` auto pointer to the (template
    /// parameter) type `COMPATIBLE_TYPE`, and make this shared pointer
    /// refer to `(ELEMENT_TYPE *)rhs.get()`.  `delete(autoPtr.release())`
    /// will be called to destroy the shared object when all references have
    /// been released.  If this shared pointer is already managing a
    /// (possibly shared) object, then release the reference to that shared
    /// object, and destroy it using its associated deleter if this shared
    /// pointer held the last shared reference to that object.  Note that if
    /// `rhs` is empty, then this shared pointer will be empty after the
    /// assignment.
    template <class COMPATIBLE_TYPE>
    typename enable_if<
        is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
        shared_ptr&>::type
    operator=(std::auto_ptr<COMPATIBLE_TYPE> rhs);
#endif
 
#if defined(BSLS_LIBRARYFEATURES_HAS_CPP11_UNIQUE_PTR)
    /// Transfer, to this shared pointer, ownership of the object managed by
    /// the specified `rhs` unique pointer to the (template parameter) type
    /// `COMPATIBLE_TYPE`, and make this shared pointer refer to
    /// `(ELEMENT_TYPE *)rhs.get()`.  The deleter of `rhs` will be called to
    /// destroy the shared object when all references have been released.
    /// If this shared pointer is already managing a (possibly shared)
    /// object, then release the reference to that shared object, and
    /// destroy it using its associated deleter if this shared pointer held
    /// the last shared reference to that object.  This function does not
    /// exist unless `unique_ptr<COMPATIBLE_TYPE, DELETER>::pointer` is
    /// convertible to `ELEMENT_TYPE *`.  Note that if `rhs` is empty, then
    /// this shared pointer will be empty after the assignment.  Also note
    /// that this function creates a `shared_ptr` with an unspecified
    /// deleter type that satisfies this contract; the C++11 standard
    /// specifies the exact deleter that should be in use after assignment,
    /// so this implementation may be non-conforming.
    template <class COMPATIBLE_TYPE, class UNIQUE_DELETER>
    typename enable_if<
        is_convertible<
            typename std::unique_ptr<COMPATIBLE_TYPE, UNIQUE_DELETER>::pointer,
                                     ELEMENT_TYPE *>::value,
            shared_ptr&>::type
    operator=(std::unique_ptr<COMPATIBLE_TYPE, UNIQUE_DELETER>&& rhs);
#endif
 
    /// Reset this shared pointer to the empty state.  If this shared
    /// pointer is managing a (possibly shared) object, then release the
    /// reference to the shared object, calling the associated deleter to
    /// destroy the shared object if this shared pointer is the last shared
    /// reference.
    void reset() BSLS_KEYWORD_NOEXCEPT;
 
    /// Modify this shared pointer to manage the modifiable object of the
    /// (template parameter) type `COMPATIBLE_TYPE` at the specified `ptr`
    /// address and to refer to `(ELEMENT_TYPE *)ptr`.  If this shared
    /// pointer is already managing a (possibly shared) object, then, unless
    /// an exception is thrown allocating memory to manage `ptr`, release
    /// the reference to the shared object, calling the associated deleter
    /// to destroy the shared object if this shared pointer is the last
    /// reference.  The currently installed default allocator is used to
    /// allocate the internal representation of this shared pointer, and the
    /// shared object will be destroyed by a call to `delete ptr` when all
    /// references have been released.  If an exception is thrown allocating
    /// the internal representation, then `delete ptr` is called and this
    /// shared pointer retains ownership of its original object.  If
    /// `COMPATIBLE_TYPE*` is not implicitly convertible to `ELEMENT_TYPE*`,
    /// then a compiler diagnostic will be emitted indicating the error.
    /// Note that if `ptr` is 0, then this shared pointer will still
    /// allocate an internal representation to share ownership of that empty
    /// state, which will be reclaimed when the last reference is destroyed.
    template <class COMPATIBLE_TYPE>
    typename
      enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value>::type
    reset(COMPATIBLE_TYPE *ptr);
 
    /// Modify this shared pointer to manage the modifiable object of the
    /// (template parameter) type `COMPATIBLE_TYPE` at the specified `ptr`
    /// address, refer to `(ELEMENT_TYPE *)ptr`, and use the specified
    /// `deleter` to delete the shared object when all references have been
    /// released.  If this shared pointer is already managing a (possibly
    /// shared) object, then unless an exception is thrown allocating memory
    /// to manage `ptr`, release the reference to the shared object, calling
    /// the associated deleter to destroy the shared object if this shared
    /// pointer is the last reference.  If `DELETER` is an object type, then
    /// `deleter` is assumed to be a function-like deleter that may be
    /// invoked to destroy the object referred to by a single argument of
    /// type `COMPATIBLE_TYPE *` (i.e., `deleter(ptr)` will be called to
    /// destroy the shared object).  If `DELETER` is a pointer type that is
    /// not a function pointer, then `deleter` shall be a pointer to a
    /// factory object that exposes a member function that can be invoked as
    /// `deleteObject(ptr)` that will be called to destroy the object at the
    /// `ptr` address (i.e., `deleter->deleteObject(ptr)` will be called to
    /// delete the shared object).  (See the "Deleters" section in the
    /// component-level documentation.)  If `DELETER` is also a pointer to
    /// `bslma::Allocator` or to a class derived from `bslma::Allocator`,
    /// then that allocator will also be used to allocate and destroy the
    /// internal representation of this shared pointer when all references
    /// have been released; otherwise, the currently installed default
    /// allocator is used to allocate and destroy the internal
    /// representation of this shared pointer when all references have been
    /// released.  If an exception is thrown allocating the internal
    /// representation, then `deleter(ptr)` is called (or
    /// `deleter->deleteObject(ptr)` for factory-type deleters) and this
    /// shared pointer retains ownership of its original object.  If
    /// `COMPATIBLE_TYPE*` is not implicitly convertible to `ELEMENT_TYPE*`,
    /// then a compiler diagnostic will be emitted indicating the error.
    /// Note that, for factory deleters, `deleter` must remain valid until
    /// all references to `ptr` have been released.  If `ptr` is 0, then an
    /// internal representation will still be allocated, and this shared
    /// pointer will share ownership of a copy of `deleter`.  Further note
    /// that this function is logically equivalent to:
    /// @code
    /// *this = shared_ptr<ELEMENT_TYPE>(ptr, deleter);
    /// @endcode
    template <class COMPATIBLE_TYPE, class DELETER>
    typename
      enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value>::type
    reset(COMPATIBLE_TYPE *ptr, DELETER deleter);
 
 
    /// Modify this shared pointer to manage the modifiable object of the
    /// (template parameter) type `COMPATIBLE_TYPE` at the specified `ptr`
    /// address, refer to `(ELEMENT_TYPE *)ptr` and use the specified
    /// `deleter` to delete the shared object when all references have been
    /// released.  Use the specified `basicAllocator` to allocate and
    /// deallocate the internal representation of the shared pointer.  If
    /// this shared pointer is already managing a (possibly shared) object,
    /// then, unless an exception is thrown allocating memory to manage
    /// `ptr`, release the shared reference to that shared object, and
    /// destroy it using its associated deleter if this shared pointer held
    /// the last shared reference to that object.  If `DELETER` is a
    /// reference type, then `deleter` is assumed to be a function-like
    /// deleter that may be invoked to destroy the object referred to by a
    /// single argument of type `COMPATIBLE_TYPE *` (i.e., `deleter(ptr)`
    /// will be called to destroy the shared object).  If `DELETER` is a
    /// pointer type, then `deleter` is assumed to be a pointer to a factory
    /// object that exposes a member function that can be invoked as
    /// `deleteObject(ptr)` that will be called to destroy the object at the
    /// `ptr` address (i.e., `deleter->deleteObject(ptr)` will be called to
    /// delete the shared object).  (See the "Deleters" section in the
    /// component-level documentation.)  If an exception is thrown
    /// allocating the internal representation, then `deleter(ptr)` is
    /// called (or `deleter->deleteObject(ptr)` for factory-type deleters)
    /// and this shared pointer retains ownership of its original object.
    /// The behavior is undefined unless `deleter(ptr)` is a well-defined
    /// expression (or `deleter->deleteObject(ptr)` for factory-type
    /// deleters), and unless the copy constructor for `deleter` does not
    /// throw an exception.  If `COMPATIBLE_TYPE *` is not implicitly
    /// convertible to `ELEMENT_TYPE *`, then a compiler diagnostic will be
    /// emitted indicating the error.  Note that, for factory deleters, the
    /// `deleter` must remain valid until all references to `ptr` have been
    /// released.  Also note that if `ptr` is 0, then an internal
    /// representation will still be allocated, and this shared pointer will
    /// share ownership of a copy of `deleter`.  Further note that this
    /// function is logically equivalent to:
    /// @code
    /// *this = shared_ptr<ELEMENT_TYPE>(ptr, deleter, basicAllocator);
    /// @endcode
    template <class COMPATIBLE_TYPE, class DELETER, class ALLOCATOR>
    typename
      enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value>::type
    reset(COMPATIBLE_TYPE *ptr,
          DELETER          deleter,
          ALLOCATOR        basicAllocator);
 
    /// Modify this shared pointer to manage the same modifiable object (if
    /// any) as the specified `source` shared pointer to the (template
    /// parameter) type `ANY_TYPE`, and refer to the modifiable object at
    /// the specified `ptr` address (i.e., make this shared pointer an
    /// "alias" of `source`).  If this shared pointer is already managing a
    /// (possibly shared) object, then release the reference to the shared
    /// object, calling the associated deleter to destroy the shared object
    /// if this shared pointer is the last reference.  Note that typically
    /// the objects referred to by `source` and `ptr` have identical
    /// lifetimes (e.g., one might be a part of the other), so that the
    /// deleter for `source` will destroy them both, but do not necessarily
    /// have the same type.  Also note that if `source` is empty, then this
    /// shared pointer will be reset to an empty state, even if `ptr` is not
    /// null (in which case this empty shared pointer will refer to the same
    /// object as `ptr`).  Also note that if `ptr` is null and `source` is
    /// not empty, then this shared pointer will be reset to a
    /// (reference-counted) null pointer alias.  Further note that the
    /// behavior of this method is the same as `loadAlias(source, ptr)`.
    /// Finally note that this is a non-standard BDE extension to the C++
    /// Standard `shared_ptr` interface, which does not provide an alias
    /// overload for the `reset` function.
    template <class ANY_TYPE>
    void reset(const shared_ptr<ANY_TYPE>& source, ELEMENT_TYPE *ptr);
 
    /// Efficiently exchange the states of this shared pointer and the
    /// specified `other` shared pointer such that each will refer to the
    /// object formerly referred to by the other and each will manage the
    /// object formerly managed by the other.
    void swap(shared_ptr& other) BSLS_KEYWORD_NOEXCEPT;
 
    // ADDITIONAL BSL MANIPULATORS
 
    /// Create "in-place" in a large enough contiguous memory region both an
    /// internal representation for this shared pointer and a
    /// default-constructed object of `ELEMENT_TYPE`, and make this shared
    /// pointer refer to the newly-created `ELEMENT_TYPE` object.  The
    /// currently installed default allocator is used to supply memory.  If
    /// an exception is thrown during allocation or construction of the
    /// `ELEMENT_TYPE` object, this shared pointer will be unchanged.
    /// Otherwise, if this shared pointer is already managing a (possibly
    /// shared) object, then release the shared reference to that shared
    /// object, and destroy it using its associated deleter if this shared
    /// pointer held the last shared reference to that object.
    void createInplace();
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_sharedptr.h
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT 14
#endif
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#endif
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 0
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 0
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 1
    template <class ARGS_01>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 1
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 2
    template <class ARGS_01,
              class ARGS_02>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 2
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 3
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 3
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 4
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 4
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 5
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 5
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 6
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05,
              class ARGS_06>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 6
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 7
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05,
              class ARGS_06,
              class ARGS_07>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 7
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 8
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05,
              class ARGS_06,
              class ARGS_07,
              class ARGS_08>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 8
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 9
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05,
              class ARGS_06,
              class ARGS_07,
              class ARGS_08,
              class ARGS_09>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 9
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 10
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05,
              class ARGS_06,
              class ARGS_07,
              class ARGS_08,
              class ARGS_09,
              class ARGS_10>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 10
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 11
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05,
              class ARGS_06,
              class ARGS_07,
              class ARGS_08,
              class ARGS_09,
              class ARGS_10,
              class ARGS_11>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 11
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 12
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05,
              class ARGS_06,
              class ARGS_07,
              class ARGS_08,
              class ARGS_09,
              class ARGS_10,
              class ARGS_11,
              class ARGS_12>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 12
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 13
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05,
              class ARGS_06,
              class ARGS_07,
              class ARGS_08,
              class ARGS_09,
              class ARGS_10,
              class ARGS_11,
              class ARGS_12,
              class ARGS_13>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 13
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 14
    template <class ARGS_01,
              class ARGS_02,
              class ARGS_03,
              class ARGS_04,
              class ARGS_05,
              class ARGS_06,
              class ARGS_07,
              class ARGS_08,
              class ARGS_09,
              class ARGS_10,
              class ARGS_11,
              class ARGS_12,
              class ARGS_13,
              class ARGS_14>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_A >= 14
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
 
    template <class... ARGS>
    void createInplace(BloombergLP::bslma::Allocator *basicAllocator,
                       BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args);
// }}} END GENERATED CODE
#endif
 
    /// [**DEPRECATED**] Use `reset` instead.
    ///
    /// Modify this shared pointer to manage the same modifiable object (if
    /// any) as the specified `source` shared pointer to the (template
    /// parameter) type `ANY_TYPE`, and refer to the modifiable object at
    /// the specified `object` address (i.e., make this shared pointer an
    /// "alias" of `source`).  If this shared pointer is already managing a
    /// (possibly shared) object, then release the shared reference to that
    /// shared object, and destroy it using its associated deleter if this
    /// shared pointer held the last shared reference to that object.  Note
    /// that typically the objects referred to by `source` and `object` have
    /// identical lifetimes (e.g., one might be a part of the other), so
    /// that the deleter for `source` will destroy them both, but they do
    /// not necessarily have the same type.  Also note that if `source` is
    /// empty, then this shared pointer will be reset to an empty state,
    /// even if `object` is not null (in which case this empty shared
    /// pointer will refer to the same object as `object`).  Also note that
    /// if `object` is null and `source` is not empty, then this shared
    /// pointer will be reset to a (reference-counted) null pointer alias.
    /// Also note that this function is logically equivalent to:
    /// @code
    /// *this = shared_ptr<ELEMENT_TYPE>(source, object);
    /// @endcode
    /// Further note that the behavior of this method is the same as
    /// `reset(source, object)`.
    template <class ANY_TYPE>
    void loadAlias(const shared_ptr<ANY_TYPE>&  source,
                   ELEMENT_TYPE                *object);
 
    /// Return the pair consisting of the addresses of the modifiable
    /// `ELEMENT_TYPE` object referred to, and the representation shared by,
    /// this shared pointer, and reset this shared pointer to the empty
    /// state, referring to no object, with no effect on the representation.
    /// The reference counter is not modified nor is the shared object
    /// deleted; if the reference count of the representation is greater
    /// than one, then it is not safe to release the representation (thereby
    /// destroying the shared object), but it is always safe to create
    /// another shared pointer with the representation using the constructor
    /// with the following signature:
    /// @code
    /// 'shared_ptr(ELEMENT_TYPE                     *ptr,
    ///             BloombergLP::bslma::SharedPtrRep *rep)'
    /// @endcode
    /// Note that this function returns a pair of null pointers if this
    /// shared pointer is empty.
    pair<element_type *, BloombergLP::bslma::SharedPtrRep *> release()
                                                         BSLS_KEYWORD_NOEXCEPT;
 
#ifndef BDE_OMIT_INTERNAL_DEPRECATED
    // DEPRECATED BDE LEGACY MANIPULATORS
 
    /// [**DEPRECATED**] Use `reset` instead.
    ///
    /// Reset this shared pointer to the empty state.  If this shared
    /// pointer is managing a (possibly shared) object, then release the
    /// reference to the shared object, calling the associated deleter to
    /// destroy the shared object if this shared pointer is the last
    /// reference.  Note that the behavior of this method is the same as
    /// `reset()`.
    void clear() BSLS_KEYWORD_NOEXCEPT;
 
    /// [**DEPRECATED**] Use `reset` instead.
    ///
    /// Modify this shared pointer to manage the modifiable object of the
    /// (template parameter) type `COMPATIBLE_TYPE` at the specified `ptr`
    /// address and to refer to `(ELEMENT_TYPE *)ptr`.  If this shared
    /// pointer is already managing a (possibly shared) object, then, unless
    /// an exception is thrown allocating memory to manage `ptr`, release
    /// the reference to the shared object, calling the associated deleter
    /// to destroy the shared object if this shared pointer is the last
    /// reference.  The currently installed default allocator is used to
    /// allocate the internal representation of this shared pointer, and the
    /// shared object will be destroyed by a call to `delete ptr` when all
    /// references have been released.  If an exception is thrown allocating
    /// the internal representation, then `delete ptr` is called and this
    /// shared pointer retains ownership of its original object.  If
    /// `COMPATIBLE_TYPE*` is not implicitly convertible to `ELEMENT_TYPE*`,
    /// then a compiler diagnostic will be emitted indicating the error.
    /// Note that if `ptr` is 0, then this shared pointer will still
    /// allocate an internal representation to share ownership of that empty
    /// state, which will be reclaimed when the last reference is destroyed.
    /// Also note also that the behavior of this method is the same as
    /// `reset(ptr)`.
    template <class COMPATIBLE_TYPE>
    void load(COMPATIBLE_TYPE *ptr);
 
    /// [**DEPRECATED**] Use `reset` instead.
    ///
    /// Modify this shared pointer to manage the modifiable object of the
    /// (template parameter) type `COMPATIBLE_TYPE` at the specified `ptr`
    /// address and to refer to `(ELEMENT_TYPE *)ptr`.  If this shared
    /// pointer is already managing a (possibly shared) object, then, unless
    /// an exception is thrown allocating memory to manage `ptr`, release
    /// the reference to the shared object, calling the associated deleter
    /// to destroy the shared object if this shared pointer is the last
    /// reference.  Use the specified `basicAllocator` to allocate the
    /// internal representation of this shared pointer and to destroy the
    /// shared object when all references have been released; if
    /// `basicAllocator` is 0, the currently installed default allocator is
    /// used.  If an exception is thrown allocating the internal
    /// representation, then destroy `*ptr` with a call to
    /// `alloc->deleteObject(ptr)` where `alloc` is the chosen allocator,
    /// and this shared pointer retains ownership of its original object.
    /// If `COMPATIBLE_TYPE *` is not implicitly convertible to
    /// `ELEMENT_TYPE *`, then a compiler diagnostic will be emitted
    /// indicating the error.  Note that if `ptr` is 0, then this shared
    /// pointer will still allocate an internal representation to share
    /// ownership of that empty state, which will be reclaimed when the last
    /// reference is destroyed.  Also note that this function is logically
    /// equivalent to:
    /// @code
    /// *this = shared_ptr<ELEMENT_TYPE>(ptr, basicAllocator);
    /// @endcode
    template <class COMPATIBLE_TYPE>
    void load(COMPATIBLE_TYPE               *ptr,
              BloombergLP::bslma::Allocator *basicAllocator);
 
    /// [**DEPRECATED**] Use `reset` instead.
    ///
    /// Modify this shared pointer to manage the modifiable object of the
    /// (template parameter) type `COMPATIBLE_TYPE` at the specified `ptr`
    /// address, refer to `(ELEMENT_TYPE *)ptr` and use the specified
    /// `deleter` to delete the shared object when all references have been
    /// released.  Use the specified `basicAllocator` to allocate and
    /// deallocate the internal representation of the shared pointer.  If
    /// `basicAllocator` is 0, the currently installed default allocator is
    /// used.  If this shared pointer is already managing a (possibly
    /// shared) object, then, unless an exception is thrown creating storage
    /// to manage `ptr`, release the shared reference to that shared object,
    /// and destroy it using its associated deleter if this shared pointer
    /// held the last shared reference to that object.  If `DELETER` is a
    /// reference type, then `deleter` is assumed to be a function-like
    /// deleter that may be invoked to destroy the object referred to by a
    /// single argument of type `COMPATIBLE_TYPE *` (i.e., `deleter(ptr)`
    /// will be called to destroy the shared object).  If `DELETER` is a
    /// pointer type, then `deleter` is assumed to be a pointer to a factory
    /// object that exposes a member function that can be invoked as
    /// `deleteObject(ptr)` that will be called to destroy the object at the
    /// `ptr` address (i.e., `deleter->deleteObject(ptr)` will be called to
    /// delete the shared object).  (See the "Deleters" section in the
    /// component-level documentation.)  If an exception is thrown
    /// allocating the internal representation, then `deleter(ptr)` is
    /// called (or `deleter->deleteObject(ptr)` for factory-type deleters)
    /// and this shared pointer retains ownership of its original object.
    /// The behavior is undefined unless `deleter(ptr)` is a well-defined
    /// expression (or `deleter->deleteObject(ptr)` for factory-type
    /// deleters), and unless the copy constructor for `deleter` does not
    /// throw an exception.  If `COMPATIBLE_TYPE *` is not implicitly
    /// convertible to `ELEMENT_TYPE *`, then a compiler diagnostic will be
    /// emitted indicating the error.  Note that, for factory deleters, the
    /// `deleter` must remain valid until all references to `ptr` have been
    /// released.  Also note that if `ptr` is 0, then an internal
    /// representation will still be allocated, and this shared pointer will
    /// share ownership of a copy of `deleter`.  Further note that this
    /// function is logically equivalent to:
    /// @code
    /// *this = shared_ptr<ELEMENT_TYPE>(ptr, deleter, basicAllocator);
    /// @endcode
    template <class COMPATIBLE_TYPE, class DELETER>
    void load(COMPATIBLE_TYPE               *ptr,
              const DELETER&                 deleter,
              BloombergLP::bslma::Allocator *basicAllocator);
 
#endif // BDE_OMIT_INTERNAL_DEPRECATED
 
    // ACCESSORS
 
    /// Return a value of an "unspecified bool" type that evaluates to
    /// `false` if this shared pointer does not refer to an object, and
    /// `true` otherwise.  Note that this conversion operator allows a
    /// shared pointer to be used within a conditional context (e.g., within
    /// an `if` or `while` statement), but does *not* allow shared pointers
    /// to unrelated types to be compared (e.g., via `<` or `>`).
    operator BoolType() const BSLS_KEYWORD_NOEXCEPT;
 
    /// Return a reference providing modifiable access to the object
    /// referred to by this shared pointer.  The behavior is undefined
    /// unless this shared pointer refers to an object, and `ELEMENT_TYPE`
    /// is not (potentially `const` or `volatile` qualified) `void`.
    typename add_lvalue_reference<ELEMENT_TYPE>::type
    operator*() const BSLS_KEYWORD_NOEXCEPT;
 
    /// Return the address providing modifiable access to the object
    /// referred to by this shared pointer, or 0 if this shared pointer does
    /// not refer to an object.  Note that applying this operator
    /// conventionally (e.g., to invoke a method) to an shared pointer that
    /// does not refer to an object will result in undefined behavior.
    ELEMENT_TYPE *operator->() const BSLS_KEYWORD_NOEXCEPT;
 
    /// Return the address providing modifiable access to the object
    /// referred to by this shared pointer, or 0 if this shared pointer does
    /// not refer to an object.
    element_type *get() const BSLS_KEYWORD_NOEXCEPT;
 
    /// Return a reference providing modifiable access to the object at the
    /// specified `index` offset in the object referred to by this shared
    /// pointer.  The behavior is undefined unless this shared pointer is
    /// not empty, `ELEMENT_TYPE` is not `void` (a compiler error will be
    /// generated if this operator is instantiated within the
    /// `shared_ptr<void>` class), and this shared pointer refers to an
    /// array of `ELEMENT_TYPE` objects.  Instead of `element_type &`, we
    /// use `add_lvalue_reference<element_type>::type` for the return type
    /// because that allows people to instantiate `shared_ptr<cv_void>`, as
    /// long as they don't use this method.  Note that this method is
    /// logically equivalent to `*(get() + index)`.
    typename add_lvalue_reference<element_type>::type
    operator[](ptrdiff_t index) const;
 
    template<class ANY_TYPE>
    bool owner_before(const shared_ptr<ANY_TYPE>& other) const
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Return `true` if the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by this shared
    /// pointer is ordered before the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by the specified
    /// `other` shared pointer under the total ordering defined by
    /// `std::less<BloombergLP::bslma::SharedPtrRep *>`, and `false`
    /// otherwise.
    template<class ANY_TYPE>
    bool owner_before(const weak_ptr<ANY_TYPE>& other) const
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    template<class ANY_TYPE>
    bool owner_equal(const shared_ptr<ANY_TYPE>& other) const
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Return `true` if the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by this shared
    /// pointer is equal to the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by the specified
    /// `other` shared pointer, and `false` otherwise.
    template<class ANY_TYPE>
    bool owner_equal(const weak_ptr<ANY_TYPE>& other) const
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Return an unspecified value such that, for any object `x` where
    /// `owner_equal(x)` is true, `owner_hash() == x.owner_hash()` is true.
    /// Note that this is based on the hash of the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by this object.
    /// Note also that for two empty smart pointers `x` and `y`,
    /// `x.owner_hash() == y.owner_hash()` is true.
    size_t owner_hash() const BSLS_KEYWORD_NOEXCEPT;
 
    BSLS_DEPRECATE_FEATURE("bsl",
                           "deprecated_cpp17_standard_library_features",
                           "do not use")
    /// Return `true` if this shared pointer is not empty and does not share
    /// ownership of the object it managed with any other shared pointer,
    /// and `false` otherwise.  Note that a shared pointer with a custom
    /// deleter can refer to a null pointer without being empty, and so may
    /// be `unique`.  Also note that the result of this function may not be
    /// reliable in a multi-threaded program, where a weak pointer may be
    /// locked on another thread.
    ///
    /// DEPRECATED: This function is deprecated in C++17 because its
    /// correctness is not guaranteed since the value returned by the used
    /// @ref use_count  function is approximate.
    bool unique() const BSLS_KEYWORD_NOEXCEPT;
 
    /// Return a "snapshot" of the number of shared pointers (including this
    /// one) that share ownership of the object managed by this shared
    /// pointer.  Note that 0 is returned if this shared pointer is empty.
    /// Also note that any result other than 0 may be unreliable in a
    /// multi-threaded program, where another pointer sharing ownership in a
    /// different thread may be copied or destroyed, or a weak pointer may
    /// be locked in the case that 1 is returned (that would otherwise
    /// indicate unique ownership).
    long use_count() const BSLS_KEYWORD_NOEXCEPT;
 
    // ADDITIONAL BSL ACCESSORS
 
    /// Return a managed pointer that refers to the same object as this
    /// shared pointer.  If this shared pointer is not empty, and is not
    /// null, then increment the shared count on the shared object, and give
    /// the managed pointer a deleter that decrements the reference count
    /// for the shared object.  Note that if this `shared_ptr` is reference-
    /// counting a null pointer, the empty `bslma::ManagedPtr` returned will
    /// not participate in that shared ownership.
    BloombergLP::bslma::ManagedPtr<ELEMENT_TYPE> managedPtr() const;
 
    /// Return the address providing modifiable access to the
    /// `BloombergLP::bslma::SharedPtrRep` object used by this shared
    /// pointer, or 0 if this shared pointer is empty.
    BloombergLP::bslma::SharedPtrRep *rep() const BSLS_KEYWORD_NOEXCEPT;
 
#ifndef BDE_OMIT_INTERNAL_DEPRECATED
    // DEPRECATED BDE LEGACY ACCESSORS
 
    /// [**DEPRECATED**] Use @ref use_count  instead.
    ///
    /// Return a "snapshot" of the number of shared pointers (including this
    /// one) that share ownership of the object managed by this shared
    /// pointer.  Note that the behavior of this function is the same as
    /// @ref use_count , and the result may be unreliable in multi-threaded code
    /// for the same reasons.
    int numReferences() const BSLS_KEYWORD_NOEXCEPT;
 
    /// [**DEPRECATED**] Use `get` instead.
    ///
    /// Return the address providing modifiable access to the object
    /// referred to by this shared pointer, or 0 if this shared pointer does
    /// not refer to an object.  Note that the behavior of this function is
    /// the same as `get`.
    element_type *ptr() const BSLS_KEYWORD_NOEXCEPT;
#endif // BDE_OMIT_INTERNAL_DEPRECATED
};
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_CTAD
// CLASS TEMPLATE DEDUCTION GUIDES
 
//  The obvious deduction guide:
//  template <class T>
//  shared_ptr(T*) -> shared_ptr<T>;
//  is not provided because there's no way to distinguish from T* and T[].
 
/// Deduce the specified type `ELEMENT_TYPE` corresponding template
/// parameter of the `bsl::weak_ptr` supplied to the constructor of
/// `shared_ptr`.
template<class ELEMENT_TYPE>
shared_ptr(weak_ptr<ELEMENT_TYPE>) -> shared_ptr<ELEMENT_TYPE>;
 
/// Deduce the specified type `ELEMENT_TYPE` corresponding template
/// parameter of the `std::unique_ptr` supplied to the constructor of
/// `shared_ptr`.
template<class ELEMENT_TYPE, class DELETER>
shared_ptr(std::unique_ptr<ELEMENT_TYPE, DELETER>)
-> shared_ptr<ELEMENT_TYPE>;
 
/// Deduce the specified type `ELEMENT_TYPE` corresponding template
/// parameter of the `std::unique_ptr` supplied to the constructor of
/// `shared_ptr`.  This guide does not participate in deduction unless the
/// specified `ALLOC` inherits from `bslma::Allocator`.
template<class ELEMENT_TYPE,
         class DELETER,
         class ALLOC,
         class = typename bsl::enable_if_t<
               bsl::is_convertible_v<ALLOC *, BloombergLP::bslma::Allocator *>>
         >
shared_ptr(std::unique_ptr<ELEMENT_TYPE, DELETER>, ALLOC *)
-> shared_ptr<ELEMENT_TYPE>;
 
// Deduction guides for `auto_ptr` and `auto_ptr_ref` are deliberately not
// provided, since auto_ptr has been removed from C++17.
 
/// Deduce the specified type `ELEMENT_TYPE` corresponding template
/// parameter of the `bslma::ManagedPtr` supplied to the constructor of
/// `shared_ptr`.
template<class ELEMENT_TYPE>
shared_ptr(BloombergLP::bslma::ManagedPtr<ELEMENT_TYPE>)
-> shared_ptr<ELEMENT_TYPE>;
 
/// Deduce the specified type `ELEMENT_TYPE` corresponding template
/// parameter of the `bslma::ManagedPtr` supplied to the constructor of
/// `shared_ptr`.  This guide does not participate in deduction unless the
/// specified `ALLOC` inherits from `bslma::Allocator`.
template<class ELEMENT_TYPE,
         class ALLOC,
         class = typename bsl::enable_if_t<
               bsl::is_convertible_v<ALLOC *, BloombergLP::bslma::Allocator *>>
         >
shared_ptr(BloombergLP::bslma::ManagedPtr<ELEMENT_TYPE>, ALLOC *)
-> shared_ptr<ELEMENT_TYPE>;
#endif
 
// FREE OPERATORS
 
/// Return `true` if the specified `lhs` shared pointer refers to the same
/// object (if any) as that referred to by the specified `rhs` shared
/// pointer (if any), and `false` otherwise; a compiler diagnostic will be
/// emitted indicating the error unless a (raw) pointer to `LHS_TYPE` can
/// be compared to a (raw) pointer to `RHS_TYPE`.  Note that two shared
/// pointers that compare equal do not necessarily manage the same object
/// due to aliasing.
template <class LHS_TYPE, class RHS_TYPE>
bool operator==(const shared_ptr<LHS_TYPE>& lhs,
                const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON
 
/// Perform a three-way comparison of the specified `lhs` and the specified
/// `rhs` pointers by using the comparison operators of `LHS_TYPE *` and
/// `RHS_TYPE *`; return the result of that comparison.
template<class LHS_TYPE, class RHS_TYPE>
strong_ordering operator<=>(const shared_ptr<LHS_TYPE>& lhs,
                            const shared_ptr<RHS_TYPE>& rhs)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
#else
 
/// Return `true` if the specified `lhs` shared pointer does not refer to
/// the same object (if any) as that referred to by the specified `rhs`
/// shared pointer (if any), and `false` otherwise; a compiler diagnostic
/// will be emitted indicating the error unless a (raw) pointer to
/// `LHS_TYPE` can be compared to a (raw) pointer to `RHS_TYPE`.  Note that
/// two shared pointers that do not compare equal may manage the same object
/// due to aliasing.
template <class LHS_TYPE, class RHS_TYPE>
bool operator!=(const shared_ptr<LHS_TYPE>& lhs,
                const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the address of the object that the specified `lhs`
/// shared pointer refers to is ordered before the address of the object
/// that the specified `rhs` shared pointer refers to under the total
/// ordering supplied by `std::less<T *>`, where `T *` is the composite
/// pointer type of `LHS_TYPE *` and `RHS_TYPE *`, and `false` otherwise.
template<class LHS_TYPE, class RHS_TYPE>
bool operator<(const shared_ptr<LHS_TYPE>& lhs,
               const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the address of the object that the specified `lhs`
/// shared pointer refers to is ordered after the address of the object
/// that the specified `rhs` shared pointer refers to under the total
/// ordering supplied by `std::less<T *>`, where `T *` is the composite
/// pointer type of `LHS_TYPE *` and `RHS_TYPE *`, and `false` otherwise.
template<class LHS_TYPE, class RHS_TYPE>
bool operator>(const shared_ptr<LHS_TYPE>& lhs,
               const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the specified `lhs` shared pointer refers to the same
/// object as the specified `rhs` shared pointer, or if the address of the
/// object referred to by `lhs` (if any) is ordered before the address of
/// the object referred to by `rhs` (if any) under the total ordering
/// supplied by `std::less<T *>`, where `T *` is the composite pointer type
// of `LHS_TYPE *` and `RHS_TYPE *`, and `false` otherwise.
template<class LHS_TYPE, class RHS_TYPE>
bool operator<=(const shared_ptr<LHS_TYPE>& lhs,
                const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the specified `lhs` shared pointer refers to the same
/// object as the specified `rhs` shared pointer, or if the address of the
/// object referred to by `lhs` (if any) is ordered after the address of the
/// object referred to by `rhs` (if any) under the total ordering supplied
/// by `std::less<T *>`, where `T *` is the composite pointer type of
/// `LHS_TYPE *` and `RHS_TYPE *`, and `false` otherwise.
template<class LHS_TYPE, class RHS_TYPE>
bool operator>=(const shared_ptr<LHS_TYPE>& lhs,
                const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
#endif  // BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON
 
/// Return `true` if the specified `lhs` shared pointer does not refer to an
/// object, and `false` otherwise.
template <class LHS_TYPE>
bool operator==(const shared_ptr<LHS_TYPE>& lhs,
                nullptr_t) BSLS_KEYWORD_NOEXCEPT;
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON
 
/// Perform a three-way comparison of the specified `ptr` and null pointer
/// by using the comparison operators of `TYPE *`; return the result of that
/// comparison.
template<class TYPE>
strong_ordering operator<=>(const shared_ptr<TYPE>& ptr,
                            nullptr_t) BSLS_KEYWORD_NOEXCEPT;
 
#else
 
/// Return `true` if the specified `rhs` shared pointer does not refer to an
/// object, and `false` otherwise.
template <class RHS_TYPE>
bool operator==(nullptr_t,
                const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the specified `lhs` shared pointer refers to an object,
/// and `false` otherwise.
template <class LHS_TYPE>
bool operator!=(const shared_ptr<LHS_TYPE>& lhs,
                nullptr_t) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the specified `rhs` shared pointer refers to an object,
/// and `false` otherwise.
template <class RHS_TYPE>
bool operator!=(nullptr_t,
                const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the address of the object referred to by the specified
/// `lhs` shared pointer is ordered before the null-pointer value under the
/// total ordering supplied by `std::less<LHS_TYPE *>`, and `false`
/// otherwise.
template <class LHS_TYPE>
bool operator<(const shared_ptr<LHS_TYPE>& lhs, nullptr_t)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the address of the object referred to by the specified
/// `rhs` shared pointer is ordered after the null-pointer value under the
/// total ordering supplied by `std::less<RHS_TYPE *>`, and `false`
/// otherwise.
template <class RHS_TYPE>
bool operator<(nullptr_t, const shared_ptr<RHS_TYPE>& rhs)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the specified `lhs` shared pointer does not refer to an
/// object, or if the address of the object referred to by `lhs` is ordered
/// before the null-pointer value under the total ordering supplied by
/// `std::less<LHS_TYPE *>`, and `false` otherwise.
template <class LHS_TYPE>
bool operator<=(const shared_ptr<LHS_TYPE>& lhs,
                nullptr_t) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the specified `rhs` shared pointer does not refer to an
/// object, or if the address of the object referred to by `rhs` is ordered
/// after the null-pointer value under the total ordering supplied by
/// `std::less<RHS_TYPE *>`, and `false` otherwise.
template <class RHS_TYPE>
bool operator<=(nullptr_t,
                const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the address of the object referred to by the specified
/// `lhs` shared pointer is ordered after the null-pointer value under the
/// total ordering supplied by `std::less<LHS_TYPE *>`, and `false`
/// otherwise.
template <class LHS_TYPE>
bool operator>(const shared_ptr<LHS_TYPE>& lhs, nullptr_t)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the address of the object referred to by the specified
/// `rhs` shared pointer is ordered before the null-pointer value under the
/// total ordering supplied by `std::less<RHS_TYPE *>`, and `false`
/// otherwise.
template <class RHS_TYPE>
bool operator>(nullptr_t, const shared_ptr<RHS_TYPE>& rhs)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the specified `lhs` shared pointer does not refer to an
/// object, or if the address of the object referred to by `lhs` is ordered
/// after the null-pointer value under the total ordering supplied by
/// `std::less<LHS_TYPE *>`, and `false` otherwise.
template <class LHS_TYPE>
bool operator>=(const shared_ptr<LHS_TYPE>& lhs,
                nullptr_t) BSLS_KEYWORD_NOEXCEPT;
 
/// Return `true` if the specified `rhs` shared pointer does not refer to an
/// object, or if the address of the object referred to by `rhs` is ordered
/// before the null-pointer value under the total ordering supplied by
/// `std::less<RHS_TYPE *>`, and `false` otherwise.
template <class RHS_TYPE>
bool operator>=(nullptr_t,
                const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
#endif  // BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON
 
/// Print to the specified `stream` the address of the shared object
/// referred to by the specified `rhs` shared pointer and return a reference
/// to the modifiable `stream`.
template<class CHAR_TYPE, class CHAR_TRAITS, class ELEMENT_TYPE>
std::basic_ostream<CHAR_TYPE, CHAR_TRAITS>&
operator<<(std::basic_ostream<CHAR_TYPE, CHAR_TRAITS>& stream,
           const shared_ptr<ELEMENT_TYPE>&             rhs);
 
// ASPECTS
 
/// Pass the address of the object referred to by the specified `input`
/// shared pointer to the specified `hashAlg` hashing algorithm of (template
/// parameter) type `HASHALG`.
template <class HASHALG, class ELEMENT_TYPE>
void hashAppend(HASHALG& hashAlg, const shared_ptr<ELEMENT_TYPE>& input);
 
/// Efficiently exchange the states of the specified `a` and `b` shared
/// pointers such that each will refer to the object formerly referred to by
/// the other, and each will manage the object formerly managed by the
/// other.
template <class ELEMENT_TYPE>
void swap(shared_ptr<ELEMENT_TYPE>& a, shared_ptr<ELEMENT_TYPE>& b)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
// STANDARD FREE FUNCTIONS
 
/// Return the address of deleter used by the specified `p` shared pointer
/// if the (template parameter) type `DELETER` is the type of the deleter
/// installed in `p`, and a null pointer value otherwise.
template<class DELETER, class ELEMENT_TYPE>
DELETER *get_deleter(const shared_ptr<ELEMENT_TYPE>& p) BSLS_KEYWORD_NOEXCEPT;
 
// STANDARD CAST FUNCTIONS
 
/// Return a `shared_ptr<TO_TYPE>` object sharing ownership of the same
/// object as the specified `source` shared pointer to the (template
/// parameter) `FROM_TYPE`, and referring to
/// `const_cast<TO_TYPE *>(source.get())`.  Note that if `source` cannot be
/// `const`-cast to `TO_TYPE *`, then a compiler diagnostic will be emitted
/// indicating the error.
template<class TO_TYPE, class FROM_TYPE>
shared_ptr<TO_TYPE> const_pointer_cast(const shared_ptr<FROM_TYPE>& source)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
/// Return a `shared_ptr<TO_TYPE>` object sharing ownership of the same
/// object as the specified `source` shared pointer to the (template
/// parameter) `FROM_TYPE`, and referring to
/// `dynamic_cast<TO_TYPE*>(source.get())`.  If `source` cannot be
/// dynamically cast to `TO_TYPE *`, then an empty `shared_ptr<TO_TYPE>`
/// object is returned.
template<class TO_TYPE, class FROM_TYPE>
shared_ptr<TO_TYPE> dynamic_pointer_cast(const shared_ptr<FROM_TYPE>& source)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
/// Return a `shared_ptr<TO_TYPE>` object sharing ownership of the same
/// object as the specified `source` shared pointer to the (template
/// parameter) `FROM_TYPE`, and referring to
/// `static_cast<TO_TYPE *>(source.get())`.  Note that if `source` cannot be
/// statically cast to `TO_TYPE *`, then a compiler diagnostic will be
/// emitted indicating the error.
template<class TO_TYPE, class FROM_TYPE>
shared_ptr<TO_TYPE> static_pointer_cast(const shared_ptr<FROM_TYPE>& source)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
/// Return a `shared_ptr<TO_TYPE>` object sharing ownership of the same
/// object as the specified `source` shared pointer to the (template
/// parameter) `FROM_TYPE`, and referring to
/// `reinterpret_cast<TO_TYPE *>(source.get())`.  Note that if `source`
/// cannot be reinterpret_cast-ed to `TO_TYPE *`, then a compiler diagnostic
/// will be emitted indicating the error.
template<class TO_TYPE, class FROM_TYPE>
shared_ptr<TO_TYPE> reinterpret_pointer_cast(
                    const shared_ptr<FROM_TYPE>& source) BSLS_KEYWORD_NOEXCEPT;
 
 
// STANDARD FACTORY FUNCTIONS
                     // ===========================
                     // allocate_shared(ALLOC, ...)
                     // ===========================
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_sharedptr.h
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT 14
#endif
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#endif
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 0
template<class ELEMENT_TYPE, class ALLOC>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 0
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 1
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 1
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 2
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 2
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 3
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 3
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 4
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 4
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 5
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 5
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 6
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 6
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 7
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 7
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 8
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 8
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 9
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 9
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 10
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 10
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 11
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 11
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 12
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 12
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 13
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12,
                                          class ARGS_13>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 13
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 14
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12,
                                          class ARGS_13,
                                          class ARGS_14>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_B >= 14
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
 
template<class ELEMENT_TYPE, class ALLOC, class... ARGS>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC basicAllocator,
                              BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args);
 
// }}} END GENERATED CODE
#endif
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a bounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` object, and each element in the
/// array is default constructed.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_bounded_array<ARRAY_TYPE>::value &&
                                                     !is_pointer<ALLOC>::value,
                   shared_ptr<ARRAY_TYPE> >::type
allocate_shared(ALLOC basicAllocator);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a bounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` object, and each element in the
/// array is constructed from the specified `value`.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_bounded_array<ARRAY_TYPE>::value &&
                                                     !is_pointer<ALLOC>::value,
                   shared_ptr<ARRAY_TYPE> >::type
allocate_shared(ALLOC                                           basicAllocator,
                const typename remove_extent<ARRAY_TYPE>::type& value);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a unbounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` containing the specified
/// `numElements` number of elements, and each element in the array is
/// default constructed.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_unbounded_array<ARRAY_TYPE>::value &&
                                                     !is_pointer<ALLOC>::value,
                   shared_ptr<ARRAY_TYPE> >::type
allocate_shared(ALLOC basicAllocator, size_t numElements);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a unbounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` containing the specified
/// `numElements` number of elements, and each element in the array is
/// constructed from the specified `value`.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_unbounded_array<ARRAY_TYPE>::value &&
                                                     !is_pointer<ALLOC>::value,
                   shared_ptr<ARRAY_TYPE> >::type
allocate_shared(ALLOC                                           basicAllocator,
                size_t                                          numElements,
                const typename remove_extent<ARRAY_TYPE>::type& value);
 
              // =========================================
              // allocate_shared_for_overwrite(ALLOC, ...)
              // =========================================
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ELEMENT_TYPE` object.  The specified `basicAllocator` will be used to
/// supply a single contiguous region of memory holding the returned shared
/// pointer's internal representation and the new `ELEMENT_TYPE` object,
/// which is default-constructed.
template<class ELEMENT_TYPE, class ALLOC>
typename enable_if<!is_array<ELEMENT_TYPE>::value && !is_pointer<ALLOC>::value,
                   shared_ptr<ELEMENT_TYPE> >::type
allocate_shared_for_overwrite(ALLOC basicAllocator);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a bounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` object, and the array is
/// default-constructed.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_bounded_array<ARRAY_TYPE>::value &&
                                                     !is_pointer<ALLOC>::value,
                   shared_ptr<ARRAY_TYPE> >::type
allocate_shared_for_overwrite(ALLOC basicAllocator);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a unbounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` containing the specified
/// `numElements` number of elements, and the array is default-constructed.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_unbounded_array<ARRAY_TYPE>::value &&
                                                     !is_pointer<ALLOC>::value,
                   shared_ptr<ARRAY_TYPE> >::type
allocate_shared_for_overwrite(ALLOC basicAllocator, size_t numElements);
 
                    // =============================
                    // allocate_shared(ALLOC *, ...)
                    // =============================
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_sharedptr.h
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT 14
#endif
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#endif
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 0
template<class ELEMENT_TYPE, class ALLOC>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 0
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 1
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 1
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 2
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 2
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 3
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 3
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 4
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 4
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 5
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 5
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 6
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 6
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 7
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 7
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 8
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 8
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 9
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 9
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 10
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 10
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 11
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 11
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 12
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 12
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 13
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12,
                                          class ARGS_13>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 13
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 14
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12,
                                          class ARGS_13,
                                          class ARGS_14>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
                           BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_C >= 14
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
 
template<class ELEMENT_TYPE, class ALLOC, class... ARGS>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared(ALLOC *basicAllocator,
                              BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args);
// }}} END GENERATED CODE
#endif
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a bounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` object, and each element in the
/// array is default constructed.  If `basicAllocator` is 0, then the
/// default allocator will be used instead.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_bounded_array<ARRAY_TYPE>::value,
                    shared_ptr<ARRAY_TYPE> >::type
allocate_shared(ALLOC *basicAllocator);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a bounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and  the new `ARRAY_TYPE` object, and each element in the
/// array is constructed from the specified `value`.  If `basicAllocator`
/// is 0, then the default allocator will be used instead.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_bounded_array<ARRAY_TYPE>::value,
                    shared_ptr<ARRAY_TYPE> >::type
allocate_shared(
               ALLOC                                           *basicAllocator,
               const typename remove_extent<ARRAY_TYPE>::type&  value);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a unbounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` containing the specified
/// `numElements` number of elements, and each element in the array is
/// default constructed.  If `basicAllocator` is 0, then the default
/// allocator will be used instead.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_unbounded_array<ARRAY_TYPE>::value,
                    shared_ptr<ARRAY_TYPE> >::type
allocate_shared(ALLOC *basicAllocator, size_t numElements);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a unbounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` containing the specified
/// `numElements` number of elements, and each element in the array is
/// constructed from the specified `value`.  If `basicAllocator` is 0, then
/// the default allocator will be used instead.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_unbounded_array<ARRAY_TYPE>::value,
                    shared_ptr<ARRAY_TYPE> >::type
allocate_shared(
               ALLOC                                           *basicAllocator,
               size_t                                           numElements,
               const typename remove_extent<ARRAY_TYPE>::type&  value);
 
             // ===========================================
             // allocate_shared_for_overwrite(ALLOC *, ...)
             // ===========================================
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ELEMENT_TYPE` object.  The specified `basicAllocator` will be used to
/// supply a single contiguous region of memory holding the returned shared
/// pointer's internal representation and the new `ELEMENT_TYPE` object,
/// which is default-constructed.  If `basicAllocator` is 0, then the
/// default allocator will be used instead.
template<class ELEMENT_TYPE, class ALLOC>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
allocate_shared_for_overwrite(ALLOC *basicAllocator);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a bounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` object, and the array is
/// default-constructed.  If `basicAllocator` is 0, then the default
/// allocator will be used instead.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_bounded_array<ARRAY_TYPE>::value,
                    shared_ptr<ARRAY_TYPE> >::type
allocate_shared_for_overwrite(ALLOC *basicAllocator);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a unbounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` containing the specified
/// `numElements` number of elements, and the array is default-constructed.
///  If `basicAllocator` is 0, then the default allocator will be used
/// instead.
template<class ARRAY_TYPE, class ALLOC>
typename enable_if<is_unbounded_array<ARRAY_TYPE>::value,
                    shared_ptr<ARRAY_TYPE> >::type
allocate_shared_for_overwrite(ALLOC *basicAllocator, size_t numElements);
 
                         // ================
                         // make_shared(...)
                         // ================
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_sharedptr.h
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT 14
#endif
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#endif
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 0
template<class ELEMENT_TYPE>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared();
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 0
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 1
template<class ELEMENT_TYPE, class ARGS_01>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 1
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 2
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 2
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 3
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 3
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 4
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 4
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 5
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 5
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 6
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 6
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 7
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 7
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 8
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 8
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 9
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 9
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 10
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 10
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 11
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10,
                             class ARGS_11>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 11
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 12
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10,
                             class ARGS_11,
                             class ARGS_12>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 12
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 13
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10,
                             class ARGS_11,
                             class ARGS_12,
                             class ARGS_13>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 13
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 14
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10,
                             class ARGS_11,
                             class ARGS_12,
                             class ARGS_13,
                             class ARGS_14>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14);
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_D >= 14
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
 
template<class ELEMENT_TYPE, class... ARGS>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args);
// }}} END GENERATED CODE
#endif
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a bounded array.  The default
/// allocator will be used to supply a single contiguous region of memory
/// holding the returned shared pointer's internal representation and the
/// new `ARRAY_TYPE` object, and each element in the array is default
/// constructed.
template<class ARRAY_TYPE>
typename enable_if<is_bounded_array<ARRAY_TYPE>::value,
                   shared_ptr<ARRAY_TYPE> >::type
make_shared();
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a bounded array.  The default
/// allocator will be used to supply a single contiguous region of memory
/// holding the returned shared pointer's internal representation and the
/// new `ARRAY_TYPE` object, and each element in the array is constructed
/// from the specified `value`.
template<class ARRAY_TYPE>
typename enable_if<is_bounded_array<ARRAY_TYPE>::value,
                   shared_ptr<ARRAY_TYPE> >::type
make_shared(const typename remove_extent<ARRAY_TYPE>::type& value);
 
// unbounded array overloads
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a unbounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` containing the specified
/// `numElements` number of elements, and each element in the array is
/// default constructed.
template<class ARRAY_TYPE>
typename enable_if<is_unbounded_array<ARRAY_TYPE>::value,
                   shared_ptr<ARRAY_TYPE> >::type
make_shared(size_t numElements);
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a unbounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` containing the specified
/// `numElements` number of elements, and each element in the array is
/// constructed from the specified `value`.
template<class ARRAY_TYPE>
typename enable_if<is_unbounded_array<ARRAY_TYPE>::value,
                   shared_ptr<ARRAY_TYPE> >::type
make_shared(size_t                                          numElements,
            const typename remove_extent<ARRAY_TYPE>::type& value);
 
                   // ==============================
                   // make_shared_for_overwrite(...)
                   // ==============================
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ELEMENT_TYPE` object.  The default allocator will be used to supply a
/// single contiguous region of memory holding the returned shared pointer's
/// internal representation and the new `ELEMENT_TYPE` object, which is
/// default-constructed.
template<class ELEMENT_TYPE>
typename enable_if<!is_array<ELEMENT_TYPE>::value,
                    shared_ptr<ELEMENT_TYPE> >::type
make_shared_for_overwrite();
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a bounded array.  The default
/// allocator will be used to supply a single contiguous region of memory
/// holding the returned shared pointer's internal representation and the
/// new `ARRAY_TYPE` object, and the array is default-constructed.
template<class ARRAY_TYPE>
typename enable_if<is_bounded_array<ARRAY_TYPE>::value,
                   shared_ptr<ARRAY_TYPE> >::type
make_shared_for_overwrite();
 
/// Return a `shared_ptr` object referring to and managing a new
/// `ARRAY_TYPE` object, where `ARRAY_TYPE` is a unbounded array.  The
/// specified `basicAllocator` will be used to supply a single contiguous
/// region of memory holding the returned shared pointer's internal
/// representation and the new `ARRAY_TYPE` containing the specified
/// `numElements` number of elements, and the array is default-constructed.
template<class ARRAY_TYPE>
typename enable_if<is_unbounded_array<ARRAY_TYPE>::value,
                   shared_ptr<ARRAY_TYPE> >::type
make_shared_for_overwrite(size_t numElements);
 
                        // ==============
                        // class weak_ptr
                        // ==============
 
/// This `class` provides a mechanism to create weak references to
/// reference-counted shared (`shared_ptr`) objects.  A weak reference
/// provides conditional access to a shared object managed by a
/// `shared_ptr`, but, unlike a shared (or "strong") reference, does not
/// affect the shared object's lifetime.
///
/// See @ref bslstl_sharedptr_cpp03 
template <class ELEMENT_TYPE>
class weak_ptr {
 
    // DATA
    ELEMENT_TYPE                     *d_ptr_p; // pointer to the referenced
                                               // object
 
    BloombergLP::bslma::SharedPtrRep *d_rep_p; // pointer to the representation
                                               // object that manages the
                                               // shared object (held, not
                                               // owned)
 
    // PRIVATE MANIPULATORS
 
    /// Release weak ownership of the currently managed shared pointer rep
    /// and assign to this weak pointer weak ownership of the specified
    /// shared pointer `rep`, aliasing the specified `target` pointer.
    void privateAssign(BloombergLP::bslma::SharedPtrRep *rep,
                       ELEMENT_TYPE                     *target);
 
    // FRIENDS
 
    /// This `friend` declaration provides access to the internal data
    /// members while constructing a weak pointer from a weak pointer of a
    /// different type.
    template <class COMPATIBLE_TYPE>
    friend class weak_ptr;
 
    friend struct BloombergLP::bslstl::SharedPtr_ImpUtil;
 
  public:
    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(weak_ptr<ELEMENT_TYPE>,
                                   bsl::is_nothrow_move_constructible);
 
    // TYPES
 
    /// For weak pointers to non-array types, @ref element_type  is an alias to
    /// the `ELEMENT_TYPE` template parameter.  Otherwise, it is an alias to
    /// the type contained in the array.
    typedef typename bsl::remove_extent<ELEMENT_TYPE>::type element_type;
 
    // CREATORS
 
    /// Create a weak pointer in the empty state and referring to no object,
    /// i.e., a weak pointer having no representation.
    BSLS_KEYWORD_CONSTEXPR
    weak_ptr() BSLS_KEYWORD_NOEXCEPT;
 
    /// Create a weak pointer that refers to the same object (if any) as the
    /// specified `original` weak pointer, and reset `original` to an empty
    /// state.
    weak_ptr(BloombergLP::bslmf::MovableRef<weak_ptr> original)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Create a weak pointer that refers to the same object (if any) as the
    /// specified `other` weak pointer, and reset `original` to an empty
    /// state.  Note that this operation does not involve any change to
    /// reference counts.
#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
    template <class COMPATIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE>
    weak_ptr(weak_ptr<COMPATIBLE_TYPE>&& other) BSLS_KEYWORD_NOEXCEPT;
#else
    template <class COMPATIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE>
    weak_ptr(BloombergLP::bslmf::MovableRef<weak_ptr<COMPATIBLE_TYPE> > other)
                                                         BSLS_KEYWORD_NOEXCEPT;
#endif
 
    /// Create a weak pointer that refers to the same object (if any) as the
    /// specified `original` weak pointer, and increment the number of weak
    /// references to the object managed by `original` (if any).  Note that
    /// if `original` is in the empty state, this weak pointer will be
    /// initialized to the empty state.
    weak_ptr(const weak_ptr& original) BSLS_KEYWORD_NOEXCEPT;
 
    /// Create a weak pointer that refers to the same object (if any) as the
    /// specified `other` (shared or weak) pointer of the (template
    /// parameter) `COMPATIBLE_TYPE`, and increment the number of weak
    /// references to the object managed by `other` (if any).  If
    /// `COMPATIBLE_TYPE *` is not implicitly convertible to
    /// `ELEMENT_TYPE *`, then a compiler diagnostic will be emitted.  Note
    /// that if `other` is in the empty state, this weak pointer will be
    /// initialized to the empty state.
    template <class COMPATIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE>
    weak_ptr(const shared_ptr<COMPATIBLE_TYPE>& other) BSLS_KEYWORD_NOEXCEPT;
                                                                    // IMPLICIT
    template <class COMPATIBLE_TYPE
              BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE>
    weak_ptr(const weak_ptr<COMPATIBLE_TYPE>& other) BSLS_KEYWORD_NOEXCEPT;
                                                                    // IMPLICIT
 
    /// Destroy this weak pointer object.  If this weak pointer manages a
    /// (possibly shared) object, release the weak reference to that object.
    ~weak_ptr();
 
    // MANIPULATORS
 
    /// Make this weak pointer refer to the same object (if any) as the
    /// specified `rhs` weak pointer.  If `rhs` is not a reference to this
    /// weak pointer, decrement the number of weak references to the object
    /// this weak pointer managed (if any), and reset `rhs` to an empty
    /// state.  Return a reference providing modifiable access to this weak
    /// pointer.  Note that if `rhs` is in an empty state, this weak pointer
    /// will be set to an empty state.
    weak_ptr& operator=(BloombergLP::bslmf::MovableRef<weak_ptr> rhs)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Make this weak pointer refer to the same object (if any) as the
    /// specified `rhs` weak pointer.  Decrement the number of weak
    /// references to the object this weak pointer manages (if any), and
    /// increment the number of weak references to the object managed by
    /// `rhs` (if any).  Return a reference providing modifiable access to
    /// this weak pointer.  Note that if `rhs` is in an empty state, this
    /// weak pointer will be set to an empty state.
    weak_ptr& operator=(const weak_ptr& rhs) BSLS_KEYWORD_NOEXCEPT;
 
    /// Make this weak pointer refer to the same object (if any) as the
    /// specified `rhs` weak pointer.  Decrement the number of weak
    /// references to the object this weak pointer managed (if any), and
    /// reset `rhs` to an empty state.  Return a reference providing
    /// modifiable access to this weak pointer.  This function does not
    /// exist unless a pointer to (the template parameter) `COMPATIBLE_TYPE`
    /// is convertible to a pointer to (the template parameter)
    /// `ELEMENT_TYPE`.  Note that if `rhs` is in an empty state, this weak
    /// pointer will be set to an empty state.
#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
    template <class COMPATIBLE_TYPE>
    typename enable_if<
     is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value, weak_ptr&>::type
    operator=(weak_ptr<COMPATIBLE_TYPE>&& rhs) BSLS_KEYWORD_NOEXCEPT;
#else
    template <class COMPATIBLE_TYPE>
    typename enable_if<
     is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value, weak_ptr&>::type
    operator=(BloombergLP::bslmf::MovableRef<weak_ptr<COMPATIBLE_TYPE> > rhs)
                                                         BSLS_KEYWORD_NOEXCEPT;
#endif
 
    template <class COMPATIBLE_TYPE>
    typename enable_if<
     is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value, weak_ptr&>::type
    operator=(const shared_ptr<COMPATIBLE_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
    /// Make this weak pointer refer to the same object (if any) as the
    /// specified `rhs` (shared or weak) pointer to the (template parameter)
    /// `COMPATIBLE_TYPE`.  Decrement the number of weak references to the
    /// object to which this weak pointer currently manages (if any), and
    /// increment the number of weak references to the object managed by
    /// `rhs` (if any).  Return a reference providing modifiable access to
    /// this weak pointer.  If `COMPATIBLE_TYPE *` is not implicitly
    /// convertible to `TYPE *`, then a compiler diagnostic will be emitted.
    /// Note that if `rhs` is in the empty state, this weak pointer will be
    /// set to the empty state.
    template <class COMPATIBLE_TYPE>
    typename enable_if<
     is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value, weak_ptr&>::type
    operator=(const weak_ptr<COMPATIBLE_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT;
 
    /// Reset this weak pointer to the empty state.  If this weak pointer
    /// manages a (possibly shared) object, then decrement the number of
    /// weak references to that object.
    void reset() BSLS_KEYWORD_NOEXCEPT;
 
    /// Efficiently exchange the states of this weak pointer and the
    /// specified `other` weak pointer such that each will refer to the
    /// object (if any) and representation (if any) formerly referred to and
    /// managed by the other.
    void swap(weak_ptr& other) BSLS_KEYWORD_NOEXCEPT;
 
    // ACCESSORS
 
    /// Return `true` if this weak pointer is in the empty state or the
    /// object that it originally referenced has been destroyed, and `false`
    /// otherwise.
    bool expired() const BSLS_KEYWORD_NOEXCEPT;
 
    /// Return a shared pointer to the object referred to by this weak
    /// pointer if `false == expired()`, and a shared pointer in the empty
    /// state otherwise.
    shared_ptr<ELEMENT_TYPE> lock() const BSLS_KEYWORD_NOEXCEPT;
 
    template <class ANY_TYPE>
    bool owner_before(const shared_ptr<ANY_TYPE>& other) const
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Return `true` if the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by this weak pointer
    /// is ordered before the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by the specified
    /// `other` shared pointer under the total ordering defined by
    /// `std::less<BloombergLP::bslma::SharedPtrRep *>`, and `false`
    /// otherwise.
    template <class ANY_TYPE>
    bool owner_before(const weak_ptr<ANY_TYPE>& other) const
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    template<class ANY_TYPE>
    bool owner_equal(const shared_ptr<ANY_TYPE>& other) const
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Return `true` if the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by this shared
    /// pointer is equal to the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by the specified
    /// `other` shared pointer, and `false` otherwise.
    template<class ANY_TYPE>
    bool owner_equal(const weak_ptr<ANY_TYPE>& other) const
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Return an unspecified value such that, for any object `x` where
    /// `owner_equal(x)` is true, `owner_hash() == x.owner_hash()` is true.
    /// Note that this is based on the hash of the address of the
    /// `BloombergLP::bslma::SharedPtrRep` object used by this object.
    /// Note also that for two empty smart pointers `x` and `y`,
    /// `x.owner_hash() == y.owner_hash()` is true.
    size_t owner_hash() const BSLS_KEYWORD_NOEXCEPT;
 
    /// Return the address providing modifiable access to the
    /// `BloombergLP::bslma::SharedPtrRep` object held by this weak pointer,
    /// or 0 if this weak pointer is in the empty state.
    BloombergLP::bslma::SharedPtrRep *rep() const BSLS_KEYWORD_NOEXCEPT;
 
    /// Return a "snapshot" of the current number of shared pointers that
    /// share ownership of the object referred to by this weak pointer, or 0
    /// if this weak pointer is in the empty state.  Note that any result
    /// other than 0 may be unreliable in a multi-threaded program, where
    /// another pointer sharing ownership in a different thread may be
    /// copied or destroyed, or another weak pointer may be locked in the
    /// case that 1 is returned (that would otherwise indicate unique
    /// ownership).
    long use_count() const BSLS_KEYWORD_NOEXCEPT;
 
#ifndef BDE_OMIT_INTERNAL_DEPRECATED
    // DEPRECATED BDE LEGACY ACCESSORS
 
    /// Return a shared pointer to the object referred to by this weak
    /// pointer and managing the same object as that managed by this weak
    /// pointer (if any) if `false == expired()`, and a shared pointer in
    /// the empty state otherwise.  Note that the behavior of this method is
    /// the same as that of `lock`.
    shared_ptr<ELEMENT_TYPE> acquireSharedPtr() const BSLS_KEYWORD_NOEXCEPT;
 
    /// [**DEPRECATED**] Use @ref use_count  instead.
    ///
    /// Return a "snapshot" of the current number of shared pointers that
    /// share ownership of the object referred to by this weak pointer, or 0
    /// if this weak pointer is in the empty state.  Note that the behavior
    /// of this method is the same as that of @ref use_count , and the result
    /// may be unreliable in multi-threaded code for the same reasons.
    int numReferences() const BSLS_KEYWORD_NOEXCEPT;
#endif // BDE_OMIT_INTERNAL_DEPRECATED
};
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_CTAD
// CLASS TEMPLATE DEDUCTION GUIDES
 
/// Deduce the specified type `ELEMENT_TYPE` corresponding template
/// parameter of the `bsl::shared_ptr` supplied to the constructor of
/// `weak_ptr`.
template<class ELEMENT_TYPE>
weak_ptr(shared_ptr<ELEMENT_TYPE>) -> weak_ptr<ELEMENT_TYPE>;
#endif
 
                    //==============================
                    // class enable_shared_from_this
                    //==============================
 
/// This class allows an object that is currently managed by a `shared_ptr`
/// to safely generate a copy of the managing `shared_ptr` object.
/// Inheriting from `enable_shared_from_this<ELEMENT_TYPE>` provides the
/// (template parameter) `ELEMENT_TYPE` type with a member function
/// `shared_from_this`.  If an object of type `ELEMENT_TYPE` is managed by a
/// `shared_ptr` then calling `shared_from_this` will return a
/// `shared_ptr<ELEMENT_TYPE>` that shares ownership of that object.  It is
/// undefined behavior to call `shared_from_this` on an object unless that
/// object is managed by a `shared_ptr`.
///
/// The intended use of `enable_shared_from_this` is that the (template
/// parameter) type `ELEMENT_TYPE` inherits directly from the
/// `enable_shared_from_this` class template.  In the case of multiple
/// inheritance, only one of the base classes should inherit from the
/// `enable_shared_from_this` class template.  If multiple base classes
/// inherit from `enable_shared_from_this`, then there will be ambiguous
/// calls to the `shared_from_this` function.
///
/// See @ref bslstl_sharedptr_cpp03 
template<class ELEMENT_TYPE>
class enable_shared_from_this {
 
    // FRIENDS
 
    /// Allows `shared_ptr` to initialize `d_weakThis` when it detects an
    /// `enable_shared_from_this` base class.
    friend struct BloombergLP::bslstl::SharedPtr_ImpUtil;
 
  private:
    // DATA
    mutable bsl::weak_ptr<ELEMENT_TYPE> d_weakThis;
 
  protected:
    // PROTECTED CREATORS
 
    /// Create an `enable_shared_from_this` object that is not owned by any
    /// `shared_ptr` object.
    enable_shared_from_this() BSLS_KEYWORD_NOEXCEPT;
 
    /// Create an `enable_shared_from_this` object that is not owned by any
    /// `shared_ptr` object.  Note that the specified `unused` argument is
    /// not used by this constructor.
    enable_shared_from_this(const enable_shared_from_this& unused)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Destroy this `enable_shared_form_this`.
    ~enable_shared_from_this();
 
    // PROTECTED MANIPULATORS
 
    /// Return `*this`. This object is unchanged.  Note that the specified
    /// `rhs` is not used.
    enable_shared_from_this& operator=(const enable_shared_from_this& rhs)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
  public:
    // MANIPULATORS
 
    /// Return a `shared_ptr<ELEMENT_TYPE>` that shares ownership with an
    /// existing `shared_ptr` object that managed this object, and throw a
    /// `std::bad_weak_ptr` exception if there is no `shared_ptr` currently
    /// managing this object.  If multiple groups of `shared_ptr`s are
    /// managing this object, the returned `shared_ptr` will share ownership
    /// with the group that first managed this object.
    bsl::shared_ptr<ELEMENT_TYPE> shared_from_this();
 
    /// Return a `weak_ptr` holding a weak reference to this managed object
    /// if this object is currently managed by `shared_ptr`, and return an
    /// expired `weak_ptr` otherwise.  If multiple groups of `shared_ptr`s
    /// are managing this object, the returned `weak_ptr` will hold a weak
    /// reference to the group that first managed this object.
    bsl::weak_ptr<ELEMENT_TYPE> weak_from_this() BSLS_KEYWORD_NOEXCEPT;
 
    // ACCESSORS
 
    /// Return a `shared_ptr<const ELEMENT_TYPE>` that shares ownership with
    /// an existing `shared_ptr` object that managed this object, and throw
    /// a `std::bad_weak_ptr` exception if there is no `shared_ptr`
    /// currently managing this object.  If multiple groups of `shared_ptr`s
    /// are managing this object, the returned `shared_ptr` will share
    /// ownership with the group that first managed this object.
    bsl::shared_ptr<const ELEMENT_TYPE> shared_from_this() const;
 
 
    /// Return a `weak_ptr` holding a weak reference (with only `const`
    /// access) to this managed object if this object is currently managed
    /// by `shared_ptr`, and return an expired `weak_ptr` otherwise.  If
    /// multiple groups of `shared_ptr`s are managing this object, the
    /// returned `weak_ptr` will hold a weak reference to the group that
    /// first managed this object.
    bsl::weak_ptr<const ELEMENT_TYPE> weak_from_this() const
                                                         BSLS_KEYWORD_NOEXCEPT;
};
 
// ASPECTS
 
/// Efficiently exchange the states of the specified `a` and `b` weak
/// pointers such that each will refer to the object (if any) and
/// representation formerly referred to by the other.
template <class ELEMENT_TYPE>
void swap(weak_ptr<ELEMENT_TYPE>& a, weak_ptr<ELEMENT_TYPE>& b)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
                        // =========================
                        // class hash specialization
                        // =========================
 
// A partial specialization of 'bsl::hash' is no longer necessary, as the
// primary template has the correct behavior once 'hashAppend' is defined.
 
}  // close namespace bsl
 
 
namespace bslstl {
 
                            // ====================
                            // struct SharedPtrUtil
                            // ====================
 
/// This `struct` provides a namespace for operations on shared pointers.
struct SharedPtrUtil {
 
    // CLASS METHODS
 
    /// Return a shared pointer with an in-place representation holding a
    /// newly-created uninitialized buffer of the specified `bufferSize` (in
    /// bytes).  Optionally specify a `basicAllocator` used to supply
    /// memory.  If `basicAllocator` is 0, the currently installed default
    /// allocator is used.  The behavior is undefined unless
    /// `0 < bufferSize`.
    static
    bsl::shared_ptr<char>
    createInplaceUninitializedBuffer(size_t            bufferSize,
                                     bslma::Allocator *basicAllocator = 0);
 
    // CASTING FUNCTIONS
 
    /// Load into the specified `target` an aliased shared pointer sharing
    /// ownership of the object managed by the specified `source` shared
    /// pointer and referring to `const_cast<TARGET *>(source.get())`.  If
    /// `*target` is already managing a (possibly shared) object, then
    /// release the shared reference to that object, and destroy it using
    /// its associated deleter if that shared pointer held the last shared
    /// reference to that object.  Note that a compiler diagnostic will be
    /// emitted indicating an error unless
    /// `const_cast<TARGET *>(source.get())` is a valid expression.
    template <class TARGET, class SOURCE>
    static
    void constCast(bsl::shared_ptr<TARGET>        *target,
                   const bsl::shared_ptr<SOURCE>&  source);
 
    /// Return a `bsl::shared_ptr<TARGET>` object sharing ownership of the
    /// same object as the specified `source` shared pointer to the
    /// (template parameter) `SOURCE` type, and referring to
    /// `const_cast<TARGET *>(source.get())`.  Note that a compiler
    /// diagnostic will be emitted indicating an error unless
    /// `const_cast<TARGET *>(source.get())` is a valid expression.
    template <class TARGET, class SOURCE>
    static
    bsl::shared_ptr<TARGET> constCast(const bsl::shared_ptr<SOURCE>& source)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Load into the specified `target` an aliased shared pointer sharing
    /// ownership of the object managed by the specified `source` shared
    /// pointer and referring to `dynamic_cast<TARGET *>(source.get())`.  If
    /// `*target` is already managing a (possibly shared) object, then
    /// release the shared reference to that object, and destroy it using
    /// its associated deleter if that shared pointer held the last shared
    /// reference to that object.  If
    /// `0 == dynamic_cast<TARGET*>(source.get())`, then `*target` shall be
    /// reset to an empty state that does not refer to an object.  Note that
    /// a compiler diagnostic will be emitted indicating an error unless
    /// `dynamic_cast<TARGET *>(source.get())` is a valid expression.
    template <class TARGET, class SOURCE>
    static
    void dynamicCast(bsl::shared_ptr<TARGET>        *target,
                     const bsl::shared_ptr<SOURCE>&  source);
 
    /// Return a `bsl::shared_ptr<TARGET>` object sharing ownership of the
    /// same object as the specified `source` shared pointer to the
    /// (template parameter) `SOURCE` type, and referring to
    /// `dynamic_cast<TARGET *>(source.get())`.  If that would return a
    /// shared pointer referring to nothing (`0 == get()`), then instead
    /// return an (empty) default constructed shared pointer.  Note that a
    /// compiler diagnostic will be emitted indicating an error unless
    /// `dynamic_cast<TARGET *>(source.get())` is a valid expression..
    template <class TARGET, class SOURCE>
    static
    bsl::shared_ptr<TARGET> dynamicCast(const bsl::shared_ptr<SOURCE>& source)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Load into the specified `target` an aliased shared pointer sharing
    /// ownership of the object managed by the specified `source` shared
    /// pointer and referring to `static_cast<TARGET *>(source.get())`.  If
    /// `*target` is already managing a (possibly shared) object, then
    /// release the shared reference to that object, and destroy it using
    /// its associated deleter if that shared pointer held the last shared
    /// reference to that object.  Note that a compiler diagnostic will be
    /// emitted indicating an error unless
    /// `static_cast<TARGET *>(source.get())` is a valid expression.
    template <class TARGET, class SOURCE>
    static
    void staticCast(bsl::shared_ptr<TARGET>        *target,
                    const bsl::shared_ptr<SOURCE>&  source);
 
    /// Return a `bsl::shared_ptr<TARGET>` object sharing ownership of the
    /// same object as the specified `source` shared pointer to the
    /// (template parameter) `SOURCE` type, and referring to
    /// `static_cast<TARGET *>(source.get())`.  Note that a compiler
    /// diagnostic will be emitted indicating an error unless
    /// `static_cast<TARGET *>(source.get())` is a valid expression.
    template <class TARGET, class SOURCE>
    static
    bsl::shared_ptr<TARGET> staticCast(const bsl::shared_ptr<SOURCE>& source)
                                                         BSLS_KEYWORD_NOEXCEPT;
};
 
                        // ==========================
                        // struct SharedPtrNilDeleter
                        // ==========================
 
/// This `struct` provides a function-like shared pointer deleter that does
/// nothing when invoked.
struct SharedPtrNilDeleter {
 
    // ACCESSORS
 
    /// No-Op.
    void operator()(const volatile void *) const BSLS_KEYWORD_NOEXCEPT;
};
 
                        // ===============================
                        // struct SharedPtr_DefaultDeleter
                        // ===============================
 
/// This `struct` provides a function-like shared pointer deleter that
/// invokes `delete` with the passed pointer.  If the template parameter is
/// `true`, then the pointer is deleted using `operator delete []`.
/// Otherwise, it is deleted using `operator delete`.
template <bool>
struct SharedPtr_DefaultDeleter {
 
    // ACCESSORS
 
    /// Call `delete` with the specified `ptr`.
    template <class ANY_TYPE>
    void operator()(ANY_TYPE *ptr) const BSLS_KEYWORD_NOEXCEPT;
};
 
                        //=========================
                        // struct SharedPtr_ImpUtil
                        //=========================
 
/// This `struct` should be used by only `shared_ptr` constructors. Its
/// purpose is to enable `shared_ptr` constructors to determine if the
/// (template parameter) types `COMPATIBLE_TYPE` or `ELEMENT_TYPE` have a
/// specialization of `enable_shared_from_this` as an unambiguous, publicly
/// accessible, base class.
struct SharedPtr_ImpUtil {
 
    // PUBLIC TYPES
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP11_BASELINE_LIBRARY
    template <class TYPE, unsigned DIM = 0>
    struct Extent : std::extent<TYPE, DIM> {};
#else
    template <class TYPE, unsigned DIM = 0>
    struct Extent : public bsl::integral_constant<size_t, 0> {};
 
    template <class TYPE>
    struct Extent<TYPE[], 0> : public bsl::integral_constant<size_t, 0> {};
 
    template <class TYPE, unsigned DIM>
    struct Extent<TYPE[], DIM>
        : public bsl::integral_constant<size_t, Extent<TYPE, DIM-1>::value> {};
 
    template <class TYPE, size_t SIZE>
    struct Extent<TYPE[SIZE], 0>
                              : public bsl::integral_constant<size_t, SIZE> {};
 
    template <class TYPE, size_t SIZE, unsigned DIM>
    struct Extent<TYPE[SIZE], DIM>
        : public bsl::integral_constant<size_t, Extent<TYPE, DIM-1>::value> {};
#endif
 
    // CLASS METHODS
 
    /// Load the specified `result` with the control block (i.e.,
    /// `SharedPtrRep`) from the specified `sharedPtr` if (and only if)
    /// `result` is not 0 and `result` does not already refer to a
    /// non-expired shared-pointer control block.  If `result` is 0, or if
    /// `result->d_weakThis` has not expired, this operation has no effect.
    /// This operation is used to initialize data members from a type that
    /// inherits from `enable_shared_from_this` when constructing an
    /// out-of-place shared pointer representation.  This function shall be
    /// called only by `shared_ptr` constructors creating shared pointers
    /// for classes that derive publicly and unambiguously from a
    /// specialization of `enabled_shared_from_this`.  Note that overload
    /// resolution will select the overload below if a supplied type does
    /// not derive from a specialization of `enable_shared_from_this`.
    template<class SHARED_TYPE, class ENABLE_TYPE>
    static void loadEnableSharedFromThis(
                   const bsl::enable_shared_from_this<ENABLE_TYPE> *result,
                   bsl::shared_ptr<SHARED_TYPE>                    *sharedPtr);
 
    /// Do nothing.  This overload is selected, rather than the immediately
    /// preceding template, when the `SHARED_TYPE` template type parameter
    /// of `shared_ptr<SHARED_TYPE>` does not derive from a specialization
    /// of `enable_shared_from_this`.
    static void loadEnableSharedFromThis(const volatile void *, const void *)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Throw a `bsl::bad_weak_ptr` exception.
    static void throwBadWeakPtr();
 
    /// Return the specified `address` cast as a pointer to `void`, even if
    /// (the template parameter) `TYPE` is cv-qualified.
    template <class TYPE>
    static void *voidify(TYPE *address) BSLS_KEYWORD_NOEXCEPT;
 
    /// Return the specified `address` of a potentially `cv`-qualified
    /// object of the given (template parameter) `TYPE`, cast as a pointer
    /// to a modifiable non-volatile object of the given `TYPE`.
    template <class TYPE>
    static TYPE *unqualify(const volatile TYPE *address) BSLS_KEYWORD_NOEXCEPT;
};
 
                        // ==========================
                        // class SharedPtr_RepProctor
                        // ==========================
 
/// This `class` implements a proctor that, unless its `release` method has
/// previously been invoked, automatically releases a reference held by the
/// `bslma::SharedPtrRep` object that is supplied at construction.
///
/// See @ref bslstl_sharedptr_cpp03 
class SharedPtr_RepProctor {
 
  private:
    // DATA
    bslma::SharedPtrRep *d_rep_p;    // Address of representation being managed
 
  private:
    // NOT IMPLEMENTED
    SharedPtr_RepProctor(const SharedPtr_RepProctor&);
    SharedPtr_RepProctor& operator=(const SharedPtr_RepProctor&);
 
  public:
    // CREATORS
 
    /// Create a `SharedPtr_RepProctor` that conditionally manages the
    /// specified `rep` (if non-zero).
    explicit SharedPtr_RepProctor(bslma::SharedPtrRep *rep)
                                                         BSLS_KEYWORD_NOEXCEPT;
 
    /// Destroy this `SharedPtr_RepProctor`, and dispose of (deallocate) the
    /// `bslma::SharedPtrRep` it manages (if any).  If no such object is
    /// currently being managed, this method has no effect.  Note that the
    /// destructor of the `bslma::SharedPtrRep` will not be called as the
    /// reference count will not be decremented.
    ~SharedPtr_RepProctor();
 
    // MANIPULATORS
 
    /// Release from management the object currently managed by this
    /// proctor.  If no object is currently being managed, this method has
    /// no effect.
    void release() BSLS_KEYWORD_NOEXCEPT;
};
 
}  // close package namespace
 
 
// ============================================================================
//                           INLINE DEFINITIONS
// ============================================================================
 
#if defined(BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS)
 
namespace bslstl {
 
#if defined(BSLS_COMPILERFEATURES_SUPPORT_DECLTYPE) &&                        \
    defined(BSLS_PLATFORM_CMP_MSVC) &&                                        \
    BSLS_PLATFORM_CMP_VERSION >= 1936 && BSLS_PLATFORM_CMP_VERSION <= 1937
// Microsoft needs a workaround to correctly handle calling 'sizeof' on an
// unevaluated expression.  This compiler bug was introduced in Visual Studio
// 2022 version 17.6 (cl 19.36, released May 2022).  The report to Microsoft is
// https://developercommunity.visualstudio.com/t/C-templates:-new-compiler-error-in-MSV/10381900
 
# define BSLSTL_SHAREDPTR_MSVC_DECLTYPE_WORKAROUND(...) decltype(__VA_ARGS__)
#else
# define BSLSTL_SHAREDPTR_MSVC_DECLTYPE_WORKAROUND(...) (__VA_ARGS__)
#endif
 
template <class FUNCTOR>
struct SharedPtr_TestIsCallable {
  private:
    // PRIVATE TYPES
    typedef BloombergLP::bslmf::Util Util;
 
    struct TrueType {
        char d_padding;
    };
    struct FalseType {
        char d_padding[17];
    };
 
    // The two structs 'TrueType' and 'FalseType' are guaranteed to have
    // distinct sizes, so that a 'sizeof(expression)' query, where 'expression'
    // returns one of these two types, will give different answers depending on
    // which type is returned.
 
  public:
    // CLASS METHODS
 
    /// This function is never defined.  It provides a property-checker that
    /// an entity of (template parameter) type `FACTORY` can be called like
    /// a function with a single argument, which is a pointer to an object
    /// of (template parameter) type `ARG`.  The `sizeof()` expression
    /// provides an unevaluated context to check the validity of the
    /// enclosed expression, and the `, 0` ensures that the `sizeof` check
    /// remains valid, even if the expression returns `void`.  Similarly,
    /// the cast to `void` ensures that there are no surprises with types
    /// that overload the comma operator.  Note that the cast to `void` is
    /// elided for Clang compilers using versions of LLVM prior to
    /// 12, which fail to evaluate the trait properly.  Note that
    /// `sizeof(decltype())` is required for MSVC due to a compiler bug in
    /// MSVC 17.6 and later (at least including 17.7.0 Preview 2.0).
    template <class ARG>
    static FalseType test(...);
    template <class ARG>
    static TrueType
    test(typename bsl::enable_if<
             static_cast<bool>(
                 sizeof(BSLSTL_SHAREDPTR_MSVC_DECLTYPE_WORKAROUND(
                     BSLSTL_SHAREDPTR_SFINAE_DISCARD(
                               Util::declval<FUNCTOR>()(Util::declval<ARG>())),
                     0)))>::type *);
};
 
#if defined(BSLS_PLATFORM_CMP_MSVC) && BSLS_PLATFORM_CMP_VERSION < 1920
// Microsoft needs a workaround to correctly handle calling through function
// pointers with incompatible types in Visual Studio 2017.  In Visual Studio
// 2019 the workaround isn't needed and crashes the compiler if enabled!
// (Visual Studio versions prior to 2017 appear to not need the workaround,
// based on further testing, but it's being left in place so as not to alter
// this code for people using older compiler versions.)
 
template <class RESULT, class PARAM>
struct SharedPtr_TestIsCallable<RESULT(PARAM)> {
  private:
    // PRIVATE TYPES
    typedef BloombergLP::bslmf::Util Util;
 
    struct TrueType  { char d_padding; };
    struct FalseType { char d_padding[17]; };
 
    // PRIVATE CLASS METHODS
    static RESULT callMe(PARAM);
 
  public:
    // CLASS METHODS
 
    // This function is never defined.  It provides a property-checker that
    // an entity of (template parameter) type `FACTORY` can be called like
    // a function with a single argument, which is a pointer to an object
    // of (template parameter) type `ARG`.  The `sizeof` expression
    // provides an unevaluated context to check the validity of the
    // enclosed expression, and the `, 0` ensures that the `sizeof` check
    // remains valid, even if the expression returns `void`.  Similarly,
    // the cast to `void` ensures that there are no surprises with types
    // that overload the comma operator.
    template <class ARG>
    static FalseType test(...);
    template <class ARG>
    static TrueType test(typename bsl::enable_if<(bool)sizeof(
                                        ((void)callMe(Util::declval<ARG>())), 0
                                                       )>::type *);
};
 
template <class RESULT, class PARAM>
struct SharedPtr_TestIsCallable<RESULT(*)(PARAM)>
    :  SharedPtr_TestIsCallable<RESULT(PARAM)> {
};
 
template <class RESULT, class PARAM>
struct SharedPtr_TestIsCallable<RESULT(&)(PARAM)>
    :  SharedPtr_TestIsCallable<RESULT(PARAM)> {
};
 
#if BSLS_PLATFORM_CMP_VERSION >= 1910
// MSVC 2017 expression-SFINAE has a regression that is failing in two
// additional cases:
//  1) for pointers to object types
//  2) where '0' is used for a null pointer literal, deducing as 'int'.
// We resolve those issues with a couple more specializations below.
 
template <class TYPE>
struct SharedPtr_TestIsCallable<TYPE *> {
    struct TrueType  { char d_padding; };
    struct FalseType { char d_padding[17]; };
 
    template <class ARG>
    static FalseType test(...);
};
 
template <>
struct SharedPtr_TestIsCallable<int> {
    struct TrueType  { char d_padding; };
    struct FalseType { char d_padding[17]; };
 
    template <class ARG>
    static FalseType test(...);
};
#endif  // MSVC 2017
 
#endif  // BSLS_PLATFORM_CMP_MSVC
 
template <class FUNCTOR, class ARG>
struct SharedPtr_IsCallable {
    enum { k_VALUE =
          sizeof(SharedPtr_TestIsCallable<FUNCTOR>::template test<ARG>(0)) == 1
    };
};
 
 
struct SharedPtr_IsFactoryFor_Impl {
  private:
    // PRIVATE TYPES
    struct TrueType {
        char d_padding;
    };
    struct FalseType {
        char d_padding[17];
    };
 
  public:
    // CLASS METHODS
 
    /// This function is never defined.  It provides a property-checker that
    /// an object of (template parameter) type `FACTORY` has a
    /// member-function called `deleteObject` that can be called with a
    /// single argument, which is a pointer to an object of (template
    /// parameter) type `ARG`.  The `sizeof` expression provides an
    /// unevaluated context to check the validity of the enclosed
    /// expression, and the `, 0` ensures that the `sizeof` check remains
    /// valid, even if the expression returns `void`.  Similarly, the cast
    /// to `void` ensures that there are no surprises with types that
    /// overload the comma operator.  Note that the cast to `void` is elided
    /// for Clang compilers using versions of LLVM prior to 12, which fail
    /// to evaluate the trait properly.
    template <class FACTORY, class ARG>
    static FalseType test(...);
    template <class FACTORY, class ARG>
    static TrueType test(typename bsl::enable_if<static_cast<bool>(sizeof(
                                  BSLSTL_SHAREDPTR_SFINAE_DISCARD(
                                      (*(FACTORY *)0)->deleteObject((ARG *)0)),
                                  0))>::type *);
};
 
template <class FACTORY, class ARG>
struct SharedPtr_IsFactoryFor {
    enum { k_VALUE =
                sizeof(SharedPtr_IsFactoryFor_Impl::test<FACTORY, ARG>(0)) == 1
    };
};
 
 
struct SharedPtr_IsNullableFactory_Impl {
  private:
    // PRIVATE TYPES
    struct TrueType {
        char d_padding;
    };
    struct FalseType {
        char d_padding[17];
    };
 
  public:
    // CLASS METHODS
 
    /// This function is never defined.  It provides a property-checker that
    /// an object of (template parameter) type `FACTORY` has a
    /// member-function called `deleteObject` that can be called with a
    /// single argument, which is a pointer to an object of (template
    /// parameter) type `ARG`.  The `sizeof` expression provides an
    /// unevaluated context to check the validity of the enclosed
    /// expression, and the `, 0` ensures that the `sizeof` check remains
    /// valid, even if the expression returns `void`.  Similarly, the cast
    /// to `void` ensures that there are no surprises with types that
    /// overload the comma operator.  Note that the cast to `void` is elided
    /// for Clang compilers using versions of LLVM prior to 12, which fail
    /// to evaluate the trait properly.
    template <class FACTORY>
    static FalseType test(...);
    template <class FACTORY>
    static TrueType test(typename bsl::enable_if<static_cast<bool>(sizeof(
                                   BSLSTL_SHAREDPTR_SFINAE_DISCARD(
                                       (*(FACTORY *)0)->deleteObject(nullptr)),
                                   0))>::type *);
};
 
template <class FACTORY>
struct SharedPtr_IsNullableFactory {
    enum { k_VALUE =
                sizeof(SharedPtr_IsNullableFactory_Impl::test<FACTORY>(0)) == 1
    };
};
 
 
template <class SOURCE_TYPE, class DEST_TYPE>
struct SharedPtr_IsPointerConvertible_Impl
: bsl::is_convertible<SOURCE_TYPE *, DEST_TYPE *>::type {};
 
template <class SOURCE_TYPE, class DEST_TYPE>
struct SharedPtr_IsPointerConvertible_Impl<SOURCE_TYPE, DEST_TYPE[]>
: bsl::is_convertible<SOURCE_TYPE (*)[], DEST_TYPE (*)[]>::type {};
 
template <class SOURCE_TYPE, class DEST_TYPE, size_t DEST_SIZE>
struct SharedPtr_IsPointerConvertible_Impl<SOURCE_TYPE, DEST_TYPE[DEST_SIZE]>
: bsl::is_convertible<SOURCE_TYPE (*)[DEST_SIZE],
                      DEST_TYPE (*)[DEST_SIZE]>::type {};
 
 
template <class SOURCE_TYPE, class DEST_TYPE>
struct SharedPtr_IsPointerConvertible
: SharedPtr_IsPointerConvertible_Impl<SOURCE_TYPE, DEST_TYPE>::type {};
 
 
template <class SOURCE_TYPE, class DEST_TYPE>
struct SharedPtr_IsPointerCompatible_Impl
    : bsl::is_convertible<SOURCE_TYPE *, DEST_TYPE *>::type {};
 
template <class TYPE, size_t SIZE>
struct SharedPtr_IsPointerCompatible_Impl<TYPE[SIZE], TYPE[]>
     : bsl::true_type {};
 
template <class TYPE, size_t SIZE>
struct SharedPtr_IsPointerCompatible_Impl<TYPE[SIZE], const TYPE[]>
     : bsl::true_type {};
 
template <class TYPE, size_t SIZE>
struct SharedPtr_IsPointerCompatible_Impl<TYPE[SIZE], volatile TYPE[]>
     : bsl::true_type {};
 
template <class TYPE, size_t SIZE>
struct SharedPtr_IsPointerCompatible_Impl<TYPE[SIZE], const volatile TYPE[]>
     : bsl::true_type {};
 
 
template <class SOURCE_TYPE, class DEST_TYPE>
struct SharedPtr_IsPointerCompatible
: SharedPtr_IsPointerCompatible_Impl<SOURCE_TYPE, DEST_TYPE>::type {};
 
}  // close package namespace
 
#endif  // BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS
 
 
namespace bsl {
                    //------------------------------
                    // class enable_shared_from_this
                    //------------------------------
// CREATORS
template<class ELEMENT_TYPE>
inline // constexpr
enable_shared_from_this<ELEMENT_TYPE>::enable_shared_from_this()
                                                          BSLS_KEYWORD_NOEXCEPT
: d_weakThis()
{
}
 
template<class ELEMENT_TYPE>
inline
enable_shared_from_this<ELEMENT_TYPE>::enable_shared_from_this(
                                                const enable_shared_from_this&)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_weakThis()
{
}
 
template<class ELEMENT_TYPE>
inline
enable_shared_from_this<ELEMENT_TYPE>::~enable_shared_from_this()
{
}
 
// MANIPULATORS
template<class ELEMENT_TYPE>
inline
enable_shared_from_this<ELEMENT_TYPE>&
enable_shared_from_this<ELEMENT_TYPE>::operator=(
                                                const enable_shared_from_this&)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return *this;
}
 
template<class ELEMENT_TYPE>
inline
shared_ptr<ELEMENT_TYPE>
enable_shared_from_this<ELEMENT_TYPE>::shared_from_this()
{
    return shared_ptr<ELEMENT_TYPE>(d_weakThis);
}
 
template<class ELEMENT_TYPE>
inline
shared_ptr<const ELEMENT_TYPE>
enable_shared_from_this<ELEMENT_TYPE>::shared_from_this() const
{
    return shared_ptr<const ELEMENT_TYPE>(d_weakThis);
}
 
template<class ELEMENT_TYPE>
inline
weak_ptr<ELEMENT_TYPE>
enable_shared_from_this<ELEMENT_TYPE>::weak_from_this() BSLS_KEYWORD_NOEXCEPT
{
    return d_weakThis;
}
 
template<class ELEMENT_TYPE>
inline
weak_ptr<const ELEMENT_TYPE>
enable_shared_from_this<ELEMENT_TYPE>::weak_from_this() const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return d_weakThis;
}
 
                            // ----------------
                            // class shared_ptr
                            // ----------------
 
// PRIVATE CLASS METHODS
template <class ELEMENT_TYPE>
template <class INPLACE_REP>
inline
BloombergLP::bslma::SharedPtrRep *
shared_ptr<ELEMENT_TYPE>::makeInternalRep(
                                         ELEMENT_TYPE                     *,
                                         INPLACE_REP                      *,
                                         BloombergLP::bslma::SharedPtrRep *rep)
{
    return rep;
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE, class ALLOCATOR>
inline
BloombergLP::bslma::SharedPtrRep *
shared_ptr<ELEMENT_TYPE>::makeInternalRep(
                                      COMPATIBLE_TYPE               *ptr,
                                      ALLOCATOR                     *,
                                      BloombergLP::bslma::Allocator *allocator)
{
    typedef BloombergLP::bslma::SharedPtrOutofplaceRep<
                                               COMPATIBLE_TYPE,
                                               BloombergLP::bslma::Allocator *>
                                                                      RepMaker;
 
    return RepMaker::makeOutofplaceRep(ptr, allocator, allocator);
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE, class DELETER>
inline
BloombergLP::bslma::SharedPtrRep *
shared_ptr<ELEMENT_TYPE>::makeInternalRep(COMPATIBLE_TYPE *ptr,
                                          DELETER         *deleter,
                                          ...)
{
    typedef BloombergLP::bslma::SharedPtrOutofplaceRep<COMPATIBLE_TYPE,
                                                       DELETER *>     RepMaker;
 
    return RepMaker::makeOutofplaceRep(ptr, deleter, 0);
}
 
// CREATORS
template <class ELEMENT_TYPE>
inline
BSLS_KEYWORD_CONSTEXPR
shared_ptr<ELEMENT_TYPE>::shared_ptr() BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(0)
, d_rep_p(0)
{
}
 
template <class ELEMENT_TYPE>
inline
BSLS_KEYWORD_CONSTEXPR
shared_ptr<ELEMENT_TYPE>::shared_ptr(bsl::nullptr_t) BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(0)
, d_rep_p(0)
{
}
 
template <class ELEMENT_TYPE>
template <class CONVERTIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(CONVERTIBLE_TYPE *ptr)
: d_ptr_p(ptr)
{
    typedef BloombergLP::bslstl::SharedPtr_DefaultDeleter<
                                   bsl::is_array<ELEMENT_TYPE>::value> Deleter;
    typedef BloombergLP::bslma::SharedPtrOutofplaceRep<CONVERTIBLE_TYPE,
                                                       Deleter>       RepMaker;
 
    d_rep_p = RepMaker::makeOutofplaceRep(ptr, Deleter(), 0);
    if (!bsl::is_array<ELEMENT_TYPE>::value) {
        BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(ptr,
                                                                         this);
    }
}
 
template <class ELEMENT_TYPE>
template <class CONVERTIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(
                                 CONVERTIBLE_TYPE              *ptr,
                                 BloombergLP::bslma::Allocator *basicAllocator)
: d_ptr_p(ptr)
{
    typedef BloombergLP::bslma::SharedPtrOutofplaceRep<
                                               CONVERTIBLE_TYPE,
                                               BloombergLP::bslma::Allocator *>
                                                                      RepMaker;
 
    d_rep_p = RepMaker::makeOutofplaceRep(ptr, basicAllocator, basicAllocator);
    if (!bsl::is_array<ELEMENT_TYPE>::value) {
        BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(ptr,
                                                                         this);
    }
}
 
template <class ELEMENT_TYPE>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(
                          typename shared_ptr<ELEMENT_TYPE>::element_type *ptr,
                          BloombergLP::bslma::SharedPtrRep                *rep)
: d_ptr_p(ptr)
, d_rep_p(rep)
{
    BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(ptr,
                                                                     this);
}
 
template <class ELEMENT_TYPE>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(
                       ELEMENT_TYPE                     *ptr,
                       BloombergLP::bslma::SharedPtrRep *rep,
                       BloombergLP::bslstl::SharedPtr_RepFromExistingSharedPtr)
: d_ptr_p(ptr)
, d_rep_p(rep)
{
}
 
template <class ELEMENT_TYPE>
template <class CONVERTIBLE_TYPE,
          class DISPATCH
          BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE
          BSLSTL_SHAREDPTR_DEFINE_IF_DELETER(DISPATCH *, CONVERTIBLE_TYPE)>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(CONVERTIBLE_TYPE *ptr,
                                     DISPATCH         *dispatch)
: d_ptr_p(ptr)
, d_rep_p(makeInternalRep(ptr, dispatch, dispatch))
{
    if (!bsl::is_array<ELEMENT_TYPE>::value) {
        BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(ptr,
                                                                         this);
    }
}
 
template <class ELEMENT_TYPE>
template <class CONVERTIBLE_TYPE,
          class DELETER
          BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE
          BSLSTL_SHAREDPTR_DEFINE_IF_DELETER(DELETER, CONVERTIBLE_TYPE)>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(
                                 CONVERTIBLE_TYPE              *ptr,
                                 DELETER                        deleter,
                                 BloombergLP::bslma::Allocator *basicAllocator)
: d_ptr_p(ptr)
{
    typedef BloombergLP::bslma::SharedPtrOutofplaceRep<CONVERTIBLE_TYPE,
                                                       DELETER> RepMaker;
 
    d_rep_p = RepMaker::makeOutofplaceRep(ptr, deleter, basicAllocator);
    if (!bsl::is_array<ELEMENT_TYPE>::value) {
        BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(ptr,
                                                                         this);
    }
}
 
template <class ELEMENT_TYPE>
template <class CONVERTIBLE_TYPE,
          class DELETER,
          class ALLOCATOR
          BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE
          BSLSTL_SHAREDPTR_DEFINE_IF_DELETER(DELETER, CONVERTIBLE_TYPE)>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(CONVERTIBLE_TYPE *ptr,
                                     DELETER           deleter,
                                     ALLOCATOR         basicAllocator,
                                     typename ALLOCATOR::value_type *)
: d_ptr_p(ptr)
{
#ifdef BSLS_PLATFORM_CMP_MSVC
    // This is not quite C++11 'decay' as we do not need to worry about array
    // types, and do not want to remove reference or cv-qualification from
    // DELETER otherwise.  This works around a Microsoft bug turning function
    // pointers into function references.
 
    typedef typename bsl::conditional<bsl::is_function<DELETER>::value,
                                      typename bsl::add_pointer<DELETER>::type,
                                      DELETER>::type DeleterType;
#else
    typedef DELETER DeleterType;
#endif
 
    typedef
    BloombergLP::bslstl::SharedPtrAllocateOutofplaceRep<CONVERTIBLE_TYPE,
                                                        DeleterType,
                                                        ALLOCATOR> RepMaker;
 
    d_rep_p = RepMaker::makeOutofplaceRep(ptr, deleter, basicAllocator);
    if (!bsl::is_array<ELEMENT_TYPE>::value) {
        BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(ptr,
                                                                         this);
    }
}
 
template <class ELEMENT_TYPE>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(nullptr_t,
                                     BloombergLP::bslma::Allocator *)
: d_ptr_p(0)
, d_rep_p(0)
{
}
 
template <class ELEMENT_TYPE>
template <class DELETER
          BSLSTL_SHAREDPTR_DEFINE_IF_NULLPTR_DELETER(DELETER)>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(
                                 nullptr_t,
                                 DELETER                        deleter,
                                 BloombergLP::bslma::Allocator *basicAllocator)
: d_ptr_p(0)
{
    typedef BloombergLP::bslma::SharedPtrOutofplaceRep<ELEMENT_TYPE,
                                                       DELETER> RepMaker;
 
    if (bsl::is_convertible<DELETER, BloombergLP::bslma::Allocator *>::value &&
        bsl::is_pointer<DELETER>::value) {
        d_rep_p = 0;
    }
    else {
        d_rep_p = RepMaker::makeOutofplaceRep((ELEMENT_TYPE *)0,
                                              deleter,
                                              basicAllocator);
    }
}
 
template <class ELEMENT_TYPE>
template <class DELETER, class ALLOCATOR
          BSLSTL_SHAREDPTR_DEFINE_IF_NULLPTR_DELETER(DELETER)>
inline
shared_ptr<ELEMENT_TYPE>::shared_ptr(
                                nullptr_t,
                                DELETER                         deleter,
                                ALLOCATOR                       basicAllocator,
                                typename ALLOCATOR::value_type *)
: d_ptr_p(0)
{
#ifdef BSLS_PLATFORM_CMP_MSVC
    // This is not quite C++11 'decay' as we do not need to worry about array
    // types, and do not want to remove reference or cv-qualification from
    // DELETER otherwise.  This works around a Microsoft bug turning function
    // pointers into function references.
 
    typedef typename bsl::conditional<bsl::is_function<DELETER>::value,
                                      typename bsl::add_pointer<DELETER>::type,
                                      DELETER>::type DeleterType;
#else
    typedef DELETER DeleterType;
#endif
 
    typedef
    BloombergLP::bslstl::SharedPtrAllocateOutofplaceRep<ELEMENT_TYPE,
                                                        DeleterType,
                                                        ALLOCATOR> RepMaker;
 
    d_rep_p = RepMaker::makeOutofplaceRep((ELEMENT_TYPE *)0,
                                          deleter,
                                          basicAllocator);
}
 
template <class ELEMENT_TYPE>
template <class CONVERTIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE>
shared_ptr<ELEMENT_TYPE>::shared_ptr(
              BloombergLP::bslma::ManagedPtr<CONVERTIBLE_TYPE>  managedPtr,
              BloombergLP::bslma::Allocator                    *basicAllocator)
: d_ptr_p(managedPtr.ptr())
, d_rep_p(0)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<
                            BloombergLP::bslma::ManagedPtr<ELEMENT_TYPE> > Rep;
 
    if (d_ptr_p) {
        ELEMENT_TYPE *pPotentiallyShared = static_cast<ELEMENT_TYPE *>(
                                                managedPtr.deleter().object());
 
        if (&BloombergLP::bslma::SharedPtrRep::managedPtrDeleter ==
                                              managedPtr.deleter().deleter()) {
            d_rep_p = static_cast<BloombergLP::bslma::SharedPtrRep *>
                                       (managedPtr.release().second.factory());
        }
        else if (&BloombergLP::bslma::SharedPtrRep::managedPtrEmptyDeleter ==
                                              managedPtr.deleter().deleter()) {
            d_rep_p = 0;
            managedPtr.release();
        }
        else {
            basicAllocator =
                        BloombergLP::bslma::Default::allocator(basicAllocator);
            Rep *rep = new (*basicAllocator) Rep(basicAllocator);
            (*rep->ptr()) = managedPtr;
            d_rep_p = rep;
        }
 
        BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(
                                                            pPotentiallyShared,
                                                            this);
    }
}
 
#if defined(BSLS_LIBRARYFEATURES_HAS_CPP98_AUTO_PTR)
template <class ELEMENT_TYPE>
template <class CONVERTIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE>
shared_ptr<ELEMENT_TYPE>::shared_ptr(
                              std::auto_ptr<CONVERTIBLE_TYPE>&  autoPtr,
                              BloombergLP::bslma::Allocator    *basicAllocator)
: d_ptr_p(autoPtr.get())
, d_rep_p(0)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<
                                         std::auto_ptr<CONVERTIBLE_TYPE> > Rep;
 
    if (d_ptr_p) {
        basicAllocator =
                        BloombergLP::bslma::Default::allocator(basicAllocator);
        Rep *rep = new (*basicAllocator) Rep(basicAllocator);
        (*rep->ptr()) = autoPtr;
        d_rep_p = rep;
        BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(
                                                                       d_ptr_p,
                                                                       this);
    }
}
 
template <class ELEMENT_TYPE>
shared_ptr<ELEMENT_TYPE>::shared_ptr(
                               std::auto_ptr_ref<ELEMENT_TYPE>  autoRef,
                               BloombergLP::bslma::Allocator   *basicAllocator)
: d_ptr_p(0)
, d_rep_p(0)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<
                                             std::auto_ptr<ELEMENT_TYPE> > Rep;
 
    std::auto_ptr<ELEMENT_TYPE> autoPtr(autoRef);
    if (autoPtr.get()) {
        basicAllocator =
                        BloombergLP::bslma::Default::allocator(basicAllocator);
        Rep *rep = new (*basicAllocator) Rep(basicAllocator);
        d_ptr_p = autoPtr.get();
        (*rep->ptr()) = autoPtr;
        d_rep_p = rep;
    }
}
#endif
 
#if defined(BSLS_LIBRARYFEATURES_HAS_CPP11_UNIQUE_PTR)
# if defined(BSLSTL_SHAREDPTR_SUPPORTS_SFINAE_CHECKS)
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE,
          class UNIQUE_DELETER,
          typename enable_if<is_convertible<
                      typename std::unique_ptr<COMPATIBLE_TYPE,
                                               UNIQUE_DELETER>::pointer,
                      ELEMENT_TYPE *>::value>::type *>
shared_ptr<ELEMENT_TYPE>::shared_ptr(
            std::unique_ptr<COMPATIBLE_TYPE, UNIQUE_DELETER>&&  adoptee,
            BloombergLP::bslma::Allocator                      *basicAllocator)
: d_ptr_p(adoptee.get())
, d_rep_p(0)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<
                        std::unique_ptr<COMPATIBLE_TYPE, UNIQUE_DELETER> > Rep;
 
    if (d_ptr_p) {
        basicAllocator =
                        BloombergLP::bslma::Default::allocator(basicAllocator);
        Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                            BloombergLP::bslmf::MovableRefUtil::move(adoptee));
        d_rep_p = rep;
        BloombergLP::bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(
                                                                       d_ptr_p,
                                                                       this);
    }
}
# endif
#endif
 
template <class ELEMENT_TYPE>
template <class ANY_TYPE>
shared_ptr<ELEMENT_TYPE>::shared_ptr(const shared_ptr<ANY_TYPE>&  source,
                                     ELEMENT_TYPE                *object)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(object)
, d_rep_p(source.d_rep_p)
{
    if (d_rep_p) {
        d_rep_p->acquireRef();
    }
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE>
shared_ptr<ELEMENT_TYPE>::
shared_ptr(const shared_ptr<COMPATIBLE_TYPE>& other) BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(other.d_ptr_p)
, d_rep_p(other.d_rep_p)
{
    if (d_rep_p) {
        d_rep_p->acquireRef();
    }
}
 
template <class ELEMENT_TYPE>
shared_ptr<ELEMENT_TYPE>::shared_ptr(const shared_ptr& original)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(original.d_ptr_p)
, d_rep_p(original.d_rep_p)
{
    if (d_rep_p) {
        d_rep_p->acquireRef();
    }
}
 
template <class ELEMENT_TYPE>
shared_ptr<ELEMENT_TYPE>::shared_ptr
                          (BloombergLP::bslmf::MovableRef<shared_ptr> original)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(BloombergLP::bslmf::MovableRefUtil::access(original).d_ptr_p)
, d_rep_p(BloombergLP::bslmf::MovableRefUtil::access(original).d_rep_p)
{
    BloombergLP::bslmf::MovableRefUtil::access(original).d_ptr_p = 0;
    BloombergLP::bslmf::MovableRefUtil::access(original).d_rep_p = 0;
}
 
#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE>
shared_ptr<ELEMENT_TYPE>::shared_ptr(shared_ptr<COMPATIBLE_TYPE>&& other)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(other.d_ptr_p)
, d_rep_p(other.d_rep_p)
{
    other.d_ptr_p = 0;
    other.d_rep_p = 0;
}
#else
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE>
shared_ptr<ELEMENT_TYPE>::
shared_ptr(BloombergLP::bslmf::MovableRef<shared_ptr<COMPATIBLE_TYPE> > other)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(BloombergLP::bslmf::MovableRefUtil::access(other).d_ptr_p)
, d_rep_p(BloombergLP::bslmf::MovableRefUtil::access(other).d_rep_p)
{
    BloombergLP::bslmf::MovableRefUtil::access(other).d_ptr_p = 0;
    BloombergLP::bslmf::MovableRefUtil::access(other).d_rep_p = 0;
}
#endif
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE>
shared_ptr<ELEMENT_TYPE>::shared_ptr(const weak_ptr<COMPATIBLE_TYPE>& other)
: d_ptr_p(0)
, d_rep_p(0)
{
    // This implementation handles two awkward cases:
    //
    // i) a ref-counted null pointer, means we cannot simply test 'if (!value)'
    // ii) a null pointer aliasing a non-null pointer is still expired, and so
    //     should throw.
 
    SelfType value = other.lock();
    if (other.expired()) {
        // Test after lock to avoid a race between testing 'expired' and
        // claiming the lock.
 
        BloombergLP::bslstl::SharedPtr_ImpUtil::throwBadWeakPtr();
    }
 
    swap(value);
}
 
#if !defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE>
shared_ptr<ELEMENT_TYPE>::shared_ptr(
                BloombergLP::bslmf::MovableRef<weak_ptr<COMPATIBLE_TYPE> > ptr)
: d_ptr_p(0)
, d_rep_p(0)
{
    // This implementation handles two awkward cases:
    //
    // i) a ref-counted null pointer, means we cannot simply test 'if (!value)'
    // ii) a null pointer aliasing a non-null pointer is still expired, and so
    //     should throw.
 
    weak_ptr<COMPATIBLE_TYPE>& other = ptr;
 
    SelfType value = other.lock();
    if (other.expired()) {
        // Test after lock to avoid a race between testing 'expired' and
        // claiming the lock.
 
        BloombergLP::bslstl::SharedPtr_ImpUtil::throwBadWeakPtr();
    }
 
    swap(value);
}
#endif
 
template <class ELEMENT_TYPE>
shared_ptr<ELEMENT_TYPE>::~shared_ptr()
{
    if (d_rep_p) {
        d_rep_p->releaseRef();
    }
}
 
// MANIPULATORS
template <class ELEMENT_TYPE>
shared_ptr<ELEMENT_TYPE>&
shared_ptr<ELEMENT_TYPE>::operator=(const shared_ptr& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    // Instead of testing '&rhs == this', which happens infrequently, optimize
    // for when reps are the same.
 
    if (rhs.d_rep_p == d_rep_p) {
        d_ptr_p = rhs.d_ptr_p;
    }
    else {
        SelfType(rhs).swap(*this);
    }
 
    return *this;
}
 
template <class ELEMENT_TYPE>
shared_ptr<ELEMENT_TYPE>&
shared_ptr<ELEMENT_TYPE>::operator=(
                                BloombergLP::bslmf::MovableRef<shared_ptr> rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    // No self-assignment to optimize, postcondition demands 'rhs' is left
    // empty, unless it is the exact same object, not just the same 'rep'.
 
    shared_ptr(BloombergLP::bslmf::MovableRefUtil::move(rhs)).swap(*this);
 
    return *this;
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
typename enable_if<
    is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
    shared_ptr<ELEMENT_TYPE>&>::type
shared_ptr<ELEMENT_TYPE>::operator=(const shared_ptr<COMPATIBLE_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    // Instead of testing '&rhs == this', which happens infrequently, optimize
    // for when reps are the same.
 
    if (rhs.d_rep_p == d_rep_p) {
        d_ptr_p = rhs.d_ptr_p;
    }
    else {
        SelfType(rhs).swap(*this);
    }
 
    return *this;
}
 
#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
typename enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
                   shared_ptr<ELEMENT_TYPE>&>::type
shared_ptr<ELEMENT_TYPE>::operator=(shared_ptr<COMPATIBLE_TYPE>&& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
#else
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
typename enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
                   shared_ptr<ELEMENT_TYPE>&>::type
shared_ptr<ELEMENT_TYPE>::operator=(
              BloombergLP::bslmf::MovableRef<shared_ptr<COMPATIBLE_TYPE> > rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
#endif
{
    // No self-assignment to optimize, postcondition demands 'rhs' is left
    // empty, unless it is the exact same object, not just the same 'rep'.
 
    shared_ptr(BloombergLP::bslmf::MovableRefUtil::move(rhs)).swap(*this);
 
    return *this;
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
inline
typename enable_if<
    is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
    shared_ptr<ELEMENT_TYPE>&>::type
shared_ptr<ELEMENT_TYPE>::operator=(
                           BloombergLP::bslma::ManagedPtr<COMPATIBLE_TYPE> rhs)
{
    SelfType(rhs).swap(*this);
    return *this;
}
 
#if defined(BSLS_LIBRARYFEATURES_HAS_CPP98_AUTO_PTR)
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
inline
typename enable_if<
    is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
    shared_ptr<ELEMENT_TYPE>&>::type
shared_ptr<ELEMENT_TYPE>::operator=(std::auto_ptr<COMPATIBLE_TYPE> rhs)
{
    SelfType(rhs).swap(*this);
    return *this;
}
#endif
 
#if defined(BSLS_LIBRARYFEATURES_HAS_CPP11_UNIQUE_PTR)
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE, class UNIQUE_DELETER>
inline
typename enable_if<
    is_convertible<
        typename std::unique_ptr<COMPATIBLE_TYPE, UNIQUE_DELETER>::pointer,
        ELEMENT_TYPE *>::value,
    shared_ptr<ELEMENT_TYPE>&>::type
shared_ptr<ELEMENT_TYPE>::operator=(
                        std::unique_ptr<COMPATIBLE_TYPE, UNIQUE_DELETER>&& rhs)
{
    SelfType(BloombergLP::bslmf::MovableRefUtil::move(rhs)).swap(*this);
    return *this;
}
#endif
 
template <class ELEMENT_TYPE>
inline
void shared_ptr<ELEMENT_TYPE>::reset() BSLS_KEYWORD_NOEXCEPT
{
    BloombergLP::bslma::SharedPtrRep *rep = d_rep_p;
 
    // Clear 'd_rep_p' first so that a self-referencing shared pointer's
    // destructor does not try to call 'releaseRef' again.
 
    d_rep_p = 0;
    d_ptr_p = 0;
 
    if (rep) {
        rep->releaseRef();
    }
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
inline
typename
      enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value>::type
shared_ptr<ELEMENT_TYPE>::reset(COMPATIBLE_TYPE *ptr)
{
    SelfType(ptr).swap(*this);
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE, class DELETER>
inline
typename
      enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value>::type
shared_ptr<ELEMENT_TYPE>::reset(COMPATIBLE_TYPE *ptr,
                                DELETER          deleter)
{
    SelfType(ptr, deleter).swap(*this);
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE, class DELETER, class ALLOCATOR>
inline
typename
      enable_if<is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value>::type
shared_ptr<ELEMENT_TYPE>::reset(COMPATIBLE_TYPE *ptr,
                                DELETER          deleter,
                                ALLOCATOR        basicAllocator)
{
    SelfType(ptr, deleter, basicAllocator).swap(*this);
}
 
template <class ELEMENT_TYPE>
template <class ANY_TYPE>
inline
void shared_ptr<ELEMENT_TYPE>::reset(const shared_ptr<ANY_TYPE>&  source,
                                     ELEMENT_TYPE                *ptr)
{
    // Optimize for the (expected) common case where aliases are managing the
    // same data structure.
 
    if (source.d_rep_p == d_rep_p && ptr) {
        d_ptr_p = ptr;
    }
    else {
        SelfType(source, ptr).swap(*this);
    }
}
 
template <class ELEMENT_TYPE>
inline
void shared_ptr<ELEMENT_TYPE>::swap(shared_ptr& other) BSLS_KEYWORD_NOEXCEPT
{
    // We directly implement swapping of two pointers, rather than simply
    // calling 'bsl::swap' or using 'bslalg::SwapUtil', to avoid (indirectly)
    // including the platform <algorithm> header, which may transitively
    // include other standard headers.  This reduces the risk of
    // platform-specific cycles, which have been observed to cause problems.
 
    // Also, as 'shared_ptr' is bitwise-moveable, we could simplify this to
    // 'memcpy'-ing through an (aligned?) array of sufficient 'char'.
 
    element_type *tempPtr_p = d_ptr_p;
    d_ptr_p       = other.d_ptr_p;
    other.d_ptr_p = tempPtr_p;
 
    BloombergLP::bslma::SharedPtrRep *tempRep_p = d_rep_p;
    d_rep_p       = other.d_rep_p;
    other.d_rep_p = tempRep_p;
}
 
// ADDITIONAL BSL MANIPULATORS
template<class ELEMENT_TYPE>
void
shared_ptr<ELEMENT_TYPE>::createInplace()
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    BloombergLP::bslma::Allocator *basicAllocator =
                                      BloombergLP::bslma::Default::allocator();
 
    Rep *rep = new (*basicAllocator) Rep(basicAllocator);
    SelfType(rep->ptr(), rep).swap(*this);
}
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_sharedptr.h
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT 14
#endif
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#endif
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 0
template <class    ELEMENT_TYPE>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator);
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 0
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 1
template <class    ELEMENT_TYPE>
template <class ARGS_01>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 1
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 2
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 2
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 3
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 3
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 4
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 4
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 5
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 5
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 6
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05,
          class ARGS_06>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 6
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 7
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05,
          class ARGS_06,
          class ARGS_07>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 7
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 8
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05,
          class ARGS_06,
          class ARGS_07,
          class ARGS_08>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 8
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 9
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05,
          class ARGS_06,
          class ARGS_07,
          class ARGS_08,
          class ARGS_09>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 9
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 10
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05,
          class ARGS_06,
          class ARGS_07,
          class ARGS_08,
          class ARGS_09,
          class ARGS_10>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 10
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 11
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05,
          class ARGS_06,
          class ARGS_07,
          class ARGS_08,
          class ARGS_09,
          class ARGS_10,
          class ARGS_11>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 11
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 12
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05,
          class ARGS_06,
          class ARGS_07,
          class ARGS_08,
          class ARGS_09,
          class ARGS_10,
          class ARGS_11,
          class ARGS_12>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_12,args_12));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 12
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 13
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05,
          class ARGS_06,
          class ARGS_07,
          class ARGS_08,
          class ARGS_09,
          class ARGS_10,
          class ARGS_11,
          class ARGS_12,
          class ARGS_13>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_12,args_12),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_13,args_13));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 13
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 14
template <class    ELEMENT_TYPE>
template <class ARGS_01,
          class ARGS_02,
          class ARGS_03,
          class ARGS_04,
          class ARGS_05,
          class ARGS_06,
          class ARGS_07,
          class ARGS_08,
          class ARGS_09,
          class ARGS_10,
          class ARGS_11,
          class ARGS_12,
          class ARGS_13,
          class ARGS_14>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_12,args_12),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_13,args_13),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_14,args_14));
    SelfType(rep->ptr(), rep).swap(*this);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_E >= 14
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class    ELEMENT_TYPE>
template <class... ARGS>
void
shared_ptr<ELEMENT_TYPE>::createInplace(
                                 BloombergLP::bslma::Allocator *basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args)
{
    typedef BloombergLP::bslma::SharedPtrInplaceRep<ELEMENT_TYPE> Rep;
 
    basicAllocator = BloombergLP::bslma::Default::allocator(basicAllocator);
    Rep *rep = new (*basicAllocator) Rep(basicAllocator,
                                  BSLS_COMPILERFEATURES_FORWARD(ARGS,args)...);
    SelfType(rep->ptr(), rep).swap(*this);
}
// }}} END GENERATED CODE
#endif
 
template <class ELEMENT_TYPE>
template <class ANY_TYPE>
void
shared_ptr<ELEMENT_TYPE>::loadAlias(const shared_ptr<ANY_TYPE>&  source,
                                    ELEMENT_TYPE                *object)
{
    if (source.d_rep_p == d_rep_p && object) {
        d_ptr_p = object;
    }
    else {
        SelfType(source, object).swap(*this);
    }
}
 
template <class ELEMENT_TYPE>
pair<typename shared_ptr<ELEMENT_TYPE>::element_type *, BloombergLP::bslma::SharedPtrRep *>
shared_ptr<ELEMENT_TYPE>::release() BSLS_KEYWORD_NOEXCEPT
{
    pair<element_type *, BloombergLP::bslma::SharedPtrRep *> ret(d_ptr_p,
                                                                 d_rep_p);
    d_ptr_p = 0;
    d_rep_p = 0;
    return ret;
}
 
#ifndef BDE_OMIT_INTERNAL_DEPRECATED
// DEPRECATED BDE LEGACY MANIPULATORS
template <class ELEMENT_TYPE>
inline
void shared_ptr<ELEMENT_TYPE>::clear() BSLS_KEYWORD_NOEXCEPT
{
    reset();
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
inline
void shared_ptr<ELEMENT_TYPE>::load(COMPATIBLE_TYPE *ptr)
{
    SelfType(ptr).swap(*this);
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
inline
void
shared_ptr<ELEMENT_TYPE>::load(COMPATIBLE_TYPE               *ptr,
                               BloombergLP::bslma::Allocator *basicAllocator)
{
    SelfType(ptr, basicAllocator).swap(*this);
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE, class DELETER>
inline
void
shared_ptr<ELEMENT_TYPE>::load(COMPATIBLE_TYPE               *ptr,
                               const DELETER&                 deleter,
                               BloombergLP::bslma::Allocator *basicAllocator)
{
    SelfType(ptr, deleter, basicAllocator).swap(*this);
}
#endif // BDE_OMIT_INTERNAL_DEPRECATED
 
// ACCESSORS
template <class ELEMENT_TYPE>
inline
#if defined(BSLS_PLATFORM_CMP_IBM)     // Last tested with xlC 12.1
shared_ptr<ELEMENT_TYPE>::operator typename shared_ptr::BoolType() const
                                                          BSLS_KEYWORD_NOEXCEPT
#else
shared_ptr<ELEMENT_TYPE>::operator BoolType() const BSLS_KEYWORD_NOEXCEPT
#endif
{
    return BloombergLP::bsls::UnspecifiedBool<shared_ptr>::makeValue(d_ptr_p);
}
 
template <class ELEMENT_TYPE>
inline
typename add_lvalue_reference<ELEMENT_TYPE>::type
shared_ptr<ELEMENT_TYPE>::operator*() const BSLS_KEYWORD_NOEXCEPT
{
    BSLS_ASSERT_SAFE(d_ptr_p);
 
    return *d_ptr_p;
}
 
template <class ELEMENT_TYPE>
inline
ELEMENT_TYPE *shared_ptr<ELEMENT_TYPE>::operator->() const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return d_ptr_p;
}
 
template <class ELEMENT_TYPE>
inline
typename shared_ptr<ELEMENT_TYPE>::element_type *
shared_ptr<ELEMENT_TYPE>::get() const BSLS_KEYWORD_NOEXCEPT
{
    return d_ptr_p;
}
 
template <class ELEMENT_TYPE>
inline typename
add_lvalue_reference<typename shared_ptr<ELEMENT_TYPE>::element_type>::type
shared_ptr<ELEMENT_TYPE>::operator[](ptrdiff_t index) const
{
    BSLS_ASSERT_SAFE(d_ptr_p);
 
    return *(d_ptr_p + index);
}
 
template <class ELEMENT_TYPE>
template<class ANY_TYPE>
inline
bool shared_ptr<ELEMENT_TYPE>::owner_before(const shared_ptr<ANY_TYPE>& other)
                                                    const BSLS_KEYWORD_NOEXCEPT
{
    return std::less<BloombergLP::bslma::SharedPtrRep *>()(rep(), other.rep());
}
 
template <class ELEMENT_TYPE>
template<class ANY_TYPE>
inline
bool
shared_ptr<ELEMENT_TYPE>::owner_before(const weak_ptr<ANY_TYPE>& other) const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return std::less<BloombergLP::bslma::SharedPtrRep *>()(rep(), other.rep());
}
 
template <class ELEMENT_TYPE>
template<class ANY_TYPE>
inline
bool shared_ptr<ELEMENT_TYPE>::owner_equal(const shared_ptr<ANY_TYPE>& other)
                                                    const BSLS_KEYWORD_NOEXCEPT
{
    return rep() == other.rep();
}
 
template <class ELEMENT_TYPE>
template<class ANY_TYPE>
inline
bool
shared_ptr<ELEMENT_TYPE>::owner_equal(const weak_ptr<ANY_TYPE>& other) const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return rep() == other.rep();
}
 
template <class ELEMENT_TYPE>
inline
size_t
shared_ptr<ELEMENT_TYPE>::owner_hash() const BSLS_KEYWORD_NOEXCEPT
{
    return hash<BloombergLP::bslma::SharedPtrRep *>()(rep());
}
 
template <class ELEMENT_TYPE>
inline
bool shared_ptr<ELEMENT_TYPE>::unique() const BSLS_KEYWORD_NOEXCEPT
{
    return 1 == use_count();
}
 
template <class ELEMENT_TYPE>
inline
long shared_ptr<ELEMENT_TYPE>::use_count() const BSLS_KEYWORD_NOEXCEPT
{
    return d_rep_p ? d_rep_p->numReferences() : 0;
}
 
// ADDITIONAL BSL ACCESSORS
template <class ELEMENT_TYPE>
BloombergLP::bslma::ManagedPtr<ELEMENT_TYPE>
shared_ptr<ELEMENT_TYPE>::managedPtr() const
{
    if (d_rep_p && d_ptr_p) {
        d_rep_p->acquireRef();
        return BloombergLP::bslma::ManagedPtr<ELEMENT_TYPE>(d_ptr_p,
                                                            d_rep_p,
                         &BloombergLP::bslma::SharedPtrRep::managedPtrDeleter);
                                                                      // RETURN
    }
 
    return BloombergLP::bslma::ManagedPtr<ELEMENT_TYPE>(
                     d_ptr_p,
                    (BloombergLP::bslma::SharedPtrRep *)0,
                    &BloombergLP::bslma::SharedPtrRep::managedPtrEmptyDeleter);
}
 
template <class ELEMENT_TYPE>
inline
BloombergLP::bslma::SharedPtrRep *shared_ptr<ELEMENT_TYPE>::rep() const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return d_rep_p;
}
 
#ifndef BDE_OMIT_INTERNAL_DEPRECATED
// DEPRECATED BDE LEGACY ACCESSORS
template <class ELEMENT_TYPE>
inline
int shared_ptr<ELEMENT_TYPE>::numReferences() const BSLS_KEYWORD_NOEXCEPT
{
    return d_rep_p ? d_rep_p->numReferences() : 0;
}
 
template <class ELEMENT_TYPE>
inline
typename shared_ptr<ELEMENT_TYPE>::element_type *
shared_ptr<ELEMENT_TYPE>::ptr() const BSLS_KEYWORD_NOEXCEPT
{
    return d_ptr_p;
}
#endif // BDE_OMIT_INTERNAL_DEPRECATED
 
                        // --------------
                        // class weak_ptr
                        // --------------
 
// CREATORS
template <class ELEMENT_TYPE>
inline
BSLS_KEYWORD_CONSTEXPR
weak_ptr<ELEMENT_TYPE>::weak_ptr() BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(0)
, d_rep_p(0)
{
}
 
template <class ELEMENT_TYPE>
weak_ptr<ELEMENT_TYPE>::weak_ptr(
         BloombergLP::bslmf::MovableRef<weak_ptr> original)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(BloombergLP::bslmf::MovableRefUtil::access(original).d_ptr_p)
, d_rep_p(BloombergLP::bslmf::MovableRefUtil::access(original).d_rep_p)
{
    BloombergLP::bslmf::MovableRefUtil::access(original).d_rep_p = 0;
//    original.d_ptr_p = 0; // this seems overkill for a /weak/ pointer
}
 
#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE>
weak_ptr<ELEMENT_TYPE>::weak_ptr(weak_ptr<COMPATIBLE_TYPE>&& original)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(original.d_ptr_p)
, d_rep_p(original.d_rep_p)
{
    original.d_rep_p = 0;
//    original.d_ptr_p = 0; // this seems overkill for a /weak/ pointer
}
#else
template <class ELEMENT_TYPE>
template <class CONVERTIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE>
weak_ptr<ELEMENT_TYPE>::weak_ptr(
          BloombergLP::bslmf::MovableRef<weak_ptr<CONVERTIBLE_TYPE> > original)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(original.d_ptr_p)
, d_rep_p(original.d_rep_p)
{
    original.d_rep_p = 0;
//    original.d_ptr_p = 0; // this seems overkill for a /weak/ pointer
}
#endif
 
template <class ELEMENT_TYPE>
weak_ptr<ELEMENT_TYPE>::weak_ptr(const weak_ptr<ELEMENT_TYPE>& original)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(original.d_ptr_p)
, d_rep_p(original.d_rep_p)
{
    if (d_rep_p) {
        d_rep_p->acquireWeakRef();
    }
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE>
weak_ptr<ELEMENT_TYPE>::weak_ptr(const shared_ptr<COMPATIBLE_TYPE>& other)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(other.get())
, d_rep_p(other.rep())
{
    if (d_rep_p) {
        d_rep_p->acquireWeakRef();
    }
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE
          BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE>
weak_ptr<ELEMENT_TYPE>::weak_ptr(const weak_ptr<COMPATIBLE_TYPE>& other)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_ptr_p(other.d_ptr_p)
, d_rep_p(other.d_rep_p)
{
    if (d_rep_p) {
        d_rep_p->acquireWeakRef();
    }
}
 
template <class ELEMENT_TYPE>
inline
weak_ptr<ELEMENT_TYPE>::~weak_ptr()
{
    if (d_rep_p) {
        d_rep_p->releaseWeakRef();
    }
}
 
// PRIVATE MANIPULATORS
template <class ELEMENT_TYPE>
inline
void weak_ptr<ELEMENT_TYPE>::privateAssign(
                                      BloombergLP::bslma::SharedPtrRep *rep,
                                      ELEMENT_TYPE                     *target)
{
    if (d_rep_p) {
        d_rep_p->releaseWeakRef();
    }
 
    d_ptr_p = target;
    d_rep_p = rep;
    d_rep_p->acquireWeakRef();
}
 
// MANIPULATORS
template <class ELEMENT_TYPE>
weak_ptr<ELEMENT_TYPE>& weak_ptr<ELEMENT_TYPE>::operator=(
                                  BloombergLP::bslmf::MovableRef<weak_ptr> rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    weak_ptr tmp(BloombergLP::bslmf::MovableRefUtil::move(rhs));
    tmp.swap(*this);
    return *this;
}
 
#if defined(BSLMF_MOVABLEREF_USES_RVALUE_REFERENCES)
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
typename enable_if<
    is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
    weak_ptr<ELEMENT_TYPE>&>::type
weak_ptr<ELEMENT_TYPE>::operator=(weak_ptr<COMPATIBLE_TYPE>&& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    weak_ptr tmp(BloombergLP::bslmf::MovableRefUtil::move(rhs));
    tmp.swap(*this);
    return *this;
}
#else
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
typename enable_if<
    is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
    weak_ptr<ELEMENT_TYPE>&>::type
weak_ptr<ELEMENT_TYPE>::operator=(
                BloombergLP::bslmf::MovableRef<weak_ptr<COMPATIBLE_TYPE> > rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    weak_ptr tmp(BloombergLP::bslmf::MovableRefUtil::move(rhs));
    tmp.swap(*this);
    return *this;
}
#endif
 
template <class ELEMENT_TYPE>
weak_ptr<ELEMENT_TYPE>& weak_ptr<ELEMENT_TYPE>::operator=(
                                             const weak_ptr<ELEMENT_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
#if 1
    weak_ptr tmp(rhs);
    tmp.swap(*this);
#else
    // needs friendship, or use the cheating util class.
    privateAssign(rhs.d_rep_p, rhs.d_ptr_p);
#endif
    return *this;
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
typename enable_if<
    is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
    weak_ptr<ELEMENT_TYPE>&>::type
weak_ptr<ELEMENT_TYPE>::operator=(const shared_ptr<COMPATIBLE_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
#if 1
    weak_ptr tmp(rhs);
    tmp.swap(*this);
#else
    // needs friendship, or use the cheating util class.
    privateAssign(rhs.d_rep_p, rhs.d_ptr_p);
#endif
    return *this;
}
 
template <class ELEMENT_TYPE>
template <class COMPATIBLE_TYPE>
typename enable_if<
    is_convertible<COMPATIBLE_TYPE *, ELEMENT_TYPE *>::value,
    weak_ptr<ELEMENT_TYPE>&>::type
weak_ptr<ELEMENT_TYPE>::operator=(const weak_ptr<COMPATIBLE_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
#if 1
    weak_ptr tmp(rhs);
    tmp.swap(*this);
#else
    // needs friendship, or use the cheating util class.
    privateAssign(rhs.d_rep_p, rhs.d_ptr_p);
#endif
    return *this;
}
 
template <class ELEMENT_TYPE>
inline
void weak_ptr<ELEMENT_TYPE>::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_rep_p) {
        d_rep_p->releaseWeakRef();
    }
 
    d_ptr_p = 0;
    d_rep_p = 0;
}
 
template <class ELEMENT_TYPE>
inline
void weak_ptr<ELEMENT_TYPE>::swap(weak_ptr<ELEMENT_TYPE>& other)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    // We directly implement swapping of two pointers, rather than simply
    // calling 'bsl::swap' or using 'bslalg::SwapUtil', to avoid (indirectly)
    // including the platform <algorithm> header, which may transitively
    // include other standard headers.  This reduces the risk of
    // platform-specific cycles, which have been observed to cause problems.
 
    ELEMENT_TYPE *tempPtr_p = d_ptr_p;
    d_ptr_p       = other.d_ptr_p;
    other.d_ptr_p = tempPtr_p;
 
    BloombergLP::bslma::SharedPtrRep *tempRep_p = d_rep_p;
    d_rep_p       = other.d_rep_p;
    other.d_rep_p = tempRep_p;
}
 
// ACCESSORS
template <class ELEMENT_TYPE>
inline
bool weak_ptr<ELEMENT_TYPE>::expired() const BSLS_KEYWORD_NOEXCEPT
{
    return !(d_rep_p && d_rep_p->numReferences());
}
 
template <class ELEMENT_TYPE>
shared_ptr<ELEMENT_TYPE> weak_ptr<ELEMENT_TYPE>::lock() const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    if (d_rep_p && d_rep_p->tryAcquireRef()) {
        return shared_ptr<ELEMENT_TYPE>(
                    d_ptr_p,
                    d_rep_p,
                    BloombergLP::bslstl::SharedPtr_RepFromExistingSharedPtr());
                                                                      // RETURN
    }
    return shared_ptr<ELEMENT_TYPE>();
}
 
template <class ELEMENT_TYPE>
template <class ANY_TYPE>
inline
bool
weak_ptr<ELEMENT_TYPE>::owner_before(const shared_ptr<ANY_TYPE>& other) const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return std::less<BloombergLP::bslma::SharedPtrRep *>()(d_rep_p,
                                                           other.rep());
}
 
template <class ELEMENT_TYPE>
template <class ANY_TYPE>
inline
bool
weak_ptr<ELEMENT_TYPE>::owner_before(const weak_ptr<ANY_TYPE>& other) const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return std::less<BloombergLP::bslma::SharedPtrRep *>()(d_rep_p,
                                                           other.d_rep_p);
}
 
template <class ELEMENT_TYPE>
template<class ANY_TYPE>
inline
bool
weak_ptr<ELEMENT_TYPE>::owner_equal(const shared_ptr<ANY_TYPE>& other)
                                                    const BSLS_KEYWORD_NOEXCEPT
{
    return rep() == other.rep();
}
 
template <class ELEMENT_TYPE>
template<class ANY_TYPE>
inline
bool
weak_ptr<ELEMENT_TYPE>::owner_equal(const weak_ptr<ANY_TYPE>& other) const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return rep() == other.rep();
}
 
template <class ELEMENT_TYPE>
inline
size_t
weak_ptr<ELEMENT_TYPE>::owner_hash() const BSLS_KEYWORD_NOEXCEPT
{
    return hash<BloombergLP::bslma::SharedPtrRep *>()(rep());
}
 
template <class ELEMENT_TYPE>
inline
BloombergLP::bslma::SharedPtrRep *weak_ptr<ELEMENT_TYPE>::rep() const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return d_rep_p;
}
 
template <class ELEMENT_TYPE>
inline
long weak_ptr<ELEMENT_TYPE>::use_count() const BSLS_KEYWORD_NOEXCEPT
{
    return d_rep_p ? d_rep_p->numReferences() : 0;
}
 
#ifndef BDE_OMIT_INTERNAL_DEPRECATED
// DEPRECATED BDE LEGACY ACCESSORS
template <class ELEMENT_TYPE>
inline
shared_ptr<ELEMENT_TYPE> weak_ptr<ELEMENT_TYPE>::acquireSharedPtr() const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return lock();
}
 
template <class ELEMENT_TYPE>
inline
int weak_ptr<ELEMENT_TYPE>::numReferences() const BSLS_KEYWORD_NOEXCEPT
{
    return d_rep_p ? d_rep_p->numReferences() : 0;
}
#endif // BDE_OMIT_INTERNAL_DEPRECATED
 
}  // close namespace bsl
 
 
namespace bslstl {
 
                            // -----------------
                            // SharedPtr_ImpUtil
                            // -----------------
 
template <class SHARED_TYPE, class ENABLE_TYPE>
inline
void SharedPtr_ImpUtil::loadEnableSharedFromThis(
                    const bsl::enable_shared_from_this<ENABLE_TYPE> *result,
                    bsl::shared_ptr<SHARED_TYPE>                    *sharedPtr)
{
    BSLS_ASSERT(0 != sharedPtr);
 
    if (0 != result && result->d_weakThis.expired()) {
        result->d_weakThis.privateAssign(
                         sharedPtr->d_rep_p,
                         const_cast <ENABLE_TYPE      *>(
                         static_cast<ENABLE_TYPE const*>(sharedPtr->d_ptr_p)));
    }
}
 
inline
void bslstl::SharedPtr_ImpUtil::loadEnableSharedFromThis(const volatile void *,
                                                         const void *)
                                                          BSLS_KEYWORD_NOEXCEPT
{
}
 
template <class TYPE>
inline
TYPE *SharedPtr_ImpUtil::unqualify(const volatile TYPE *address)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return const_cast<TYPE *>(address);
}
 
template <class TYPE>
inline
void *SharedPtr_ImpUtil::voidify(TYPE *address) BSLS_KEYWORD_NOEXCEPT
{
    return static_cast<void *>(
            const_cast<typename bsl::remove_cv<TYPE>::type *>(address));
}
 
                            // --------------------
                            // struct SharedPtrUtil
                            // --------------------
 
// CLASS METHODS
template <class TARGET, class SOURCE>
inline
void SharedPtrUtil::constCast(bsl::shared_ptr<TARGET>        *target,
                              const bsl::shared_ptr<SOURCE>&  source)
{
    BSLS_ASSERT(0 != target);
 
    target->reset(source, const_cast<TARGET *>(source.get()));
}
 
template <class TARGET, class SOURCE>
inline
bsl::shared_ptr<TARGET>
SharedPtrUtil::constCast(const bsl::shared_ptr<SOURCE>& source)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return bsl::shared_ptr<TARGET>(source,
                                   const_cast<TARGET *>(source.get()));
}
 
template <class TARGET, class SOURCE>
inline
void SharedPtrUtil::dynamicCast(bsl::shared_ptr<TARGET>        *target,
                                const bsl::shared_ptr<SOURCE>&  source)
{
    BSLS_ASSERT(0 != target);
 
    if (TARGET *castPtr = dynamic_cast<TARGET *>(source.get())) {
        target->reset(source, castPtr);
    }
    else {
        target->reset();
    }
}
 
template <class TARGET, class SOURCE>
inline
bsl::shared_ptr<TARGET>
SharedPtrUtil::dynamicCast(const bsl::shared_ptr<SOURCE>& source)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    if (TARGET *castPtr = dynamic_cast<TARGET *>(source.get())) {
        return bsl::shared_ptr<TARGET>(source, castPtr);              // RETURN
    }
 
    return bsl::shared_ptr<TARGET>();
}
 
template <class TARGET, class SOURCE>
inline
void SharedPtrUtil::staticCast(bsl::shared_ptr<TARGET>        *target,
                               const bsl::shared_ptr<SOURCE>&  source)
{
    BSLS_ASSERT(0 != target);
 
    target->reset(source, static_cast<TARGET *>(source.get()));
}
 
template <class TARGET, class SOURCE>
inline
bsl::shared_ptr<TARGET>
SharedPtrUtil::staticCast(const bsl::shared_ptr<SOURCE>& source)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return bsl::shared_ptr<TARGET>(source,
                                   static_cast<TARGET *>(source.get()));
}
 
                        // --------------------------
                        // struct SharedPtrNilDeleter
                        // --------------------------
 
// ACCESSORS
inline
void SharedPtrNilDeleter::operator()(const volatile void *) const
                                                          BSLS_KEYWORD_NOEXCEPT
{
}
 
                        // -------------------------------
                        // struct SharedPtr_DefaultDeleter
                        // -------------------------------
 
// ACCESSORS
template <>
template <class ANY_TYPE>
inline
void SharedPtr_DefaultDeleter<true>::operator()(ANY_TYPE *ptr) const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    delete [] ptr;
}
 
template <>
template <class ANY_TYPE>
inline
void SharedPtr_DefaultDeleter<false>::operator()(ANY_TYPE *ptr) const
                                                          BSLS_KEYWORD_NOEXCEPT
{
    delete ptr;
}
 
                        // --------------------------
                        // class SharedPtr_RepProctor
                        // --------------------------
 
// CREATORS
inline
SharedPtr_RepProctor::SharedPtr_RepProctor(bslma::SharedPtrRep *rep)
                                                          BSLS_KEYWORD_NOEXCEPT
: d_rep_p(rep)
{
}
 
inline
SharedPtr_RepProctor::~SharedPtr_RepProctor()
{
    if (d_rep_p) {
        d_rep_p->disposeRep();
    }
}
 
// MANIPULATORS
inline
void SharedPtr_RepProctor::release() BSLS_KEYWORD_NOEXCEPT
{
    d_rep_p = 0;
}
 
}  // close package namespace
 
 
// FREE OPERATORS
template <class LHS_TYPE, class RHS_TYPE>
inline
bool bsl::operator==(const shared_ptr<LHS_TYPE>& lhs,
                     const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT
{
    return lhs.get() == rhs.get();
}
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON
 
template<class LHS_TYPE, class RHS_TYPE>
inline
bsl::strong_ordering bsl::operator<=>(const shared_ptr<LHS_TYPE>& lhs,
                                      const shared_ptr<RHS_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    const void *p1 = lhs.get(),
               *p2 = rhs.get();
    return p1 <=> p2;
}
 
#else
 
template <class LHS_TYPE, class RHS_TYPE>
inline
bool bsl::operator!=(const shared_ptr<LHS_TYPE>& lhs,
                     const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT
{
    return !(lhs == rhs);
}
 
template <class LHS_TYPE, class RHS_TYPE>
inline
bool bsl::operator<(const shared_ptr<LHS_TYPE>& lhs,
                    const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT
{
    return std::less<const void *>()(lhs.get(), rhs.get());
}
 
template <class LHS_TYPE, class RHS_TYPE>
inline
bool bsl::operator>(const shared_ptr<LHS_TYPE>& lhs,
                    const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT
{
    return rhs < lhs;
}
 
template <class LHS_TYPE, class RHS_TYPE>
inline
bool bsl::operator<=(const shared_ptr<LHS_TYPE>& lhs,
                     const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT
{
    return !(rhs < lhs);
}
 
template <class LHS_TYPE, class RHS_TYPE>
inline
bool bsl::operator>=(const shared_ptr<LHS_TYPE>& lhs,
                     const shared_ptr<RHS_TYPE>& rhs) BSLS_KEYWORD_NOEXCEPT
{
    return !(lhs < rhs);
}
 
#endif  // BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON
 
template <class LHS_TYPE>
inline
bool bsl::operator==(const shared_ptr<LHS_TYPE>& lhs, bsl::nullptr_t)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return !lhs;
}
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON
 
template<class TYPE>
inline
bsl::strong_ordering bsl::operator<=>(const shared_ptr<TYPE>& ptr,
                                      nullptr_t) BSLS_KEYWORD_NOEXCEPT
{
    const typename shared_ptr<TYPE>::element_type *null = nullptr;
    return ptr.get() <=> null;
}
 
#else
 
template <class RHS_TYPE>
inline
bool bsl::operator==(bsl::nullptr_t, const shared_ptr<RHS_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return !rhs;
}
 
template <class LHS_TYPE>
inline
bool bsl::operator!=(const shared_ptr<LHS_TYPE>& lhs, bsl::nullptr_t)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return static_cast<bool>(lhs);
}
 
template <class RHS_TYPE>
inline
bool bsl::operator!=(bsl::nullptr_t, const shared_ptr<RHS_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return static_cast<bool>(rhs);
}
 
template <class LHS_TYPE>
inline
bool bsl::operator<(const shared_ptr<LHS_TYPE>& lhs, bsl::nullptr_t)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return std::less<LHS_TYPE *>()(lhs.get(), 0);
}
 
template <class RHS_TYPE>
inline
bool bsl::operator<(bsl::nullptr_t, const shared_ptr<RHS_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return std::less<RHS_TYPE *>()(0, rhs.get());
}
 
template <class LHS_TYPE>
inline
bool bsl::operator<=(const shared_ptr<LHS_TYPE>& lhs, bsl::nullptr_t)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return !std::less<LHS_TYPE *>()(0, lhs.get());
}
 
template <class RHS_TYPE>
inline
bool bsl::operator<=(bsl::nullptr_t, const shared_ptr<RHS_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return !std::less<RHS_TYPE *>()(rhs.get(), 0);
}
 
template <class LHS_TYPE>
inline
bool bsl::operator>(const shared_ptr<LHS_TYPE>& lhs, bsl::nullptr_t)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return std::less<LHS_TYPE *>()(0, lhs.get());
}
 
template <class RHS_TYPE>
inline
bool bsl::operator>(bsl::nullptr_t, const shared_ptr<RHS_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return std::less<RHS_TYPE *>()(rhs.get(), 0);
}
 
template <class LHS_TYPE>
inline
bool bsl::operator>=(const shared_ptr<LHS_TYPE>& lhs, bsl::nullptr_t)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return !std::less<LHS_TYPE *>()(lhs.get(), 0);
}
 
template <class RHS_TYPE>
inline
bool bsl::operator>=(bsl::nullptr_t, const shared_ptr<RHS_TYPE>& rhs)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return !std::less<RHS_TYPE *>()(0, rhs.get());
}
 
#endif  // BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON
 
template <class CHAR_TYPE, class CHAR_TRAITS, class ELEMENT_TYPE>
inline
std::basic_ostream<CHAR_TYPE, CHAR_TRAITS>&
bsl::operator<<(std::basic_ostream<CHAR_TYPE, CHAR_TRAITS>& stream,
                const shared_ptr<ELEMENT_TYPE>&             rhs)
{
    return stream << rhs.get();
}
 
// ASPECTS
template <class HASHALG, class ELEMENT_TYPE>
inline
void bsl::hashAppend(HASHALG& hashAlg, const shared_ptr<ELEMENT_TYPE>& input)
{
    hashAppend(hashAlg, input.get());
}
 
template <class ELEMENT_TYPE>
inline
void bsl::swap(shared_ptr<ELEMENT_TYPE>& a, shared_ptr<ELEMENT_TYPE>& b)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    a.swap(b);
}
 
template <class ELEMENT_TYPE>
inline
void bsl::swap(weak_ptr<ELEMENT_TYPE>& a, weak_ptr<ELEMENT_TYPE>& b)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    a.swap(b);
}
 
// STANDARD FREE FUNCTIONS
template<class DELETER, class ELEMENT_TYPE>
inline
DELETER *bsl::get_deleter(const shared_ptr<ELEMENT_TYPE>& p)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    BloombergLP::bslma::SharedPtrRep *rep = p.rep();
    return rep ? static_cast<DELETER *>(rep->getDeleter(typeid(DELETER))) : 0;
}
 
// STANDARD CAST FUNCTIONS
template<class TO_TYPE, class FROM_TYPE>
inline
bsl::shared_ptr<TO_TYPE>
bsl::const_pointer_cast(const shared_ptr<FROM_TYPE>& source)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return shared_ptr<TO_TYPE>(source, const_cast<TO_TYPE *>(source.get()));
}
 
template<class TO_TYPE, class FROM_TYPE>
inline
bsl::shared_ptr<TO_TYPE>
bsl::dynamic_pointer_cast(const shared_ptr<FROM_TYPE>& source)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    if (TO_TYPE *castPtr = dynamic_cast<TO_TYPE *>(source.get())) {
        return shared_ptr<TO_TYPE>(source, castPtr);                  // RETURN
    }
 
    return shared_ptr<TO_TYPE>();
}
 
template<class TO_TYPE, class FROM_TYPE>
inline
bsl::shared_ptr<TO_TYPE>
bsl::static_pointer_cast(const shared_ptr<FROM_TYPE>& source)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return shared_ptr<TO_TYPE>(source, static_cast<TO_TYPE *>(source.get()));
}
 
template<class TO_TYPE, class FROM_TYPE>
inline
bsl::shared_ptr<TO_TYPE>
bsl::reinterpret_pointer_cast(const shared_ptr<FROM_TYPE>& source)
                                                          BSLS_KEYWORD_NOEXCEPT
{
    return shared_ptr<TO_TYPE>(source,
                               reinterpret_cast<TO_TYPE *>(source.get()));
}
 
// STANDARD FACTORY FUNCTIONS
 
                     // ===========================
                     // allocate_shared(ALLOC, ...)
                     // ===========================
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_sharedptr.h
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT 14
#endif
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#endif
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 0
template<class ELEMENT_TYPE, class ALLOC>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 1
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 2
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 3
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 4
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 5
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 6
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 7
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 8
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 9
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 10
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 11
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 12
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_12,args_12));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 13
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12,
                                          class ARGS_13>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_12,args_12),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_13,args_13));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 14
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12,
                                          class ARGS_13,
                                          class ARGS_14>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
                            BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_12,args_12),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_13,args_13),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_14,args_14));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_F >= 14
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
 
template<class ELEMENT_TYPE, class ALLOC, class... ARGS>
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator,
                               BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    bsl::allocator_traits<ALLOC>::construct(
                                  basicAllocator,
                                  ImpUtil::unqualify(rep_p->ptr()),
                                  BSLS_COMPILERFEATURES_FORWARD(ARGS,args)...);
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
// }}} END GENERATED CODE
#endif
 
template<class ARRAY_TYPE, class ALLOC>                   // ARRAY_TYPE is T[N]
inline
typename bsl::enable_if<bsl::is_bounded_array<ARRAY_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                       bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef typename bsl::allocator_traits<ALLOC>::template
              rebind_traits<Element_type>::allocator_type ElementAllocatorType;
    typedef BloombergLP::bslstl::
                       SharedPtrArrayAllocateInplaceRep<ARRAY_TYPE, ALLOC> Rep;
 
    const size_t   numElements = ImpUtil::Extent<ARRAY_TYPE>::value;
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::defaultConstruct(
                                    static_cast<Element_type *> (rep_p->ptr()),
                                    numElements,
                                    ElementAllocatorType(basicAllocator));
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE, class ALLOC>                   // ARRAY_TYPE is T[N]
inline
typename bsl::enable_if<bsl::is_bounded_array<ARRAY_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared(
           ALLOC                                                basicAllocator,
           const typename bsl::remove_extent<ARRAY_TYPE>::type& value)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef typename bsl::allocator_traits<ALLOC>::template
              rebind_traits<Element_type>::allocator_type ElementAllocatorType;
    typedef BloombergLP::bslstl::
                       SharedPtrArrayAllocateInplaceRep<ARRAY_TYPE, ALLOC> Rep;
 
    const size_t   numElements = ImpUtil::Extent<ARRAY_TYPE>::value;
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::uninitializedFillN(
                                    static_cast<Element_type *> (rep_p->ptr()),
                                    numElements,
                                    value,
                                    ElementAllocatorType(basicAllocator));
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE, class ALLOC>                    // ARRAY_TYPE is T[]
inline
typename bsl::enable_if<bsl::is_unbounded_array<ARRAY_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared(ALLOC basicAllocator, size_t numElements)
{
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef typename bsl::allocator_traits<ALLOC>::template
              rebind_traits<Element_type>::allocator_type ElementAllocatorType;
    typedef BloombergLP::bslstl::
                       SharedPtrArrayAllocateInplaceRep<ARRAY_TYPE, ALLOC> Rep;
 
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::defaultConstruct(
                                    static_cast<Element_type *> (rep_p->ptr()),
                                    numElements,
                                    ElementAllocatorType(basicAllocator));
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE, class ALLOC>                    // ARRAY_TYPE is T[]
inline
typename bsl::enable_if<bsl::is_unbounded_array<ARRAY_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared(
           ALLOC                                                basicAllocator,
           size_t                                               numElements,
           const typename bsl::remove_extent<ARRAY_TYPE>::type& value)
{
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef typename bsl::allocator_traits<ALLOC>::template
              rebind_traits<Element_type>::allocator_type ElementAllocatorType;
    typedef BloombergLP::bslstl::
                       SharedPtrArrayAllocateInplaceRep<ARRAY_TYPE, ALLOC> Rep;
 
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::uninitializedFillN(
                                    static_cast<Element_type *> (rep_p->ptr()),
                                    numElements,
                                    value,
                                    ElementAllocatorType(basicAllocator));
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
              // =========================================
              // allocate_shared_for_overwrite(ALLOC, ...)
              // =========================================
 
template<class ELEMENT_TYPE, class ALLOC>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared_for_overwrite(ALLOC basicAllocator)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<ELEMENT_TYPE,
                                                             ALLOC> Rep;
    Rep *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE;
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
 
template<class ARRAY_TYPE, class ALLOC>                   // ARRAY_TYPE is T[N]
inline
typename bsl::enable_if<bsl::is_bounded_array<ARRAY_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared_for_overwrite(ALLOC basicAllocator)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef BloombergLP::bslstl::
                       SharedPtrArrayAllocateInplaceRep<ARRAY_TYPE, ALLOC> Rep;
 
    const size_t   numElements = ImpUtil::Extent<ARRAY_TYPE>::value;
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ARRAY_TYPE;
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE, class ALLOC>                    // ARRAY_TYPE is T[]
inline
typename bsl::enable_if<bsl::is_unbounded_array<ARRAY_TYPE>::value &&
                                                !bsl::is_pointer<ALLOC>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared_for_overwrite(ALLOC basicAllocator, size_t numElements)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef BloombergLP::bslstl::
                       SharedPtrArrayAllocateInplaceRep<ARRAY_TYPE, ALLOC> Rep;
 
    Rep *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) Element_type[numElements];
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
                    // =============================
                    // allocate_shared(ALLOC *, ...)
                    // =============================
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_sharedptr.h
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT 14
#endif
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#endif
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 0
template<class ELEMENT_TYPE, class ALLOC>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 0
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 1
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 1
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 2
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 2
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 3
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 3
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 4
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 4
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 5
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 5
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 6
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 6
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 7
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 7
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 8
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 8
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 9
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 9
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 10
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 10
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 11
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 11
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 12
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_12,args_12));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 12
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 13
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12,
                                          class ARGS_13>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_12,args_12),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_13,args_13));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 13
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 14
template<class ELEMENT_TYPE, class ALLOC, class ARGS_01,
                                          class ARGS_02,
                                          class ARGS_03,
                                          class ARGS_04,
                                          class ARGS_05,
                                          class ARGS_06,
                                          class ARGS_07,
                                          class ARGS_08,
                                          class ARGS_09,
                                          class ARGS_10,
                                          class ARGS_11,
                                          class ARGS_12,
                                          class ARGS_13,
                                          class ARGS_14>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_01,args_01),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_02,args_02),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_03,args_03),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_04,args_04),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_05,args_05),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_06,args_06),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_07,args_07),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_08,args_08),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_09,args_09),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_10,args_10),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_11,args_11),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_12,args_12),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_13,args_13),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS_14,args_14));
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_G >= 14
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template<class ELEMENT_TYPE, class ALLOC, class... ARGS>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared(ALLOC     *basicAllocator,
                     BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
    typedef bsl::allocator_traits<AllocatorType>   AllocatorTraits;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    AllocatorTraits::construct(alloc,
                               ImpUtil::unqualify(rep_p->ptr()),
                               BSLS_COMPILERFEATURES_FORWARD(ARGS,args)...);
    proctor.release();
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
// }}} END GENERATED CODE
#endif
 
template<class ARRAY_TYPE, class ALLOC>                   // ARRAY_TYPE is T[N]
inline
typename bsl::enable_if<bsl::is_bounded_array<ARRAY_TYPE>::value,
                         bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared(ALLOC *basicAllocator)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
 
    const size_t   numElements = ImpUtil::Extent<ARRAY_TYPE>::value;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::defaultConstruct(rep_p->ptr(),
                                                           numElements,
                                                           basicAllocator);
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE, class ALLOC>                   // ARRAY_TYPE is T[N]
inline
typename bsl::enable_if<bsl::is_bounded_array<ARRAY_TYPE>::value,
                         bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared(
          ALLOC                                                *basicAllocator,
          const typename bsl::remove_extent<ARRAY_TYPE>::type&  value)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
 
    const size_t   numElements = ImpUtil::Extent<ARRAY_TYPE>::value;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::uninitializedFillN(
                                    static_cast<Element_type *> (rep_p->ptr()),
                                    numElements,
                                    value,
                                    basicAllocator);
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE, class ALLOC>                    // ARRAY_TYPE is T[]
inline
typename bsl::enable_if<bsl::is_unbounded_array<ARRAY_TYPE>::value,
                         bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared(ALLOC *basicAllocator, size_t numElements)
{
    typedef bsl::allocator<char>                          AllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::defaultConstruct(rep_p->ptr(),
                                                           numElements,
                                                           basicAllocator);
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE, class ALLOC>                    // ARRAY_TYPE is T[]
inline
typename bsl::enable_if<bsl::is_unbounded_array<ARRAY_TYPE>::value,
                         bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared(
          ALLOC                                                *basicAllocator,
          size_t                                                numElements,
          const typename bsl::remove_extent<ARRAY_TYPE>::type&  value)
{
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::uninitializedFillN(
                                    static_cast<Element_type *> (rep_p->ptr()),
                                    numElements,
                                    value,
                                    basicAllocator);
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
             // ===========================================
             // allocate_shared_for_overwrite(ALLOC *, ...)
             // ===========================================
 
template<class ELEMENT_TYPE, class ALLOC>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::allocate_shared_for_overwrite(ALLOC *basicAllocator)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE;
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
 
 
template<class ARRAY_TYPE, class ALLOC>                   // ARRAY_TYPE is T[N]
inline
typename bsl::enable_if<bsl::is_bounded_array<ARRAY_TYPE>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared_for_overwrite(ALLOC *basicAllocator)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
 
    const size_t   numElements = ImpUtil::Extent<ARRAY_TYPE>::value;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ARRAY_TYPE;
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE, class ALLOC>                    // ARRAY_TYPE is T[]
inline
typename bsl::enable_if<bsl::is_unbounded_array<ARRAY_TYPE>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::allocate_shared_for_overwrite(ALLOC *basicAllocator, size_t numElements)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
    AllocatorType  alloc(basicAllocator);
    Rep           *rep_p = Rep::makeRep(alloc, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) Element_type[numElements];
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
                         // ================
                         // make_shared(...)
                         // ================
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_sharedptr.h
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT 14
#endif
#ifndef BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H
#define BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H BSLSTL_SHAREDPTR_VARIADIC_LIMIT
#endif
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 0
template<class ELEMENT_TYPE>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared()
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                                 );
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 0
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 1
template<class ELEMENT_TYPE, class ARGS_01>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 1
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 2
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 2
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 3
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 3
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 4
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 4
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 5
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 5
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 6
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 6
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 7
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 7
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 8
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 8
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 9
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 9
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 10
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 10
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 11
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10,
                             class ARGS_11>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 11
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 12
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10,
                             class ARGS_11,
                             class ARGS_12>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 12
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 13
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10,
                             class ARGS_11,
                             class ARGS_12,
                             class ARGS_13>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_13, args_13));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 13
 
#if BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 14
template<class ELEMENT_TYPE, class ARGS_01,
                             class ARGS_02,
                             class ARGS_03,
                             class ARGS_04,
                             class ARGS_05,
                             class ARGS_06,
                             class ARGS_07,
                             class ARGS_08,
                             class ARGS_09,
                             class ARGS_10,
                             class ARGS_11,
                             class ARGS_12,
                             class ARGS_13,
                             class ARGS_14>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_01) args_01,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_02) args_02,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_03) args_03,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_04) args_04,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_05) args_05,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_06) args_06,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_07) args_07,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_08) args_08,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_09) args_09,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_10) args_10,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_11) args_11,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_12) args_12,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_13) args_13,
                 BSLS_COMPILERFEATURES_FORWARD_REF(ARGS_14) args_14)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_01, args_01),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_02, args_02),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_03, args_03),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_04, args_04),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_05, args_05),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_06, args_06),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_07, args_07),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_08, args_08),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_09, args_09),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_10, args_10),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_11, args_11),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_12, args_12),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_13, args_13),
                              BSLS_COMPILERFEATURES_FORWARD(ARGS_14, args_14));
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
#endif  // BSLSTL_SHAREDPTR_VARIADIC_LIMIT_H >= 14
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
 
template<class ELEMENT_TYPE, class... ARGS>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared(BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)... args)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE(
                                 BSLS_COMPILERFEATURES_FORWARD(ARGS, args)...);
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
// }}} END GENERATED CODE
#endif
 
template<class ARRAY_TYPE>                                // ARRAY_TYPE is T[N]
inline
typename bsl::enable_if<bsl::is_bounded_array<ARRAY_TYPE>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::make_shared()
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef typename bsl::allocator_traits<AllocatorType>::template
              rebind_traits<Element_type>::allocator_type ElementAllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
 
    const size_t   numElements = ImpUtil::Extent<ARRAY_TYPE>::value;
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::defaultConstruct(
                                         rep_p->ptr(),
                                         numElements,
                                         ElementAllocatorType(basicAllocator));
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE>                                // ARRAY_TYPE is T[N]
inline
typename bsl::enable_if<bsl::is_bounded_array<ARRAY_TYPE>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::make_shared(const typename bsl::remove_extent<ARRAY_TYPE>::type& value)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef typename bsl::allocator_traits<AllocatorType>::template
              rebind_traits<Element_type>::allocator_type ElementAllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
 
    const size_t   numElements = ImpUtil::Extent<ARRAY_TYPE>::value;
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::uninitializedFillN(
                                         rep_p->ptr(),
                                         numElements,
                                         value,
                                         ElementAllocatorType(basicAllocator));
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE>                                 // ARRAY_TYPE is T[]
inline
typename bsl::enable_if<bsl::is_unbounded_array<ARRAY_TYPE>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::make_shared(size_t numElements)
{
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef typename bsl::allocator_traits<AllocatorType>::template
              rebind_traits<Element_type>::allocator_type ElementAllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::defaultConstruct(
                                         rep_p->ptr(),
                                         numElements,
                                         ElementAllocatorType(basicAllocator));
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE>                                 // ARRAY_TYPE is T[]
inline
typename bsl::enable_if<bsl::is_unbounded_array<ARRAY_TYPE>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::make_shared(
              size_t                                               numElements,
              const typename bsl::remove_extent<ARRAY_TYPE>::type& value)
{
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef typename bsl::allocator_traits<AllocatorType>::template
              rebind_traits<Element_type>::allocator_type ElementAllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    BloombergLP::bslalg::ArrayPrimitives::uninitializedFillN(
                                         rep_p->ptr(),
                                         numElements,
                                         value,
                                         ElementAllocatorType(basicAllocator));
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
                   // ==============================
                   // make_shared_for_overwrite(...)
                   // ==============================
 
template<class ELEMENT_TYPE>
inline
typename bsl::enable_if<!bsl::is_array<ELEMENT_TYPE>::value,
                         bsl::shared_ptr<ELEMENT_TYPE> >::type
bsl::make_shared_for_overwrite()
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil ImpUtil;
    typedef bsl::allocator<char>                   AllocatorType;
 
    typedef BloombergLP::bslstl::SharedPtrAllocateInplaceRep<
                                                            ELEMENT_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ELEMENT_TYPE;
    proctor.release();
 
    return shared_ptr<ELEMENT_TYPE>(rep_p->ptr(), rep_p);
}
 
template<class ARRAY_TYPE>                                // ARRAY_TYPE is T[N]
inline
typename bsl::enable_if<bsl::is_bounded_array<ARRAY_TYPE>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::make_shared_for_overwrite()
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
 
    const size_t   numElements = ImpUtil::Extent<ARRAY_TYPE>::value;
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) ARRAY_TYPE;
 
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
template<class ARRAY_TYPE>                                 // ARRAY_TYPE is T[]
inline
typename bsl::enable_if<bsl::is_unbounded_array<ARRAY_TYPE>::value,
                        bsl::shared_ptr<ARRAY_TYPE> >::type
bsl::make_shared_for_overwrite(size_t numElements)
{
    typedef BloombergLP::bslstl::SharedPtr_ImpUtil        ImpUtil;
    typedef typename bsl::remove_extent<ARRAY_TYPE>::type Element_type;
    typedef bsl::allocator<char>                          AllocatorType;
    typedef BloombergLP::bslstl::SharedPtrArrayAllocateInplaceRep<
                                                            ARRAY_TYPE,
                                                            AllocatorType> Rep;
 
    AllocatorType  basicAllocator;
    Rep           *rep_p = Rep::makeRep(basicAllocator, numElements);
 
    BloombergLP::bslstl::SharedPtr_RepProctor proctor(rep_p);
    ::new (ImpUtil::voidify(rep_p->ptr())) Element_type[numElements];
 
    proctor.release();
 
    BloombergLP::bslma::SharedPtrRep *upcastRep = rep_p;
    return shared_ptr<ARRAY_TYPE>(rep_p->ptr(), upcastRep);
}
 
// ============================================================================
//                              TYPE TRAITS
// ============================================================================
 
// Type traits for smart pointers:
//: o 'shared_ptr' has pointer semantics, but 'weak_ptr' does not.
//:
//: o Although 'shared_ptr' constructs with an allocator, it does not 'use' an
//:   allocator in the manner of the 'UsesBslmaAllocator' trait, and should be
//:   explicitly specialized as a clear sign to code inspection tools.
//:
//: o Smart pointers are bitwise-movable as long as there is no opportunity for
//:   holding a pointer to internal state in the immediate object itself.  As
//:   'd_ptr_p' is never exposed by reference, it is not possible to create an
//:   internal pointer, so the trait should be 'true'.
 
 
 
namespace bslma {
 
template <class ELEMENT_TYPE>
struct UsesBslmaAllocator< ::bsl::shared_ptr<ELEMENT_TYPE> >
    : bsl::false_type
{};
 
}  // close namespace bslma
 
namespace bslmf {
 
template <class ELEMENT_TYPE>
struct HasPointerSemantics< ::bsl::shared_ptr<ELEMENT_TYPE> >
    : bsl::true_type
{};
 
template <class ELEMENT_TYPE>
struct IsBitwiseMoveable< ::bsl::shared_ptr<ELEMENT_TYPE> >
    : bsl::true_type
{};
 
template <class ELEMENT_TYPE>
struct IsBitwiseMoveable< ::bsl::weak_ptr<ELEMENT_TYPE> >
    : bsl::true_type
{};
 
}  // close namespace bslmf
 
 
 
#if defined(BSLS_PLATFORM_HAS_PRAGMA_GCC_DIAGNOSTIC)
# pragma GCC diagnostic pop
#endif
 
#undef BSLSTL_SHAREDPTR_DECLARE_IF_CONVERTIBLE
#undef BSLSTL_SHAREDPTR_DEFINE_IF_CONVERTIBLE
 
#undef BSLSTL_SHAREDPTR_DECLARE_IF_COMPATIBLE
#undef BSLSTL_SHAREDPTR_DEFINE_IF_COMPATIBLE
 
#undef BSLSTL_SHAREDPTR_DECLARE_IF_DELETER
#undef BSLSTL_SHAREDPTR_DEFINE_IF_DELETER
 
#undef BSLSTL_SHAREDPTR_DECLARE_IF_NULLPTR_DELETER
#undef BSLSTL_SHAREDPTR_DEFINE_IF_NULLPTR_DELETER
 
#undef BSLSTL_SHAREDPTR_MSVC_DECLTYPE_WORKAROUND
 
#undef BSLSTL_SHAREDPTR_SFINAE_DISCARD
 
#else // if ! defined(DEFINED_BSLSTL_SHAREDPTR_H)
# error Not valid except when included from bslstl_sharedptr.h
#endif // ! defined(COMPILING_BSLSTL_SHAREDPTR_H)
 
#endif // ! defined(INCLUDED_BSLSTL_SHAREDPTR_CPP03)
 
// ----------------------------------------------------------------------------
// Copyright 2023 Bloomberg Finance L.P.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ----------------------------- END-OF-FILE ----------------------------------
 
/** @} */
/** @} */
/** @} */