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

Namespace for low&hyphen;level algorithms and type traits used by BSL containers&period;

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslalg/ArrayDestructionPrimitives.adoc[`ArrayDestructionPrimitives`] 
| Namespace for utility functions that destroy arrays of `TARGET&lowbar;TYPE`&period;
| xref:BloombergLP/bslalg/ArrayPrimitives.adoc[`ArrayPrimitives`] 
| Namespace for utility functions that operate on arrays of elements&period;
| xref:BloombergLP/bslalg/ArrayPrimitives_CanBitwiseCopy.adoc[`ArrayPrimitives&lowbar;CanBitwiseCopy`] 
| Metafunction that is `true` when `FROM&lowbar;TYPE` and `TO&lowbar;TYPE` are the same type (ignoring top&hyphen;level `const`) and that type is bit&hyphen;wise copyable&period;
| xref:BloombergLP/bslalg/AutoArrayDestructor.adoc[`AutoArrayDestructor`] 
| This class provides a proctor that destroys a guarded range of array elements&period;
| xref:BloombergLP/bslalg/AutoArrayMoveDestructor.adoc[`AutoArrayMoveDestructor`] 
| This `class` provides a specialized proctor that bit&hyphen;wise moves and destroys array segments upon destruction&period;
| xref:BloombergLP/bslalg/AutoScalarDestructor.adoc[`AutoScalarDestructor`] 
| Proctor that destroys a guarded object unless released&period;
| xref:BloombergLP/bslalg/BidirectionalLink.adoc[`BidirectionalLink`] 
| A node in a doubly&hyphen;linked (bidirectional) list&period;
| xref:BloombergLP/bslalg/BidirectionalLinkListUtil.adoc[`BidirectionalLinkListUtil`] 
| Namespace for utility functions that manipulate bidirectional linked lists&period;
| xref:BloombergLP/bslalg/BidirectionalNode.adoc[`BidirectionalNode`] 
| POD&hyphen;like node holding a `VALUE` in a doubly&hyphen;linked list&period;
| xref:BloombergLP/bslalg/ConstructorProxy.adoc[`ConstructorProxy`] 
| Proxy for constructing and destroying an optionally allocator&hyphen;aware object&period;
| xref:BloombergLP/bslalg/ConstructorProxy_AllocatorType-08.adoc[`ConstructorProxy&lowbar;AllocatorType`] 
| Metafunction yielding the allocator types used with a proxied `TYPE`&period;
| xref:BloombergLP/bslalg/ConstructorProxy_PolymorphicAllocator.adoc[`ConstructorProxy&lowbar;PolymorphicAllocator`] 
| Wrapper around `bsl&colon;&colon;polymorphic&lowbar;allocator` that can tolerate being constructed with a null pointer&period;
| xref:BloombergLP/bslalg/ContainerBase.adoc[`ContainerBase`] 
| Allocator proxy base class for STL&hyphen;style containers&period;
| xref:BloombergLP/bslalg/ContainerBase_EmptyBase.adoc[`ContainerBase&lowbar;EmptyBase`] 
| Empty base class for `ContainerBase` with a stateless allocator&period;
| xref:BloombergLP/bslalg/ContainerBase_NonEmptyBase.adoc[`ContainerBase&lowbar;NonEmptyBase`] 
| Base class for `ContainerBase` that stores a non&hyphen;empty allocator&period;
| xref:BloombergLP/bslalg/DequeImpUtil.adoc[`DequeImpUtil`] 
| This `struct`, parameterized by the `VALUE&lowbar;TYPE` and a `BLOCK&lowbar;LENGTH`, provides the various parameters of the deque implementation&period;
| xref:BloombergLP/bslalg/DequeIterator-0d.adoc[`DequeIterator`] 
| Primitive random&hyphen;access iterator over a block&hyphen;based deque&period;
| xref:BloombergLP/bslalg/DequePrimitives-01.adoc[`DequePrimitives`] 
| Namespace for primitive algorithms that operate on deques&period;
| xref:BloombergLP/bslalg/DequePrimitives_DequeElementGuard.adoc[`DequePrimitives&lowbar;DequeElementGuard`] 
| Proctor that destroys a guarded range of deque elements on destruction&period;
| xref:BloombergLP/bslalg/DequePrimitives_DequeEndpointProctor.adoc[`DequePrimitives&lowbar;DequeEndpointProctor`] 
| Proctor that restores a deque endpoint iterator on destruction&period;
| xref:BloombergLP/bslalg/DequePrimitives_DequeMoveGuard.adoc[`DequePrimitives&lowbar;DequeMoveGuard`] 
| Guard that reverses a deque move on destruction unless released&period;
| xref:BloombergLP/bslalg/DequePrimitives_ExternalDequeElementGuard.adoc[`DequePrimitives&lowbar;ExternalDequeElementGuard`] 
| Proctor that destroys an externally updated deque element range&period;
| xref:BloombergLP/bslalg/FunctorAdapter-09.adoc[`FunctorAdapter`] 
| This class provides a metafunction that aliases a callable object to a functor type&period;
| xref:BloombergLP/bslalg/FunctorAdapter_FunctionPointer.adoc[`FunctorAdapter&lowbar;FunctionPointer`] 
| This class provides a functor that delegates to a function pointer&period;
| xref:BloombergLP/bslalg/HasStlIterators-0e.adoc[`HasStlIterators`] 
| This class detects if the specified class `TYPE` has STL&hyphen;like iterators&period;
| xref:BloombergLP/bslalg/HasTrait.adoc[`HasTrait`] 
| This meta&hyphen;function evaluates to `bsl&colon;&colon;true&lowbar;type` if the (template parameter) `TYPE` has the (template parameter) `TRAIT`, and to `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslalg/HashTableAnchor.adoc[`HashTableAnchor`] 
| Value&hyphen;semantic attribute class characterizing the key data of a hash table&period;
| xref:BloombergLP/bslalg/HashTableBucket.adoc[`HashTableBucket`] 
| POD that refers to the first and last nodes of a hash&hyphen;table bucket&period;
| xref:BloombergLP/bslalg/HashTableImpUtil.adoc[`HashTableImpUtil`] 
| This `struct` provides a namespace for a suite of utility functions for creating and manipulating a hash table&period;
| xref:BloombergLP/bslalg/HashTableImpUtil_ExtractKeyResult.adoc[`HashTableImpUtil&lowbar;ExtractKeyResult`] 
| Metafunction that deduces the return type of `KEY&lowbar;CONFIG&colon;&colon;extractKey`&period;
| xref:BloombergLP/bslalg/HashUtil.adoc[`HashUtil`] 
| This `struct` provides a namespace for hash functions&period;
| xref:BloombergLP/bslalg/NothrowMovableUtil.adoc[`NothrowMovableUtil`] 
| Namesapace for `NothrowMovableWrapper` traits and utilities&period;
| xref:BloombergLP/bslalg/NothrowMovableUtil_Traits-04.adoc[`NothrowMovableUtil&lowbar;Traits`] 
| Metafunction providing traits for `NothrowMovableWrapper` types&period;
| xref:BloombergLP/bslalg/NothrowMovableWrapper-02.adoc[`NothrowMovableWrapper`] 
| Wrapper asserting a noexcept move constructor for a value of `TYPE`&period;
| xref:BloombergLP/bslalg/NumericFormatterUtil.adoc[`NumericFormatterUtil`] 
| Namespace `struct` for free functions supporting `to&lowbar;chars`&period;
| xref:BloombergLP/bslalg/RangeCompare.adoc[`RangeCompare`] 
| Utility for equality and lexicographical comparison of iterator ranges&period;
| xref:BloombergLP/bslalg/RbTreeAnchor.adoc[`RbTreeAnchor`] 
| Hold the first&hyphen;node, root&hyphen;node, and node&hyphen;count of a binary search tree&period;
| xref:BloombergLP/bslalg/RbTreeNode.adoc[`RbTreeNode`] 
| A node in a red&hyphen;black binary search tree&period;
| xref:BloombergLP/bslalg/RbTreeUtil.adoc[`RbTreeUtil`] 
| This `struct` provides a namespace for a suite of utility functions that operate on elements of type `RbTreeNode`&period;
| xref:BloombergLP/bslalg/RbTreeUtilTreeProctor.adoc[`RbTreeUtilTreeProctor`] 
| This class implements a proctor that, unless `release` is called, invokes the parameterized `DELETER` on each node in the tree supplied at construction&period;
| xref:BloombergLP/bslalg/RbTreeUtil_Validator.adoc[`RbTreeUtil&lowbar;Validator`] 
| This `struct` provides a namespace for auxiliary functions used to validate a red&hyphen;black binary search tree&period;
| xref:BloombergLP/bslalg/ScalarPrimitives.adoc[`ScalarPrimitives`] 
| Namespace for utility functions that operate on scalar `TARGET&lowbar;TYPE` elements&period;
| xref:BloombergLP/bslalg/SelectTrait.adoc[`SelectTrait`] 
| Meta&hyphen;function that selects the first matching trait for a type&period;
| xref:BloombergLP/bslalg/SwapUtil.adoc[`SwapUtil`] 
| This class provides a namespace for the `swap` utility method&period;
| xref:BloombergLP/bslalg/SynthThreeWayUtil.adoc[`SynthThreeWayUtil`] 
| &quot;Exposition&hyphen;only&quot; part of `bslstl&lowbar;compare&period;h`
| xref:BloombergLP/bslalg/TypeTraitBitwiseCopyable.adoc[`TypeTraitBitwiseCopyable`] 
| Objects of a type with this trait can be copied using `memcpy`&period;
| xref:BloombergLP/bslalg/TypeTraitBitwiseEqualityComparable.adoc[`TypeTraitBitwiseEqualityComparable`] 
| Trait for types whose equality can be tested with `memcmp`&period;
| xref:BloombergLP/bslalg/TypeTraitBitwiseMoveable.adoc[`TypeTraitBitwiseMoveable`] 
| Objects of a type with this trait can be &quot;moved&quot; from one memory location to another using `memmove` or `memcpy`&period;
| xref:BloombergLP/bslalg/TypeTraitHasPointerSemantics.adoc[`TypeTraitHasPointerSemantics`] 
| Trait for types that behave as if they were fundamental pointers&period;
| xref:BloombergLP/bslalg/TypeTraitHasStlIterators.adoc[`TypeTraitHasStlIterators`] 
| A `TYPE` with this trait defines (at minimum) the nested types `iterator` and `const&lowbar;iterator` and the functions `begin()` and `end()` having the standard STL semantics&period;
| xref:BloombergLP/bslalg/TypeTraitHasTrivialDefaultConstructor.adoc[`TypeTraitHasTrivialDefaultConstructor`] 
| Trait for types that have a trivial default constructor&period;
| xref:BloombergLP/bslalg/TypeTraitNil.adoc[`TypeTraitNil`] 
| Nil trait &hyphen;&hyphen; every type has this trait&period;
| xref:BloombergLP/bslalg/TypeTraitPair.adoc[`TypeTraitPair`] 
| A `TYPE` with this trait has two data members, `first` and `second` of types `T&colon;&colon;first&lowbar;type` and `T&colon;&colon;second&lowbar;type`, respectively&period;
| xref:BloombergLP/bslalg/TypeTraitUsesBslmaAllocator.adoc[`TypeTraitUsesBslmaAllocator`] 
| A `TYPE` with this trait uses an allocator derived from `bslma&colon;&colon;Allocator` to supply memory&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslalg/ScalarDestructionPrimitives.adoc[`ScalarDestructionPrimitives`] 
| This alias is defined for backward compatibility&period;
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslalg/_04enum.adoc[`Unnamed enum`] 
| Trait&hyphen;tag constants used to select `DequePrimitives` overloads&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslalg/swap.adoc[`swap`] 
| Efficiently exchange the values of two `HashTableAnchor` objects&period;
| xref:BloombergLP/bslalg/operator_eq-0b.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:BloombergLP/bslalg/operator_not_eq-03.adoc[`operator!&equals;`] 
| Inequality operators
| xref:BloombergLP/bslalg/operator_3way-04.adoc[`operator&lt;&equals;&gt;`] 
| Three&hyphen;way comparison operators
|===



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