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

Implementation details for `basic&lowbar;syncbuf` and related stream types&period;

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/AlgorithmUtil.adoc[`AlgorithmUtil`] 
| Provide a namespace for implementing helper routines for algorithm implementations&period;
| xref:BloombergLP/bslstl/BadWeakPtr.adoc[`BadWeakPtr`] 
| Exception type thrown when a `weak&lowbar;ptr` is locked after its managed object is destroyed&period;
| xref:BloombergLP/bslstl/BidirectionalIterator.adoc[`BidirectionalIterator`] 
| Adaptor that produces a standard bidirectional iterator from a core type&period;
| xref:BloombergLP/bslstl/BidirectionalNodePool.adoc[`BidirectionalNodePool`] 
| This class provides methods for creating and destroying nodes using the appropriate allocator&hyphen;traits of the (template parameter) type `ALLOCATOR`&period;
| xref:BloombergLP/bslstl/BoyerMooreHorspoolSearcher.adoc[`BoyerMooreHorspoolSearcher`] 
| STL&hyphen;compliant searcher using the Boyer&hyphen;Moore&hyphen;Horspool algorithm&period;
| xref:BloombergLP/bslstl/BoyerMooreHorspoolSearcher_CharImp.adoc[`BoyerMooreHorspoolSearcher&lowbar;CharImp`] 
| Char&hyphen;optimized Boyer&hyphen;Moore&hyphen;Horspool searcher implementation&period;
| xref:BloombergLP/bslstl/BoyerMooreHorspoolSearcher_GeneralImp.adoc[`BoyerMooreHorspoolSearcher&lowbar;GeneralImp`] 
| This class template implements the same interfaces as the `BoyerMooreHorspoolSearcher&lowbar;CharImp` for arbitrary `value&lowbar;type`&period;
| xref:BloombergLP/bslstl/CallableVariable.adoc[`CallableVariable`] 
| Metafunction aliasing `CALLABLE`, or `CALLABLE &amp;` for function types&period;
| xref:BloombergLP/bslstl/DefaultSearcher.adoc[`DefaultSearcher`] 
| Searcher functor using a naive sequential search for a fixed needle&period;
| xref:BloombergLP/bslstl/DefaultSearcher_CanOptimize.adoc[`DefaultSearcher&lowbar;CanOptimize`] 
| Trait indicating whether the default searcher can use an optimized path&period;
| xref:BloombergLP/bslstl/ForwardIterator.adoc[`ForwardIterator`] 
| STL&hyphen;compliant forward iterator adapted from a minimal implementation&period;
| xref:BloombergLP/bslstl/Function_ArgTypes-06.adoc[`Function&lowbar;ArgTypes`] 
| Component&hyphen;private metafunction providing nested argument typedefs for `bsl&colon;&colon;function`&period;
| xref:BloombergLP/bslstl/Function_InvokerUtil.adoc[`Function&lowbar;InvokerUtil`] 
| Namespace for looking up an invoker for a given callable type&period;
| xref:BloombergLP/bslstl/Function_InvokerUtilNullCheck-03.adoc[`Function&lowbar;InvokerUtilNullCheck`] 
| Customization point that detects whether a `FUNC` callable is null&period;
| xref:BloombergLP/bslstl/Function_InvokerUtil_Dispatch-09a.adoc[`Function&lowbar;InvokerUtil&lowbar;Dispatch`] 
| Dispatcher that invokes a callable of category `INVOCATION&lowbar;TYPE`&period;
| xref:BloombergLP/bslstl/Function_InvokerUtil_ForwardType.adoc[`Function&lowbar;InvokerUtil&lowbar;ForwardType`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_ForwardTypeImp-01.adoc[`Function&lowbar;InvokerUtil&lowbar;ForwardTypeImp`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_IsExplicitlyConvertible-0c.adoc[`Function&lowbar;InvokerUtil&lowbar;IsExplicitlyConvertible`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_IsExplicitlyConvertibleImp-0d.adoc[`Function&lowbar;InvokerUtil&lowbar;IsExplicitlyConvertibleImp`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_IsFuncInvocable-05.adoc[`Function&lowbar;InvokerUtil&lowbar;IsFuncInvocable`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_IsFuncInvocableImp-03.adoc[`Function&lowbar;InvokerUtil&lowbar;IsFuncInvocableImp`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_ResultType.adoc[`Function&lowbar;InvokerUtil&lowbar;ResultType`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_ResultTypeImp-02.adoc[`Function&lowbar;InvokerUtil&lowbar;ResultTypeImp`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_IsInvocableWithPrototype-06.adoc[`Function&lowbar;IsInvocableWithPrototype`] 
| Forward declaration of the invocability metafunction for `bsl&colon;&colon;function`&period;
| xref:BloombergLP/bslstl/Function_IsReferenceCompatible-0c.adoc[`Function&lowbar;IsReferenceCompatible`] 
| Metafunction that is `true&lowbar;type` if a reference to `FROM&lowbar;TYPE` can substitute for a reference to `TO&lowbar;TYPE`&period;
| xref:BloombergLP/bslstl/Function_Rep.adoc[`Function&lowbar;Rep`] 
| This is a component&hyphen;private class&period; Do not use&period;
| xref:BloombergLP/bslstl/Function_SmallObjectOptimization.adoc[`Function&lowbar;SmallObjectOptimization`] 
| Utility types and constants for `bsl&colon;&colon;function` small&hyphen;object optimization&period;
| xref:BloombergLP/bslstl/Function_Variadic-0e.adoc[`Function&lowbar;Variadic`] 
| This component&hyphen;private class template contains the physical representation and provides the variadic interfaces for `bsl&colon;&colon;function`&period;
| xref:BloombergLP/bslstl/HashTable.adoc[`HashTable`] 
| Value&hyphen;semantic unordered container of keyed elements&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[`HashTableBucketIterator`] 
| Standard&hyphen;conforming forward iterator over a single hash&hyphen;table bucket&period;
| xref:BloombergLP/bslstl/HashTableIterator.adoc[`HashTableIterator`] 
| STL&hyphen;conforming forward iterator over hash&hyphen;table node lists&period;
| xref:BloombergLP/bslstl/HashTable_ArrayProctor.adoc[`HashTable&lowbar;ArrayProctor`] 
| This class probably already exists in `bslalg`
| xref:BloombergLP/bslstl/HashTable_BaseHasher.adoc[`HashTable&lowbar;BaseHasher`] 
| This `struct` adapts the (template parameter) `HASHER` type for use as the base hasher of a `HashTable`&period;
| xref:BloombergLP/bslstl/HashTable_Comparator.adoc[`HashTable&lowbar;Comparator`] 
| Comparator adapter used by `HashTable`&period;
| xref:BloombergLP/bslstl/HashTable_ComparatorWrapper-0e.adoc[`HashTable&lowbar;ComparatorWrapper`] 
| Wrapper ensuring a comparator&apos;s call operator is const&hyphen;qualified&period;
| xref:BloombergLP/bslstl/HashTable_HashWrapper-03.adoc[`HashTable&lowbar;HashWrapper`] 
| Wrapper ensuring a hash functor&apos;s call operator is const&hyphen;qualified&period;
| xref:BloombergLP/bslstl/HashTable_NodeProctor.adoc[`HashTable&lowbar;NodeProctor`] 
| Proctor that deletes a managed node unless `release` is called&period;
| xref:BloombergLP/bslstl/HashTable_Util.adoc[`HashTable&lowbar;Util`] 
| Utilities for initializing and destroying `HashTable` bucket arrays&period;
| xref:BloombergLP/bslstl/IoManip_QuotedStringFormatter.adoc[`IoManip&lowbar;QuotedStringFormatter`] 
| Temporary proxy for quoting a `bsl&colon;&colon;basic&lowbar;string` in stream I&sol;O&period;
| xref:BloombergLP/bslstl/IoManip_QuotedStringViewFormatter.adoc[`IoManip&lowbar;QuotedStringViewFormatter`] 
| Temporary proxy for quoting a `bsl&colon;&colon;basic&lowbar;string&lowbar;view` for stream output&period;
| xref:BloombergLP/bslstl/IsConvertibleToCString-04.adoc[`IsConvertibleToCString`] 
| This `struct` template implements a meta&hyphen;function to determine if the (template parameter) `t&lowbar;TYPE` is convertible to `const t&lowbar;CHAR&lowbar;TYPE &ast;`&period;
| xref:BloombergLP/bslstl/IsConvertibleToStringView-02.adoc[`IsConvertibleToStringView`] 
| Meta&hyphen;function for detecting types convertible to a string view&period;
| xref:BloombergLP/bslstl/IteratorUtil.adoc[`IteratorUtil`] 
| This utility struct provides a namespace for functions on iterators and iterator ranges&period;
| xref:BloombergLP/bslstl/IteratorUtil_LegacyInsertDistance-03.adoc[`IteratorUtil&lowbar;LegacyInsertDistance`] 
| Utility for type&hyphen;based dispatch of insert&hyphen;distance calculation&period;
| xref:BloombergLP/bslstl/MapComparator.adoc[`MapComparator`] 
| This class compares map keys with `TreeNode` objects using `COMPARATOR`&period;
| xref:BloombergLP/bslstl/Optional_Base-05.adoc[`Optional&lowbar;Base`] 
| Component&hyphen;private class template implementing `bsl&colon;&colon;optional`&period;
| xref:BloombergLP/bslstl/Optional_ConstructFromForwardRef.adoc[`Optional&lowbar;ConstructFromForwardRef`] 
| Tag type selecting construction from a forwarding reference&period;
| xref:BloombergLP/bslstl/Optional_ConstructsFromType.adoc[`Optional&lowbar;ConstructsFromType`] 
| Metafunction detecting constructibility from a non&hyphen;optional type&period;
| xref:BloombergLP/bslstl/Optional_CopyConstructFromOtherOptional.adoc[`Optional&lowbar;CopyConstructFromOtherOptional`] 
| Tag type selecting copy construction from another `optional`&period;
| xref:BloombergLP/bslstl/Optional_CopyConstructFromStdOptional.adoc[`Optional&lowbar;CopyConstructFromStdOptional`] 
| Tag type selecting copy construction from a `std&colon;&colon;optional`&period;
| xref:BloombergLP/bslstl/Optional_Data-0c.adoc[`Optional&lowbar;Data`] 
| Component&hyphen;private storage that destroys a non&hyphen;trivial contained value&period;
| xref:BloombergLP/bslstl/Optional_DataImp.adoc[`Optional&lowbar;DataImp`] 
| Component&hyphen;private buffer managing an optional&apos;s contained value&period;
| xref:BloombergLP/bslstl/Optional_ImmovableHelper.adoc[`Optional&lowbar;ImmovableHelper`] 
| Helper enabling in&hyphen;place construction of immovable values&period;
| xref:BloombergLP/bslstl/Optional_InvokeConstructorTag.adoc[`Optional&lowbar;InvokeConstructorTag`] 
| Constructor tag used to implement the `transform` function&period;
| xref:BloombergLP/bslstl/Optional_IsBslOptional-07.adoc[`Optional&lowbar;IsBslOptional`] 
| Metafunction that is `false&lowbar;type` for types that are not `bsl&colon;&colon;optional`&period;
| xref:BloombergLP/bslstl/Optional_IsTriviallyDestructible.adoc[`Optional&lowbar;IsTriviallyDestructible`] 
| This metafunction is derived from `std&colon;&colon;is&lowbar;trivially&lowbar;destructible&lt;t&lowbar;TYPE&gt;` in C&plus;&plus;11 and later&period;
| xref:BloombergLP/bslstl/Optional_MoveConstructFromOtherOptional.adoc[`Optional&lowbar;MoveConstructFromOtherOptional`] 
| Tag type selecting move construction from another `optional`&period;
| xref:BloombergLP/bslstl/Optional_MoveConstructFromStdOptional.adoc[`Optional&lowbar;MoveConstructFromStdOptional`] 
| Tag type selecting move construction from a `std&colon;&colon;optional`&period;
| xref:BloombergLP/bslstl/Optional_NulloptConstructToken.adoc[`Optional&lowbar;NulloptConstructToken`] 
| This trivial tag type is used to create `nullopt&lowbar;t` objects prior to C&plus;&plus;17&period;
| xref:BloombergLP/bslstl/Optional_OptNoSuchType.adoc[`Optional&lowbar;OptNoSuchType`] 
| Tag type distinguishing user arguments from `enable&lowbar;if` defaults&period;
| xref:BloombergLP/bslstl/Optional_PropagatesAllocator.adoc[`Optional&lowbar;PropagatesAllocator`] 
| Metafunction detecting allocator propagation for const value types&period;
| xref:BloombergLP/bslstl/Pair_GetImpUtil-0f.adoc[`Pair&lowbar;GetImpUtil`] 
| This utility class template provides functions for selecting the element of pair, returned from `bsl&colon;&colon;get(bsl&colon;&colon;pair&lt;T1, T2&gt;)`, by its index&period;
| xref:BloombergLP/bslstl/Pair_IndexOfType-02.adoc[`Pair&lowbar;IndexOfType`] 
| Metafunction giving the index of the pair element having type `T`&period;
| xref:BloombergLP/bslstl/RandomAccessIterator.adoc[`RandomAccessIterator`] 
| STL&hyphen;compliant random&hyphen;access iterator adapted from a minimal implementation&period;
| xref:BloombergLP/bslstl/SetComparator.adoc[`SetComparator`] 
| Comparator for `TreeNode` objects and lookup keys&period;
| xref:BloombergLP/bslstl/SharedPtrAllocateInplaceRep.adoc[`SharedPtrAllocateInplaceRep`] 
| In&hyphen;place `SharedPtrRep` implementation for a managed object of `TYPE`&period;
| xref:BloombergLP/bslstl/SharedPtrAllocateOutofplaceRep.adoc[`SharedPtrAllocateOutofplaceRep`] 
| Out&hyphen;of&hyphen;place concrete implementation of the `SharedPtrRep` protocol&period;
| xref:BloombergLP/bslstl/SharedPtrAllocateOutofplaceRep_InitProctor.adoc[`SharedPtrAllocateOutofplaceRep&lowbar;InitProctor`] 
| Proctor that deletes a pointer if out&hyphen;of&hyphen;place rep construction fails&period;
| xref:BloombergLP/bslstl/SharedPtrArrayAllocateInplaceRep.adoc[`SharedPtrArrayAllocateInplaceRep`] 
| In&hyphen;place `SharedPtrRep` implementation for a managed array of `TYPE`&period;
| xref:BloombergLP/bslstl/SharedPtrNilDeleter.adoc[`SharedPtrNilDeleter`] 
| This `struct` provides a function&hyphen;like shared pointer deleter that does nothing when invoked&period;
| xref:BloombergLP/bslstl/SharedPtrUtil.adoc[`SharedPtrUtil`] 
| This `struct` provides a namespace for operations on shared pointers&period;
| xref:BloombergLP/bslstl/SharedPtr_DefaultDeleter-06.adoc[`SharedPtr&lowbar;DefaultDeleter`] 
| Function&hyphen;like deleter that deletes a pointer with `delete` or `delete&lsqb;&rsqb;`&period;
| xref:BloombergLP/bslstl/SharedPtr_IsCallable.adoc[`SharedPtr&lowbar;IsCallable`] 
| Trait detecting whether `FUNCTOR` is callable with `ARG`&period;
| xref:BloombergLP/bslstl/SharedPtr_IsFactoryFor.adoc[`SharedPtr&lowbar;IsFactoryFor`] 
| Trait detecting whether `FACTORY` can delete an `ARG` object&period;
| xref:BloombergLP/bslstl/SharedPtr_IsNullableFactory.adoc[`SharedPtr&lowbar;IsNullableFactory`] 
| Trait detecting whether `FACTORY` accepts a null pointer in `deleteObject`&period;
| xref:BloombergLP/bslstl/SharedPtr_IsPointerCompatible.adoc[`SharedPtr&lowbar;IsPointerCompatible`] 
| Trait detecting compatibility of `SOURCE&lowbar;TYPE &ast;` with `DEST&lowbar;TYPE &ast;`&period;
| xref:BloombergLP/bslstl/SharedPtr_IsPointerConvertible.adoc[`SharedPtr&lowbar;IsPointerConvertible`] 
| Trait detecting convertibility of `SOURCE&lowbar;TYPE &ast;` to `DEST&lowbar;TYPE &ast;`&period;
| xref:BloombergLP/bslstl/SharedPtr_RepFromExistingSharedPtr.adoc[`SharedPtr&lowbar;RepFromExistingSharedPtr`] 
| Tag type identifying a `SharedPtrRep` from an existing `shared&lowbar;ptr`&period;
| xref:BloombergLP/bslstl/SharedPtr_RepProctor.adoc[`SharedPtr&lowbar;RepProctor`] 
| Proctor that disposes a `SharedPtrRep` unless `release` is called&period;
| xref:BloombergLP/bslstl/SharedPtr_TestIsCallable.adoc[`SharedPtr&lowbar;TestIsCallable`] 
| SFINAE helper that probes whether `FUNCTOR` is callable with an argument&period;
| xref:BloombergLP/bslstl/SimplePool.adoc[`SimplePool`] 
| Memory pool that allocates blocks of a fixed value type&period;
| xref:BloombergLP/bslstl/SimplePool_Type.adoc[`SimplePool&lowbar;Type`] 
| Provide type aliases for a maximally aligned `SimplePool` base class&period;
| xref:BloombergLP/bslstl/StdExceptUtil.adoc[`StdExceptUtil`] 
| This `struct` provides a namespace for `static` utility functions that throw standard library exceptions&period;
| xref:BloombergLP/bslstl/StopCallback_CallbackStorage-06.adoc[`StopCallback&lowbar;CallbackStorage`] 
| Stores a non&hyphen;reference `t&lowbar;CALLBACK` object for stop callbacks&period;
| xref:BloombergLP/bslstl/StopCallback_NoAlloc.adoc[`StopCallback&lowbar;NoAlloc`] 
| This component&hyphen;private empty class is used as a dummy &quot;allocator&quot; when `bsl&colon;&colon;stop&lowbar;callback` wraps a non&hyphen;allocator&hyphen;aware type&period;
| xref:BloombergLP/bslstl/StopCallback_Node.adoc[`StopCallback&lowbar;Node`] 
| Component&hyphen;private node storing a stop callback for `StopState`&period;
| xref:BloombergLP/bslstl/StopState.adoc[`StopState`] 
| Shared stop state that tracks a stop request and registered callbacks&period;
| xref:BloombergLP/bslstl/StopStateCallbackNode.adoc[`StopStateCallbackNode`] 
| Intrusive list node that stores a registered stop&hyphen;callback invocation&period;
| xref:BloombergLP/bslstl/StopState_ListNode.adoc[`StopState&lowbar;ListNode`] 
| This component&hyphen;private class represents a node in a doubly&hyphen;linked list&period;
| xref:BloombergLP/bslstl/StopToken_RefCountedState.adoc[`StopToken&lowbar;RefCountedState`] 
| Component&hyphen;private `StopState` with a `stop&lowbar;source` reference count&period;
| xref:BloombergLP/bslstl/StringRefData-04.adoc[`StringRefData`] 
| This class is an intermediate link between `bslstl&colon;&colon;StringRef` used in BDE and `bsl&colon;&colon;string&lowbar;view` and is kept only for compatibility with legacy code&period;
| xref:BloombergLP/bslstl/StringRefImp-0c.adoc[`StringRefImp`] 
| Provide a non&hyphen;owning reference to a contiguous character sequence&period;
| xref:BloombergLP/bslstl/StringRefImp_CompareUtil.adoc[`StringRefImp&lowbar;CompareUtil`] 
| &lsqb;*PRIVATE*&rsqb;This class provides a namespace for private comparison implementation functions&period;
| xref:BloombergLP/bslstl/SyncBufBase.adoc[`SyncBufBase`] 
| Allocator&hyphen;independent base of `basic&lowbar;syncbuf`&period;
| xref:BloombergLP/bslstl/SyncBufBaseUtil.adoc[`SyncBufBaseUtil`] 
| Internal utils&period;
| xref:BloombergLP/bslstl/TreeIterator.adoc[`TreeIterator`] 
| STL&hyphen;conforming bidirectional iterator over ordered tree nodes&period;
| xref:BloombergLP/bslstl/TreeNode.adoc[`TreeNode`] 
| POD&hyphen;like node for a red&hyphen;black tree of parameterized `VALUE` objects&period;
| xref:BloombergLP/bslstl/TreeNodePool.adoc[`TreeNodePool`] 
| Memory manager that creates and deletes nodes for tree&hyphen;based containers&period;
| xref:BloombergLP/bslstl/UnorderedMapKeyConfiguration.adoc[`UnorderedMapKeyConfiguration`] 
| This `struct` provides a namespace for key&hyphen;configuration utilities used by `bsl&colon;&colon;unordered&lowbar;map` to extract keys from stored value objects&period;
| xref:BloombergLP/bslstl/UnorderedSetKeyConfiguration.adoc[`UnorderedSetKeyConfiguration`] 
| The `UnorderedSetKeyConfiguration` type&period;
| xref:BloombergLP/bslstl/Variant_AllocatorBase-0e.adoc[`Variant&lowbar;AllocatorBase`] 
| This component&hyphen;private struct keeps track of the allocator for a `bsl&colon;&colon;variant` object&period;
| xref:BloombergLP/bslstl/Variant_ArrayHelper.adoc[`Variant&lowbar;ArrayHelper`] 
| Check whether `t&lowbar;TYPE` is a potential converting&hyphen;constructor match&period;
| xref:BloombergLP/bslstl/Variant_AssignsFromType.adoc[`Variant&lowbar;AssignsFromType`] 
| Determine whether `t&lowbar;TYPE` assigns to a unique alternative of `t&lowbar;VARIANT`&period;
| xref:BloombergLP/bslstl/Variant_Base.adoc[`Variant&lowbar;Base`] 
| Define the data representation and special member functions of `bsl&colon;&colon;variant`&period;
| xref:BloombergLP/bslstl/Variant_CVQualAlt.adoc[`Variant&lowbar;CVQualAlt`] 
| Compute the alternative type at `t&lowbar;INDEX`, with `t&lowbar;VARIANT`&apos;s cv&sol;ref&hyphen;quals&period;
| xref:BloombergLP/bslstl/Variant_CheckForP1957R2-0e0.adoc[`Variant&lowbar;CheckForP1957R2`] 
| This component&hyphen;private metafunction checks whether a conversion from a pointer type to (template parameter) `t&lowbar;TYPE` is narrowing&period;
| xref:BloombergLP/bslstl/Variant_ConstructFromStdTag.adoc[`Variant&lowbar;ConstructFromStdTag`] 
| This component&hyphen;private tag type is used as a parameter type for constructors of `Variant&lowbar;Base` that accept a `std&colon;&colon;variant`&period;
| xref:BloombergLP/bslstl/Variant_ConstructsFromType.adoc[`Variant&lowbar;ConstructsFromType`] 
| Determine whether `t&lowbar;TYPE` constructs a unique alternative of `t&lowbar;VARIANT`&period;
| xref:BloombergLP/bslstl/Variant_ConvertIndex.adoc[`Variant&lowbar;ConvertIndex`] 
| Compute the index of the unique best&hyphen;match alternative, or `npos`&period;
| xref:BloombergLP/bslstl/Variant_ConvertsWithoutNarrowing-0b.adoc[`Variant&lowbar;ConvertsWithoutNarrowing`] 
| Metafunction that is `true&lowbar;type` when `t&lowbar;SOURCE` converts to `t&lowbar;DEST` without narrowing, and `false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_CopyAssignBase-08.adoc[`Variant&lowbar;CopyAssignBase`] 
| This component&hyphen;private class has deleted copy assignment operator if (template parameter) `t&lowbar;ISCOPYASSIGNABLE` is `false`&period;
| xref:BloombergLP/bslstl/Variant_CopyAssignVisitor.adoc[`Variant&lowbar;CopyAssignVisitor`] 
| This component&hyphen;private class is a visitor that is used to implement the copy assignment operator for `bsl&colon;&colon;variant`&period;
| xref:BloombergLP/bslstl/Variant_CopyConstructVisitor.adoc[`Variant&lowbar;CopyConstructVisitor`] 
| This component&hyphen;private class is a visitor that is used to implement the copy constructor for `bsl&colon;&colon;variant`&period;
| xref:BloombergLP/bslstl/Variant_CopyConstructorBase-01.adoc[`Variant&lowbar;CopyConstructorBase`] 
| This component&hyphen;private class has deleted copy constructor if (template parameter) `t&lowbar;ISCOPYCONSTRUCTIBLE` is `false`&period;
| xref:BloombergLP/bslstl/Variant_CorrespondingStdVariant-02.adoc[`Variant&lowbar;CorrespondingStdVariant`] 
| Provide the `std&colon;&colon;variant` type corresponding to `t&lowbar;TYPE`, or `void`&period;
| xref:BloombergLP/bslstl/Variant_CountCVType-03.adoc[`Variant&lowbar;CountCVType`] 
| Count occurrences of `t&lowbar;TYPE` in `t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;`, ignoring cv&hyphen;quals&period;
| xref:BloombergLP/bslstl/Variant_CountType-0d.adoc[`Variant&lowbar;CountType`] 
| Count how many times `t&lowbar;TYPE` occurs among the listed alternatives&period;
| xref:BloombergLP/bslstl/Variant_DataImp.adoc[`Variant&lowbar;DataImp`] 
| This component&hyphen;private class manages an object of type (template parameter) `t&lowbar;TYPE` that is stored in a `variant` object&period;
| xref:BloombergLP/bslstl/Variant_DestructorVisitor.adoc[`Variant&lowbar;DestructorVisitor`] 
| This component&hyphen;private struct is a visitor that destroys the active alternative of the visited `variant` object&period;
| xref:BloombergLP/bslstl/Variant_EqualVisitor.adoc[`Variant&lowbar;EqualVisitor`] 
| Component&hyphen;private visitor for variant `&equals;&equals;` comparison&period;
| xref:BloombergLP/bslstl/Variant_Function-0b.adoc[`Variant&lowbar;Function`] 
| Component&hyphen;private vtable entry invoking a visitor on alternative `t&lowbar;INDEX`&period;
| xref:BloombergLP/bslstl/Variant_FunctionId.adoc[`Variant&lowbar;FunctionId`] 
| Component&hyphen;private vtable entry invoking a tagged visitor on alternative `t&lowbar;INDEX`&period;
| xref:BloombergLP/bslstl/Variant_GreaterOrEqualVisitor.adoc[`Variant&lowbar;GreaterOrEqualVisitor`] 
| Component&hyphen;private visitor for variant `&gt;&equals;` comparison&period;
| xref:BloombergLP/bslstl/Variant_GreaterThanVisitor.adoc[`Variant&lowbar;GreaterThanVisitor`] 
| Component&hyphen;private visitor for variant `&gt;` comparison&period;
| xref:BloombergLP/bslstl/Variant_HasUniqueCVType-06.adoc[`Variant&lowbar;HasUniqueCVType`] 
| Determine whether `t&lowbar;TYPE` occurs exactly once, ignoring cv&hyphen;quals&period;
| xref:BloombergLP/bslstl/Variant_HasUniqueType-0d.adoc[`Variant&lowbar;HasUniqueType`] 
| Determine whether `t&lowbar;TYPE` occurs exactly once in `t&lowbar;VARIANT`&period;
| xref:BloombergLP/bslstl/Variant_HashVisitor.adoc[`Variant&lowbar;HashVisitor`] 
| This component&hyphen;private class is a visitor that is used to implement `hashAppend` for `bsl&colon;&colon;variant`&period;
| xref:BloombergLP/bslstl/Variant_IsAlternativeConstructibleFrom-0e.adoc[`Variant&lowbar;IsAlternativeConstructibleFrom`] 
| Determine whether the unique best&hyphen;match alternative is constructible&period;
| xref:BloombergLP/bslstl/Variant_IsAssignable.adoc[`Variant&lowbar;IsAssignable`] 
| This component&hyphen;private metafunction derives from `std&colon;&colon;is&lowbar;assignable&lt;t&lowbar;LHS, t&lowbar;RHS&gt;` in C&plus;&plus;11 and later, and `bsl&colon;&colon;true&lowbar;type` in C&plus;&plus;03&period;
| xref:BloombergLP/bslstl/Variant_IsBitwiseMoveableAll-0c.adoc[`Variant&lowbar;IsBitwiseMoveableAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template arguments are bitwise moveable, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsConstructible.adoc[`Variant&lowbar;IsConstructible`] 
| Determine whether `t&lowbar;TO` is constructible from `t&lowbar;FROM`&period;
| xref:BloombergLP/bslstl/Variant_IsCopyAssignableAll-0d.adoc[`Variant&lowbar;IsCopyAssignableAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are copy assignable, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsCopyConstructibleAll-03.adoc[`Variant&lowbar;IsCopyConstructibleAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are copy constructible, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsMoveAssignableAll-0e.adoc[`Variant&lowbar;IsMoveAssignableAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are move assignable, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsMoveConstructibleAll-05.adoc[`Variant&lowbar;IsMoveConstructibleAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are move constructible, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsSameReturnType-02.adoc[`Variant&lowbar;IsSameReturnType`] 
| Determine whether `t&lowbar;VISITOR` yields `t&lowbar;RET` for every alternative&period;
| xref:BloombergLP/bslstl/Variant_IsTag-01.adoc[`Variant&lowbar;IsTag`] 
| Determine whether `t&lowbar;TYPE` is a recognized `bsl&colon;&colon;variant` tag type&period;
| xref:BloombergLP/bslstl/Variant_LessOrEqualVisitor.adoc[`Variant&lowbar;LessOrEqualVisitor`] 
| Component&hyphen;private visitor for variant `&lt;&equals;` comparison&period;
| xref:BloombergLP/bslstl/Variant_LessThanVisitor.adoc[`Variant&lowbar;LessThanVisitor`] 
| Component&hyphen;private visitor for variant `&lt;` comparison&period;
| xref:BloombergLP/bslstl/Variant_MoveAssignBase-05.adoc[`Variant&lowbar;MoveAssignBase`] 
| This component&hyphen;private class has deleted move assignment operator if (template parameter) `t&lowbar;ISMOVEASSIGNABLE` is `false`&period;
| xref:BloombergLP/bslstl/Variant_MoveAssignVisitor.adoc[`Variant&lowbar;MoveAssignVisitor`] 
| This component&hyphen;private class is a visitor that is used to implement the move assignment operator for `bsl&colon;&colon;variant`&period;
| xref:BloombergLP/bslstl/Variant_MoveConstructVisitor.adoc[`Variant&lowbar;MoveConstructVisitor`] 
| This component&hyphen;private class is a visitor that is used to implement the move constructor for `bsl&colon;&colon;variant`&period;
| xref:BloombergLP/bslstl/Variant_MoveConstructorBase-01.adoc[`Variant&lowbar;MoveConstructorBase`] 
| This component&hyphen;private class has deleted move constructor if (template parameter) `t&lowbar;ISMOVECONSTRUCTIBLE` is `false`&period;
| xref:BloombergLP/bslstl/Variant_NoSuchType.adoc[`Variant&lowbar;NoSuchType`] 
| This component&hyphen;private trivial tag type is used to distinguish between arguments passed by a user, and an `enable&lowbar;if` argument&period;
| xref:BloombergLP/bslstl/Variant_NotEqualVisitor.adoc[`Variant&lowbar;NotEqualVisitor`] 
| Component&hyphen;private visitor for variant `!&equals;` comparison&period;
| xref:BloombergLP/bslstl/Variant_OverloadHelper-05.adoc[`Variant&lowbar;OverloadHelper`] 
| This component&hyphen;private metafunction provides a member typedef `Index` representing the value that should be computed by `Variant&lowbar;ConvertIndex`&period;
| xref:BloombergLP/bslstl/Variant_OverloadSetImp-07.adoc[`Variant&lowbar;OverloadSetImp`] 
| Compute an overload set of `candidate` functions, one per alternative&period;
| xref:BloombergLP/bslstl/Variant_SMFBase.adoc[`Variant&lowbar;SMFBase`] 
| This component&hyphen;private class has special member functions that are either deleted or defaulted according to the specified template parameters&period;
| xref:BloombergLP/bslstl/Variant_SwapVisitor.adoc[`Variant&lowbar;SwapVisitor`] 
| This component&hyphen;private class is a visitor that is used to implement `bsl&colon;&colon;variant&colon;&colon;swap`&period;
| xref:BloombergLP/bslstl/Variant_TypeToIndex-0d.adoc[`Variant&lowbar;TypeToIndex`] 
| Compute the zero&hyphen;based index of `t&lowbar;TYPE` in `t&lowbar;VARIANT`&apos;s alternatives&period;
| xref:BloombergLP/bslstl/Variant_TypeToIndexImpl-0a.adoc[`Variant&lowbar;TypeToIndexImpl`] 
| Compute `t&lowbar;INDEX &plus; i` where `i` is the index of `t&lowbar;TYPE`, or `npos`&period;
| xref:BloombergLP/bslstl/Variant_Union-0a.adoc[`Variant&lowbar;Union`] 
| This component&hyphen;private union stores a `Variant&lowbar;DataImp` for any alternative&period;
| xref:BloombergLP/bslstl/Variant_UsesBslmaAllocatorAny-0e.adoc[`Variant&lowbar;UsesBslmaAllocatorAny`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if at least one template argument uses an allocator, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_VTable-09.adoc[`Variant&lowbar;VTable`] 
| This component&hyphen;private struct computes an array in which element `i` is a pointer to `Variant&lowbar;Function&lt;t&lowbar;RET, t&lowbar;VISITOR, t&lowbar;VARIANT, i&gt;&colon;&colon;functionImpl`&period;
| xref:BloombergLP/bslstl/Variant_VTableId-05.adoc[`Variant&lowbar;VTableId`] 
| This component&hyphen;private struct computes an array in which element `i` is a pointer to `Variant&lowbar;FunctionId&lt;t&lowbar;RET, t&lowbar;VISITOR, t&lowbar;VARIANT, i&gt;&colon;&colon;functionImpl`&period;
| xref:BloombergLP/bslstl/Variant_isAlternativeAssignableFrom-07.adoc[`Variant&lowbar;isAlternativeAssignableFrom`] 
| Determine whether the unique best&hyphen;match alternative is assignable&period;
| xref:BloombergLP/bslstl/to_chars_result.adoc[`to&lowbar;chars&lowbar;result`] 
| Result type for the `to&lowbar;chars` function&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/Pair_IndexSequence.adoc[`Pair&lowbar;IndexSequence`] 
| Alias for `bslmf&colon;&colon;IntegerSequence` with `std&colon;&colon;size&lowbar;t` elements&period;
| xref:BloombergLP/bslstl/Pair_MakeIndexSequence.adoc[`Pair&lowbar;MakeIndexSequence`] 
| Alias for `bslmf&colon;&colon;MakeIntegerSequence` with `std&colon;&colon;size&lowbar;t` elements&period;
| xref:BloombergLP/bslstl/StringRef.adoc[`StringRef`] 
| This `typedef` is an alias to `StringRefImp&lt;char&gt;`&period;
| xref:BloombergLP/bslstl/StringRefWide.adoc[`StringRefWide`] 
| Wide&hyphen;character string ref type (`StringRefImp&lt;wchar&lowbar;t&gt;`)&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/hashAppend.adoc[`hashAppend`] 
| Pass the specified `input` to the specified `hashAlg`
| xref:BloombergLP/bslstl/operator_plus-04.adoc[`operator&plus;`] 
| Addition operators
| xref:BloombergLP/bslstl/operator_inc-0e.adoc[`operator&plus;&plus;`] 
| Increment operators
| xref:BloombergLP/bslstl/operator_minus-08.adoc[`operator&hyphen;`] 
| Subtraction operators
| xref:BloombergLP/bslstl/operator_dec-00.adoc[`operator&hyphen;&hyphen;`] 
| Decrement operators
| xref:BloombergLP/bslstl/operator_rshift.adoc[`operator&gt;&gt;`] 
| Read a quoted string from the specified `input` stream into `object`&period;
| xref:BloombergLP/bslstl/optional_acceptsBslOptional.adoc[`optional&lowbar;acceptsBslOptional`] 
| Component&hyphen;private constraint helper for `Optional&lowbar;DerivedFromBslOptional`&period;
| xref:BloombergLP/bslstl/optional_acceptsStdOptional.adoc[`optional&lowbar;acceptsStdOptional`] 
| Component&hyphen;private constraint helper for `Optional&lowbar;DerivedFromStdOptional`&period;
| xref:BloombergLP/bslstl/swap-010.adoc[`swap`] 
| `swap` overloads
| xref:BloombergLP/bslstl/to_chars.adoc[`to&lowbar;chars`] 
| Write the specified `value` into the character buffer `&lsqb;first, last)&rsqb;`&period;
| xref:BloombergLP/bslstl/variant_swapImpl-0a2.adoc[`variant&lowbar;swapImpl`] 
| `variant&lowbar;swapImpl` overloads
| xref:BloombergLP/bslstl/operator_lshift-02.adoc[`operator&lt;&lt;`] 
| Write the value of the specified `object` to the specified `output` stream&period;
| xref:BloombergLP/bslstl/operator_eq-0c1.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:BloombergLP/bslstl/operator_not_eq-0ac.adoc[`operator!&equals;`] 
| Inequality operators
| xref:BloombergLP/bslstl/operator_lt.adoc[`operator&lt;`] 
| Return `true` if `lhs` precedes `rhs` in the iteration sequence&period;
| xref:BloombergLP/bslstl/operator_le.adoc[`operator&lt;&equals;`] 
| Return `true` if `lhs` precedes or equals `rhs` in the iteration sequence&period;
| xref:BloombergLP/bslstl/operator_gt.adoc[`operator&gt;`] 
| Return `true` if `lhs` follows `rhs` in the iteration sequence&period;
| xref:BloombergLP/bslstl/operator_ge.adoc[`operator&gt;&equals;`] 
| Return `true` if `lhs` follows or equals `rhs` in the iteration sequence&period;
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/variant_constructsFromStd.adoc[`variant&lowbar;constructsFromStd`] 
| Determine whether `t&lowbar;VARIANT` is constructible from `t&lowbar;STD&lowbar;VARIANT`&period;
|===


== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/IteratorUtil_ModernIterator.adoc[`IteratorUtil&lowbar;ModernIterator`] 
| Concept identifying iterators that expose an `iterator&lowbar;concept` type&period;
| xref:BloombergLP/bslstl/Optional_ConvertibleToBool.adoc[`Optional&lowbar;ConvertibleToBool`] 
| Component&hyphen;private concept modeling the exposition&hyphen;only `boolean&hyphen;testable` concept&period;
| xref:BloombergLP/bslstl/Optional_DerivedFromBslOptional.adoc[`Optional&lowbar;DerivedFromBslOptional`] 
| Component&hyphen;private concept that is satisfied when `t&lowbar;TYPE` derives from `bsl&colon;&colon;optional`&period;
| xref:BloombergLP/bslstl/Optional_DerivedFromOptional.adoc[`Optional&lowbar;DerivedFromOptional`] 
| This component&hyphen;private concept models whether a type is derived from one of `std&colon;&colon;optional` or `bsl&colon;&colon;optional`&period;
| xref:BloombergLP/bslstl/Optional_DerivedFromStdOptional.adoc[`Optional&lowbar;DerivedFromStdOptional`] 
| Component&hyphen;private concept that is satisfied when `t&lowbar;TYPE` derives from `std&colon;&colon;optional`&period;
|===



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