[#BloombergLP-bslma]
= xref:BloombergLP.adoc[BloombergLP]::bslma
:relfileprefix: ../
:mrdocs:

Package namespace for memory&hyphen;allocation mechanisms&period;

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslma/AAModel.adoc[`AAModel`] 
| Metafunction that yields the AA model preferred by `TYPE`&period;
| xref:BloombergLP/bslma/AAModelBsl.adoc[`AAModelBsl`] 
| Model tag for bsl&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelIsSupported-06.adoc[`AAModelIsSupported`] 
| Metafunction that is `true&lowbar;type` if `TYPE` supports AA model `MODEL`&period;
| xref:BloombergLP/bslma/AAModelLegacy.adoc[`AAModelLegacy`] 
| Model tag for legacy&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelNone.adoc[`AAModelNone`] 
| Model tag for non&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelPmr.adoc[`AAModelPmr`] 
| Model tag for pmr&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelStl.adoc[`AAModelStl`] 
| Model tag for stl&hyphen;AA types&period;
| xref:BloombergLP/bslma/AATypeUtil.adoc[`AATypeUtil`] 
| Namespace for utility functions on allocator&hyphen;aware types
| xref:BloombergLP/bslma/Allocator.adoc[`Allocator`] 
| Pure abstract protocol for clients and suppliers of raw memory&period;
| xref:BloombergLP/bslma/AllocatorTraits_CallMaxSize-07.adoc[`AllocatorTraits&lowbar;CallMaxSize`] 
| Fallback `max&lowbar;size` implementation when the allocator does not provide its own `max&lowbar;size` member function&period;
| xref:BloombergLP/bslma/AllocatorTraits_ConstPointerType-04.adoc[`AllocatorTraits&lowbar;ConstPointerType`] 
| Metafunction that yields the const pointer type for the specified (template parameter) `T`&period;
| xref:BloombergLP/bslma/AllocatorTraits_ConstVoidPointerType-09.adoc[`AllocatorTraits&lowbar;ConstVoidPointerType`] 
| Metafunction that yields the const void pointer type for allocator `T`&period;
| xref:BloombergLP/bslma/AllocatorTraits_DifferenceType-0d.adoc[`AllocatorTraits&lowbar;DifferenceType`] 
| Metafunction that yields the difference type for allocator `T`&period;
| xref:BloombergLP/bslma/AllocatorTraits_HasConstructMethod.adoc[`AllocatorTraits&lowbar;HasConstructMethod`] 
| Metafunction detecting whether `T` provides a matching `construct` method&period;
| xref:BloombergLP/bslma/AllocatorTraits_HasDestroyMethod.adoc[`AllocatorTraits&lowbar;HasDestroyMethod`] 
| Metafunction that detects whether `T` provides a `destroy` method with the specified signature&period;
| xref:BloombergLP/bslma/AllocatorTraits_HasIsAlwaysEqual.adoc[`AllocatorTraits&lowbar;HasIsAlwaysEqual`] 
| Metafunction detecting whether `ALLOC` defines nested `is&lowbar;always&lowbar;equal`&period;
| xref:BloombergLP/bslma/AllocatorTraits_HasPropOnCopyAssign.adoc[`AllocatorTraits&lowbar;HasPropOnCopyAssign`] 
| Metafunction detecting nested `propagate&lowbar;on&lowbar;container&lowbar;copy&lowbar;assignment`&period;
| xref:BloombergLP/bslma/AllocatorTraits_HasPropOnMoveAssign.adoc[`AllocatorTraits&lowbar;HasPropOnMoveAssign`] 
| Metafunction detecting nested `propagate&lowbar;on&lowbar;container&lowbar;move&lowbar;assignment`&period;
| xref:BloombergLP/bslma/AllocatorTraits_HasPropOnSwap.adoc[`AllocatorTraits&lowbar;HasPropOnSwap`] 
| Metafunction detecting nested `propagate&lowbar;on&lowbar;container&lowbar;swap`&period;
| xref:BloombergLP/bslma/AllocatorTraits_HasSelectOnCopyMethod.adoc[`AllocatorTraits&lowbar;HasSelectOnCopyMethod`] 
| Metafunction detecting `select&lowbar;on&lowbar;container&lowbar;copy&lowbar;construction`&period;
| xref:BloombergLP/bslma/AllocatorTraits_IsAlwaysEqual-0e.adoc[`AllocatorTraits&lowbar;IsAlwaysEqual`] 
| Use the allocator&apos;s nested `is&lowbar;always&lowbar;equal` when defined&period;
| xref:BloombergLP/bslma/AllocatorTraits_PointerType-0e.adoc[`AllocatorTraits&lowbar;PointerType`] 
| Metafunction that yields the pointer type for allocator `T`&period;
| xref:BloombergLP/bslma/AllocatorTraits_PropOnCopyAssign-0a.adoc[`AllocatorTraits&lowbar;PropOnCopyAssign`] 
| Default copy&hyphen;assignment propagation trait to `false&lowbar;type` when undefined&period;
| xref:BloombergLP/bslma/AllocatorTraits_PropOnMoveAssign-05.adoc[`AllocatorTraits&lowbar;PropOnMoveAssign`] 
| Default move&hyphen;assignment propagation trait to `false&lowbar;type` when undefined&period;
| xref:BloombergLP/bslma/AllocatorTraits_PropOnSwap-07.adoc[`AllocatorTraits&lowbar;PropOnSwap`] 
| Default `propagate&lowbar;on&lowbar;container&lowbar;swap` to `false&lowbar;type` when undefined&period;
| xref:BloombergLP/bslma/AllocatorTraits_RebindAlloc-0a.adoc[`AllocatorTraits&lowbar;RebindAlloc`] 
| Metafunction that rebinds an allocator type to a different value type&period;
| xref:BloombergLP/bslma/AllocatorTraits_RebindFront-0d.adoc[`AllocatorTraits&lowbar;RebindFront`] 
| Primary template with no `type` unless `T` is a class template&period;
| xref:BloombergLP/bslma/AllocatorTraits_SizeType-0c.adoc[`AllocatorTraits&lowbar;SizeType`] 
| Metafunction that yields the size type for the specified (template parameter) `T`&period;
| xref:BloombergLP/bslma/AllocatorTraits_VoidPointerType-08c.adoc[`AllocatorTraits&lowbar;VoidPointerType`] 
| Metafunction that yields the void pointer type for the specified (template parameter) `T`&period;
| xref:BloombergLP/bslma/AllocatorUtil.adoc[`AllocatorUtil`] 
| Namespace for utility functions on allocators
| xref:BloombergLP/bslma/AllocatorUtil_Traits-02.adoc[`AllocatorUtil&lowbar;Traits`] 
| Traits extending `allocator&lowbar;traits` to pointer&hyphen;to&hyphen;memory&hyphen;resource types&period;
| xref:BloombergLP/bslma/AutoDeallocator.adoc[`AutoDeallocator`] 
| This class implements a range proctor that automatically deallocates managed memory blocks&period;
| xref:BloombergLP/bslma/AutoDestructor.adoc[`AutoDestructor`] 
| This class implements a range proctor that destroys managed objects&period;
| xref:BloombergLP/bslma/AutoRawDeleter.adoc[`AutoRawDeleter`] 
| Range proctor that deletes a contiguous sequence of objects on destruction&period;
| xref:BloombergLP/bslma/BslAllocator_Voidish.adoc[`BslAllocator&lowbar;Voidish`] 
| Object type that will be placeholder for &apos;void&apos;
| xref:BloombergLP/bslma/BufferAllocator.adoc[`BufferAllocator`] 
| Concrete buffer allocator that allocates from a user&hyphen;supplied fixed&hyphen;size buffer&period;
| xref:BloombergLP/bslma/ConstructionUtil.adoc[`ConstructionUtil`] 
| This `struct` provides a namespace for utility functions that construct elements of (a template parameter) `TARGET&lowbar;TYPE`&period;
| xref:BloombergLP/bslma/ConstructionUtil_AllocAdaptorUtil-06.adoc[`ConstructionUtil&lowbar;AllocAdaptorUtil`] 
| Component&hyphen;private utility for adapting allocator objects (see specializations)&period;
| xref:BloombergLP/bslma/ConstructionUtil_ConstructionTrait.adoc[`ConstructionUtil&lowbar;ConstructionTrait`] 
| Metafunction yielding one of the following three `value` constants&colon;
| xref:BloombergLP/bslma/ConstructionUtil_IsAllocatorPtr-06.adoc[`ConstructionUtil&lowbar;IsAllocatorPtr`] 
| Metafunction that inherits from `true&lowbar;type` if the `ALLOC` type is a pointer to `bslma&colon;&colon;Allocator` or a class derived from it and `false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslma/DeallocateBytesProctor.adoc[`DeallocateBytesProctor`] 
| Proctor that deallocates a managed memory block upon destruction&period;
| xref:BloombergLP/bslma/DeallocateBytesProctor_PtrType-0e7.adoc[`DeallocateBytesProctor&lowbar;PtrType`] 
| Metafunction yielding the void&hyphen;pointer type used by `DeallocateBytesProctor`&period;
| xref:BloombergLP/bslma/DeallocateObjectProctor.adoc[`DeallocateObjectProctor`] 
| Proctor that automatically deallocates a managed object on destruction&period;
| xref:BloombergLP/bslma/DeallocateObjectProctor_PtrType-0d.adoc[`DeallocateObjectProctor&lowbar;PtrType`] 
| Metafunction yielding the pointer type used by `DeallocateObjectProctor`&period;
| xref:BloombergLP/bslma/DeallocatorGuard.adoc[`DeallocatorGuard`] 
| Guard that unconditionally deallocates a managed memory block on destruction&period;
| xref:BloombergLP/bslma/DeallocatorProctor.adoc[`DeallocatorProctor`] 
| Proctor that conditionally manages and deallocates a block of memory&period;
| xref:BloombergLP/bslma/Default.adoc[`Default`] 
| Provide access to the process&hyphen;wide default and global allocators&period;
| xref:BloombergLP/bslma/DefaultAllocatorGuard.adoc[`DefaultAllocatorGuard`] 
| This class provides a scoped guard that temporarily replaces the process&hyphen;wide default allocator&period;
| xref:BloombergLP/bslma/Default_NewDeleteSetter.adoc[`Default&lowbar;NewDeleteSetter`] 
| Set the initial C&plus;&plus;17 default resource to `NewDeleteAllocator`&period;
| xref:BloombergLP/bslma/DeleteObjectProctor.adoc[`DeleteObjectProctor`] 
| Proctor that conditionally deletes a managed object on destruction&period;
| xref:BloombergLP/bslma/DeleteObjectProctor_PtrType-0e.adoc[`DeleteObjectProctor&lowbar;PtrType`] 
| Metafunction yielding the pointer type used by `DeleteObjectProctor`&period;
| xref:BloombergLP/bslma/DeleterHelper.adoc[`DeleterHelper`] 
| This struct provides a namespace for helper functions used for deleting objects in various pools and allocators&period;
| xref:BloombergLP/bslma/DeleterHelper_Helper-0f.adoc[`DeleterHelper&lowbar;Helper`] 
| Helper template for `DeleterHelper` dispatch by polymorphism&period;
| xref:BloombergLP/bslma/DestructionUtil.adoc[`DestructionUtil`] 
| Utility functions that destroy elements of parameterized type `TYPE`&period;
| xref:BloombergLP/bslma/DestructorGuard.adoc[`DestructorGuard`] 
| This class implements a guard that unconditionally destroys a managed object upon destruction by invoking the (managed) object&apos;s destructor&period;
| xref:BloombergLP/bslma/DestructorProctor.adoc[`DestructorProctor`] 
| Proctor that conditionally manages and destroys an object&period;
| xref:BloombergLP/bslma/ExceptionGuard.adoc[`ExceptionGuard`] 
| Guard that verifies an object is unchanged if an exception is thrown&period;
| xref:BloombergLP/bslma/HasAllocatorType-00.adoc[`HasAllocatorType`] 
| Metafunction that yields whether `TYPE` has a nested C&plus;&plus;11 `allocator&lowbar;type`&period;
| xref:BloombergLP/bslma/InfrequentDeleteBlockList.adoc[`InfrequentDeleteBlockList`] 
| Memory manager that allocates and manages a sequence of memory blocks&period;
| xref:BloombergLP/bslma/IsStdAllocator-07.adoc[`IsStdAllocator`] 
| Metafunction that yields whether `TYPE` meets C&plus;&plus;11 allocator requirements&period;
| xref:BloombergLP/bslma/IsStdAllocator_SizeType-04.adoc[`IsStdAllocator&lowbar;SizeType`] 
| Component&hyphen;private metafunction that yields the size type for `TYPE`&period;
| xref:BloombergLP/bslma/MallocFreeAllocator.adoc[`MallocFreeAllocator`] 
| This class provides direct access to the system&hyphen;supplied (native) global `std&colon;&colon;malloc` and `std&colon;&colon;free`&period;
| xref:BloombergLP/bslma/ManagedAllocator.adoc[`ManagedAllocator`] 
| Protocol for allocators that support releasing all allocated memory&period;
| xref:BloombergLP/bslma/ManagedPtr-0fa.adoc[`ManagedPtr`] 
| Smart pointer with sole ownership of a managed object and a possibly distinct target&period;
| xref:BloombergLP/bslma/ManagedPtrDeleter.adoc[`ManagedPtrDeleter`] 
| In&hyphen;core value&hyphen;semantic class that stores a bound delete function&period;
| xref:BloombergLP/bslma/ManagedPtrNilDeleter.adoc[`ManagedPtrNilDeleter`] 
| Utility providing a no&hyphen;op deleter for managed pointers to stack objects&period;
| xref:BloombergLP/bslma/ManagedPtrUtil.adoc[`ManagedPtrUtil`] 
| Utility providing a no&hyphen;op deleter for managed pointers to stack objects&period;
| xref:BloombergLP/bslma/ManagedPtr_DefaultDeleter.adoc[`ManagedPtr&lowbar;DefaultDeleter`] 
| This `struct` provides a function&hyphen;like managed pointer deleter that invokes `delete` with the passed pointer&period;
| xref:BloombergLP/bslma/ManagedPtr_FactoryDeleter.adoc[`ManagedPtr&lowbar;FactoryDeleter`] 
| This utility provides a general deleter for factories that provide a `deleteObject` operation (e&period;g&period;, `bslma&colon;&colon;Allocator`, `bdlma&colon;&colon;Pool`)&period;
| xref:BloombergLP/bslma/ManagedPtr_FactoryDeleterType.adoc[`ManagedPtr&lowbar;FactoryDeleterType`] 
| Metafunction selecting the preferred factory deleter for `ManagedPtr`&period;
| xref:BloombergLP/bslma/ManagedPtr_Members.adoc[`ManagedPtr&lowbar;Members`] 
| Type&hyphen;agnostic container for the internal state of a managed pointer&period;
| xref:BloombergLP/bslma/ManagedPtr_PairProxy.adoc[`ManagedPtr&lowbar;PairProxy`] 
| This class is a simple aggregate that may be used to construct a `bsl&colon;&colon;pair` object&period;
| xref:BloombergLP/bslma/ManagedPtr_Ref.adoc[`ManagedPtr&lowbar;Ref`] 
| Temporary reference enabling construction from temporary `ManagedPtr`s&period;
| xref:BloombergLP/bslma/ManagedPtr_TraitConstraint.adoc[`ManagedPtr&lowbar;TraitConstraint`] 
| This `struct` is an empty type that exists solely to enable constructor access to be constrained by type trait&period;
| xref:BloombergLP/bslma/MemoryResourceImpSupport.adoc[`MemoryResourceImpSupport`] 
| Namespace for functions that support implementing a memory resource&period;
| xref:BloombergLP/bslma/MemoryResourceImpSupport_AlignedData.adoc[`MemoryResourceImpSupport&lowbar;AlignedData`] 
| Component&hyphen;private maximally aligned struct holding an unsigned 64&hyphen;bit integer&period;
| xref:BloombergLP/bslma/NewDeleteAllocator.adoc[`NewDeleteAllocator`] 
| Concrete allocator adapting global `operator new` and `operator delete`&period;
| xref:BloombergLP/bslma/PointerUtil.adoc[`PointerUtil`] 
| This `struct` provides a namespace for utility functions that perform low&hyphen;level pointer manipulations&period;
| xref:BloombergLP/bslma/RawDeleterGuard.adoc[`RawDeleterGuard`] 
| Guard that unconditionally deletes a managed object on destruction&period;
| xref:BloombergLP/bslma/RawDeleterProctor.adoc[`RawDeleterProctor`] 
| Proctor that conditionally manages and deletes an object&period;
| xref:BloombergLP/bslma/SequentialAllocator.adoc[`SequentialAllocator`] 
| This class implements the `ManagedAllocator` protocol to provide a fast allocator of arbitrarily&hyphen;sized blocks of memory&period;
| xref:BloombergLP/bslma/SequentialPool.adoc[`SequentialPool`] 
| This class implements a memory pool that dispenses arbitrarily&hyphen;sized blocks of memory&period;
| xref:BloombergLP/bslma/SharedPtrInplaceRep.adoc[`SharedPtrInplaceRep`] 
| In&hyphen;place `SharedPtrRep` implementation for a managed object of `TYPE`&period;
| xref:BloombergLP/bslma/SharedPtrOutofplaceRep.adoc[`SharedPtrOutofplaceRep`] 
| Out&hyphen;of&hyphen;place concrete implementation of the `SharedPtrRep` protocol&period;
| xref:BloombergLP/bslma/SharedPtrOutofplaceRep_DeleterDiscriminator.adoc[`SharedPtrOutofplaceRep&lowbar;DeleterDiscriminator`] 
| Metafunction that classifies a deleter&apos;s kind and C&plus;&plus; type&period;
| xref:BloombergLP/bslma/SharedPtrOutofplaceRep_DeleterHelper.adoc[`SharedPtrOutofplaceRep&lowbar;DeleterHelper`] 
| This `struct` provides utility functions to apply a deleter to a shared object referred to by `SharedPtrOutofplaceRep`&period;
| xref:BloombergLP/bslma/SharedPtrOutofplaceRep_DeleterType.adoc[`SharedPtrOutofplaceRep&lowbar;DeleterType`] 
| This `struct` enumerates four kinds of deleters, the first two are factory deleters, and the last two are function&hyphen;like deleters&period;
| xref:BloombergLP/bslma/SharedPtrOutofplaceRep_InitProctor.adoc[`SharedPtrOutofplaceRep&lowbar;InitProctor`] 
| Proctor that deletes a pointer if out&hyphen;of&hyphen;place rep construction fails&period;
| xref:BloombergLP/bslma/SharedPtrRep.adoc[`SharedPtrRep`] 
| Partially implemented shared pointer representation protocol&period;
| xref:BloombergLP/bslma/StdTestAllocator.adoc[`StdTestAllocator`] 
| An STL&hyphen;compatible test allocator that forwards to a `bslma&colon;&colon;TestAllocator`&period;
| xref:BloombergLP/bslma/SuppressesImplicitConvertibilityWarnings.adoc[`SuppressesImplicitConvertibilityWarnings`] 
| Metafunction that reports whether convertibility deprecation warnings are suppressed for `t&lowbar;TYPE`&period;
| xref:BloombergLP/bslma/TestAllocator.adoc[`TestAllocator`] 
| Concrete test allocator that tracks memory usage for testing&period;
| xref:BloombergLP/bslma/TestAllocatorException.adoc[`TestAllocatorException`] 
| This class defines an exception object for memory allocation operations&period; Objects of this class contain information about an allocation request&period;
| xref:BloombergLP/bslma/TestAllocatorMonitor.adoc[`TestAllocatorMonitor`] 
| Mechanism that reports changes in a `TestAllocator`&apos;s statistics&period;
| xref:BloombergLP/bslma/TestAllocatorStashedStatistics.adoc[`TestAllocatorStashedStatistics`] 
| Saved `TestAllocator` statistics for later restoration&period;
| xref:BloombergLP/bslma/TestAllocatorStatisticsGuard.adoc[`TestAllocatorStatisticsGuard`] 
| This mechanism provides scoped, localized statistics for a `TestAllocator`&period;
| xref:BloombergLP/bslma/TestAllocator_BlockHeader.adoc[`TestAllocator&lowbar;BlockHeader`] 
| Private header for a block of allocated memory managed by `TestAllocator`&period;
| xref:BloombergLP/bslma/TestAllocator_Proxy.adoc[`TestAllocator&lowbar;Proxy`] 
| Proxy for a test allocator used by exception&hyphen;test macros&period;
| xref:BloombergLP/bslma/TestAllocator_ProxyBase.adoc[`TestAllocator&lowbar;ProxyBase`] 
| Common base class for `TestAllocator&lowbar;Proxy`&period;
| xref:BloombergLP/bslma/UsesBslmaAllocator-020.adoc[`UsesBslmaAllocator`] 
| Metafunction that is `true&lowbar;type` if `TYPE` uses the `bslma` allocator idiom&period;
| xref:BloombergLP/bslma/UsesBslmaAllocator_DeprecatedIf-0f.adoc[`UsesBslmaAllocator&lowbar;DeprecatedIf`] 
| Empty helper whose `check` may emit a deprecation warning&period;
| xref:BloombergLP/bslma/UsesBslmaAllocator_Sniff-0d.adoc[`UsesBslmaAllocator&lowbar;Sniff`] 
| Metafunction that sniffs whether `TYPE` is convertible from `bslma&colon;&colon;Allocator &ast;`&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslma/AllocatorAdaptor.adoc[`AllocatorAdaptor`] 
| Polymorphic wrapper around an STL&hyphen;style allocator&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslma/TestAllocator_getProxy.adoc[`TestAllocator&lowbar;getProxy`] 
| Return, by value, a test allocator proxy for the specified parameterized `allocator`&period;
| xref:BloombergLP/bslma/swap.adoc[`swap`] 
| Efficiently exchange the values of the specified `a` and `b` objects&period; This function provides the no&hyphen;throw exception&hyphen;safety guarantee&period;
| xref:BloombergLP/bslma/operator_lshift.adoc[`operator&lt;&lt;`] 
| Write the state of `ta` to `stream` and return `stream`&period;
| xref:BloombergLP/bslma/operator_eq-03.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:BloombergLP/bslma/operator_not_eq-09.adoc[`operator!&equals;`] 
| Inequality operators
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslma/IsStdAllocator_v.adoc[`IsStdAllocator&lowbar;v`] 
| This template variable represents the result value of the `bslma&colon;&colon;IsStdAllocator` meta&hyphen;function&period;
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
