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

Implementation details for `basic_syncbuf` and related stream types.

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/AlgorithmUtil.adoc[`AlgorithmUtil`] 
| Provide a namespace for implementing helper routines for algorithm implementations.
| xref:BloombergLP/bslstl/BadWeakPtr.adoc[`BadWeakPtr`] 
| Exception type thrown when a `weak_ptr` is locked after its managed object is destroyed.
| xref:BloombergLP/bslstl/BidirectionalIterator.adoc[`BidirectionalIterator`] 
| Adaptor that produces a standard bidirectional iterator from a core type.
| xref:BloombergLP/bslstl/BidirectionalNodePool.adoc[`BidirectionalNodePool`] 
| This class provides methods for creating and destroying nodes using the appropriate allocator‐traits of the (template parameter) type `ALLOCATOR`.
| xref:BloombergLP/bslstl/BoyerMooreHorspoolSearcher.adoc[`BoyerMooreHorspoolSearcher`] 
| STL‐compliant searcher using the Boyer‐Moore‐Horspool algorithm.
| xref:BloombergLP/bslstl/BoyerMooreHorspoolSearcher_CharImp.adoc[`BoyerMooreHorspoolSearcher_CharImp`] 
| Char‐optimized Boyer‐Moore‐Horspool searcher implementation.
| xref:BloombergLP/bslstl/BoyerMooreHorspoolSearcher_GeneralImp.adoc[`BoyerMooreHorspoolSearcher_GeneralImp`] 
| This class template implements the same interfaces as the `BoyerMooreHorspoolSearcher_CharImp` for arbitrary `value_type`.
| xref:BloombergLP/bslstl/CallableVariable.adoc[`CallableVariable`] 
| Metafunction aliasing `CALLABLE`, or `CALLABLE &` for function types.
| xref:BloombergLP/bslstl/DefaultSearcher.adoc[`DefaultSearcher`] 
| Searcher functor using a naive sequential search for a fixed needle.
| xref:BloombergLP/bslstl/DefaultSearcher_CanOptimize.adoc[`DefaultSearcher_CanOptimize`] 
| Trait indicating whether the default searcher can use an optimized path.
| xref:BloombergLP/bslstl/ForwardIterator.adoc[`ForwardIterator`] 
| STL‐compliant forward iterator adapted from a minimal implementation.
| xref:BloombergLP/bslstl/Function_ArgTypes-06.adoc[`Function_ArgTypes`] 
| Component‐private metafunction providing nested argument typedefs for `bsl::function`.
| xref:BloombergLP/bslstl/Function_InvokerUtil.adoc[`Function_InvokerUtil`] 
| Namespace for looking up an invoker for a given callable type.
| xref:BloombergLP/bslstl/Function_InvokerUtilNullCheck-03.adoc[`Function_InvokerUtilNullCheck`] 
| Customization point that detects whether a `FUNC` callable is null.
| xref:BloombergLP/bslstl/Function_InvokerUtil_Dispatch-09a.adoc[`Function_InvokerUtil_Dispatch`] 
| Dispatcher that invokes a callable of category `INVOCATION_TYPE`.
| xref:BloombergLP/bslstl/Function_InvokerUtil_ForwardType.adoc[`Function_InvokerUtil_ForwardType`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_ForwardTypeImp-01.adoc[`Function_InvokerUtil_ForwardTypeImp`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_IsExplicitlyConvertible-0c.adoc[`Function_InvokerUtil_IsExplicitlyConvertible`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_IsExplicitlyConvertibleImp-0d.adoc[`Function_InvokerUtil_IsExplicitlyConvertibleImp`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_IsFuncInvocable-05.adoc[`Function_InvokerUtil_IsFuncInvocable`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_IsFuncInvocableImp-03.adoc[`Function_InvokerUtil_IsFuncInvocableImp`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_ResultType.adoc[`Function_InvokerUtil_ResultType`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_InvokerUtil_ResultTypeImp-02.adoc[`Function_InvokerUtil_ResultTypeImp`] 
| forward declaration
| xref:BloombergLP/bslstl/Function_IsInvocableWithPrototype-06.adoc[`Function_IsInvocableWithPrototype`] 
| Forward declaration of the invocability metafunction for `bsl::function`.
| xref:BloombergLP/bslstl/Function_IsReferenceCompatible-0c.adoc[`Function_IsReferenceCompatible`] 
| Metafunction that is `true_type` if a reference to `FROM_TYPE` can substitute for a reference to `TO_TYPE`.
| xref:BloombergLP/bslstl/Function_Rep.adoc[`Function_Rep`] 
| This is a component‐private class. Do not use.
| xref:BloombergLP/bslstl/Function_SmallObjectOptimization.adoc[`Function_SmallObjectOptimization`] 
| Utility types and constants for `bsl::function` small‐object optimization.
| xref:BloombergLP/bslstl/Function_Variadic-0e.adoc[`Function_Variadic`] 
| This component‐private class template contains the physical representation and provides the variadic interfaces for `bsl::function`.
| xref:BloombergLP/bslstl/HashTable.adoc[`HashTable`] 
| Value‐semantic unordered container of keyed elements.
| xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[`HashTableBucketIterator`] 
| Standard‐conforming forward iterator over a single hash‐table bucket.
| xref:BloombergLP/bslstl/HashTableIterator.adoc[`HashTableIterator`] 
| STL‐conforming forward iterator over hash‐table node lists.
| xref:BloombergLP/bslstl/HashTable_ArrayProctor.adoc[`HashTable_ArrayProctor`] 
| This class probably already exists in `bslalg`
| xref:BloombergLP/bslstl/HashTable_BaseHasher.adoc[`HashTable_BaseHasher`] 
| This `struct` adapts the (template parameter) `HASHER` type for use as the base hasher of a `HashTable`.
| xref:BloombergLP/bslstl/HashTable_Comparator.adoc[`HashTable_Comparator`] 
| Comparator adapter used by `HashTable`.
| xref:BloombergLP/bslstl/HashTable_ComparatorWrapper-0e.adoc[`HashTable_ComparatorWrapper`] 
| Wrapper ensuring a comparator's call operator is const‐qualified.
| xref:BloombergLP/bslstl/HashTable_HashWrapper-03.adoc[`HashTable_HashWrapper`] 
| Wrapper ensuring a hash functor's call operator is const‐qualified.
| xref:BloombergLP/bslstl/HashTable_NodeProctor.adoc[`HashTable_NodeProctor`] 
| Proctor that deletes a managed node unless `release` is called.
| xref:BloombergLP/bslstl/HashTable_Util.adoc[`HashTable_Util`] 
| Utilities for initializing and destroying `HashTable` bucket arrays.
| xref:BloombergLP/bslstl/IoManip_QuotedStringFormatter.adoc[`IoManip_QuotedStringFormatter`] 
| Temporary proxy for quoting a `bsl::basic_string` in stream I/O.
| xref:BloombergLP/bslstl/IoManip_QuotedStringViewFormatter.adoc[`IoManip_QuotedStringViewFormatter`] 
| Temporary proxy for quoting a `bsl::basic_string_view` for stream output.
| xref:BloombergLP/bslstl/IsConvertibleToCString-04.adoc[`IsConvertibleToCString`] 
| This `struct` template implements a meta‐function to determine if the (template parameter) `t_TYPE` is convertible to `const t_CHAR_TYPE *`.
| xref:BloombergLP/bslstl/IsConvertibleToStringView-02.adoc[`IsConvertibleToStringView`] 
| Meta‐function for detecting types convertible to a string view.
| xref:BloombergLP/bslstl/IteratorUtil.adoc[`IteratorUtil`] 
| This utility struct provides a namespace for functions on iterators and iterator ranges.
| xref:BloombergLP/bslstl/IteratorUtil_LegacyInsertDistance-03.adoc[`IteratorUtil_LegacyInsertDistance`] 
| Utility for type‐based dispatch of insert‐distance calculation.
| xref:BloombergLP/bslstl/MapComparator.adoc[`MapComparator`] 
| This class compares map keys with `TreeNode` objects using `COMPARATOR`.
| xref:BloombergLP/bslstl/Optional_Base-05.adoc[`Optional_Base`] 
| Component‐private class template implementing `bsl::optional`.
| xref:BloombergLP/bslstl/Optional_ConstructFromForwardRef.adoc[`Optional_ConstructFromForwardRef`] 
| Tag type selecting construction from a forwarding reference.
| xref:BloombergLP/bslstl/Optional_ConstructsFromType.adoc[`Optional_ConstructsFromType`] 
| Metafunction detecting constructibility from a non‐optional type.
| xref:BloombergLP/bslstl/Optional_CopyConstructFromOtherOptional.adoc[`Optional_CopyConstructFromOtherOptional`] 
| Tag type selecting copy construction from another `optional`.
| xref:BloombergLP/bslstl/Optional_CopyConstructFromStdOptional.adoc[`Optional_CopyConstructFromStdOptional`] 
| Tag type selecting copy construction from a `std::optional`.
| xref:BloombergLP/bslstl/Optional_Data-0c.adoc[`Optional_Data`] 
| Component‐private storage that destroys a non‐trivial contained value.
| xref:BloombergLP/bslstl/Optional_DataImp.adoc[`Optional_DataImp`] 
| Component‐private buffer managing an optional's contained value.
| xref:BloombergLP/bslstl/Optional_ImmovableHelper.adoc[`Optional_ImmovableHelper`] 
| Helper enabling in‐place construction of immovable values.
| xref:BloombergLP/bslstl/Optional_InvokeConstructorTag.adoc[`Optional_InvokeConstructorTag`] 
| Constructor tag used to implement the `transform` function.
| xref:BloombergLP/bslstl/Optional_IsBslOptional-07.adoc[`Optional_IsBslOptional`] 
| Metafunction that is `false_type` for types that are not `bsl::optional`.
| xref:BloombergLP/bslstl/Optional_IsTriviallyDestructible.adoc[`Optional_IsTriviallyDestructible`] 
| This metafunction is derived from `std::is_trivially_destructible<t_TYPE>` in C++11 and later.
| xref:BloombergLP/bslstl/Optional_MoveConstructFromOtherOptional.adoc[`Optional_MoveConstructFromOtherOptional`] 
| Tag type selecting move construction from another `optional`.
| xref:BloombergLP/bslstl/Optional_MoveConstructFromStdOptional.adoc[`Optional_MoveConstructFromStdOptional`] 
| Tag type selecting move construction from a `std::optional`.
| xref:BloombergLP/bslstl/Optional_NulloptConstructToken.adoc[`Optional_NulloptConstructToken`] 
| This trivial tag type is used to create `nullopt_t` objects prior to C++17.
| xref:BloombergLP/bslstl/Optional_OptNoSuchType.adoc[`Optional_OptNoSuchType`] 
| Tag type distinguishing user arguments from `enable_if` defaults.
| xref:BloombergLP/bslstl/Optional_PropagatesAllocator.adoc[`Optional_PropagatesAllocator`] 
| Metafunction detecting allocator propagation for const value types.
| xref:BloombergLP/bslstl/Pair_GetImpUtil-0f.adoc[`Pair_GetImpUtil`] 
| This utility class template provides functions for selecting the element of pair, returned from `bsl::get(bsl::pair<T1, T2>)`, by its index.
| xref:BloombergLP/bslstl/Pair_IndexOfType-02.adoc[`Pair_IndexOfType`] 
| Metafunction giving the index of the pair element having type `T`.
| xref:BloombergLP/bslstl/RandomAccessIterator.adoc[`RandomAccessIterator`] 
| STL‐compliant random‐access iterator adapted from a minimal implementation.
| xref:BloombergLP/bslstl/SetComparator.adoc[`SetComparator`] 
| Comparator for `TreeNode` objects and lookup keys.
| xref:BloombergLP/bslstl/SharedPtrAllocateInplaceRep.adoc[`SharedPtrAllocateInplaceRep`] 
| In‐place `SharedPtrRep` implementation for a managed object of `TYPE`.
| xref:BloombergLP/bslstl/SharedPtrAllocateOutofplaceRep.adoc[`SharedPtrAllocateOutofplaceRep`] 
| Out‐of‐place concrete implementation of the `SharedPtrRep` protocol.
| xref:BloombergLP/bslstl/SharedPtrAllocateOutofplaceRep_InitProctor.adoc[`SharedPtrAllocateOutofplaceRep_InitProctor`] 
| Proctor that deletes a pointer if out‐of‐place rep construction fails.
| xref:BloombergLP/bslstl/SharedPtrArrayAllocateInplaceRep.adoc[`SharedPtrArrayAllocateInplaceRep`] 
| In‐place `SharedPtrRep` implementation for a managed array of `TYPE`.
| xref:BloombergLP/bslstl/SharedPtrNilDeleter.adoc[`SharedPtrNilDeleter`] 
| This `struct` provides a function‐like shared pointer deleter that does nothing when invoked.
| xref:BloombergLP/bslstl/SharedPtrUtil.adoc[`SharedPtrUtil`] 
| This `struct` provides a namespace for operations on shared pointers.
| xref:BloombergLP/bslstl/SharedPtr_DefaultDeleter-06.adoc[`SharedPtr_DefaultDeleter`] 
| Function‐like deleter that deletes a pointer with `delete` or `delete[]`.
| xref:BloombergLP/bslstl/SharedPtr_IsCallable.adoc[`SharedPtr_IsCallable`] 
| Trait detecting whether `FUNCTOR` is callable with `ARG`.
| xref:BloombergLP/bslstl/SharedPtr_IsFactoryFor.adoc[`SharedPtr_IsFactoryFor`] 
| Trait detecting whether `FACTORY` can delete an `ARG` object.
| xref:BloombergLP/bslstl/SharedPtr_IsNullableFactory.adoc[`SharedPtr_IsNullableFactory`] 
| Trait detecting whether `FACTORY` accepts a null pointer in `deleteObject`.
| xref:BloombergLP/bslstl/SharedPtr_IsPointerCompatible.adoc[`SharedPtr_IsPointerCompatible`] 
| Trait detecting compatibility of `SOURCE_TYPE *` with `DEST_TYPE *`.
| xref:BloombergLP/bslstl/SharedPtr_IsPointerConvertible.adoc[`SharedPtr_IsPointerConvertible`] 
| Trait detecting convertibility of `SOURCE_TYPE *` to `DEST_TYPE *`.
| xref:BloombergLP/bslstl/SharedPtr_RepFromExistingSharedPtr.adoc[`SharedPtr_RepFromExistingSharedPtr`] 
| Tag type identifying a `SharedPtrRep` from an existing `shared_ptr`.
| xref:BloombergLP/bslstl/SharedPtr_RepProctor.adoc[`SharedPtr_RepProctor`] 
| Proctor that disposes a `SharedPtrRep` unless `release` is called.
| xref:BloombergLP/bslstl/SharedPtr_TestIsCallable.adoc[`SharedPtr_TestIsCallable`] 
| SFINAE helper that probes whether `FUNCTOR` is callable with an argument.
| xref:BloombergLP/bslstl/SimplePool.adoc[`SimplePool`] 
| Memory pool that allocates blocks of a fixed value type.
| xref:BloombergLP/bslstl/SimplePool_Type.adoc[`SimplePool_Type`] 
| Provide type aliases for a maximally aligned `SimplePool` base class.
| xref:BloombergLP/bslstl/StdExceptUtil.adoc[`StdExceptUtil`] 
| This `struct` provides a namespace for `static` utility functions that throw standard library exceptions.
| xref:BloombergLP/bslstl/StopCallback_CallbackStorage-06.adoc[`StopCallback_CallbackStorage`] 
| Stores a non‐reference `t_CALLBACK` object for stop callbacks.
| xref:BloombergLP/bslstl/StopCallback_NoAlloc.adoc[`StopCallback_NoAlloc`] 
| This component‐private empty class is used as a dummy "allocator" when `bsl::stop_callback` wraps a non‐allocator‐aware type.
| xref:BloombergLP/bslstl/StopCallback_Node.adoc[`StopCallback_Node`] 
| Component‐private node storing a stop callback for `StopState`.
| xref:BloombergLP/bslstl/StopState.adoc[`StopState`] 
| Shared stop state that tracks a stop request and registered callbacks.
| xref:BloombergLP/bslstl/StopStateCallbackNode.adoc[`StopStateCallbackNode`] 
| Intrusive list node that stores a registered stop‐callback invocation.
| xref:BloombergLP/bslstl/StopState_ListNode.adoc[`StopState_ListNode`] 
| This component‐private class represents a node in a doubly‐linked list.
| xref:BloombergLP/bslstl/StopToken_RefCountedState.adoc[`StopToken_RefCountedState`] 
| Component‐private `StopState` with a `stop_source` reference count.
| xref:BloombergLP/bslstl/StringRefData-04.adoc[`StringRefData`] 
| This class is an intermediate link between `bslstl::StringRef` used in BDE and `bsl::string_view` and is kept only for compatibility with legacy code.
| xref:BloombergLP/bslstl/StringRefImp-0c.adoc[`StringRefImp`] 
| Provide a non‐owning reference to a contiguous character sequence.
| xref:BloombergLP/bslstl/StringRefImp_CompareUtil.adoc[`StringRefImp_CompareUtil`] 
| [*PRIVATE*]This class provides a namespace for private comparison implementation functions.
| xref:BloombergLP/bslstl/SyncBufBase.adoc[`SyncBufBase`] 
| Allocator‐independent base of `basic_syncbuf`.
| xref:BloombergLP/bslstl/SyncBufBaseUtil.adoc[`SyncBufBaseUtil`] 
| Internal utils.
| xref:BloombergLP/bslstl/TreeIterator.adoc[`TreeIterator`] 
| STL‐conforming bidirectional iterator over ordered tree nodes.
| xref:BloombergLP/bslstl/TreeNode.adoc[`TreeNode`] 
| POD‐like node for a red‐black tree of parameterized `VALUE` objects.
| xref:BloombergLP/bslstl/TreeNodePool.adoc[`TreeNodePool`] 
| Memory manager that creates and deletes nodes for tree‐based containers.
| xref:BloombergLP/bslstl/UnorderedMapKeyConfiguration.adoc[`UnorderedMapKeyConfiguration`] 
| This `struct` provides a namespace for key‐configuration utilities used by `bsl::unordered_map` to extract keys from stored value objects.
| xref:BloombergLP/bslstl/UnorderedSetKeyConfiguration.adoc[`UnorderedSetKeyConfiguration`] 
| The `UnorderedSetKeyConfiguration` type.
| xref:BloombergLP/bslstl/Variant_AllocatorBase-0e.adoc[`Variant_AllocatorBase`] 
| This component‐private struct keeps track of the allocator for a `bsl::variant` object.
| xref:BloombergLP/bslstl/Variant_ArrayHelper.adoc[`Variant_ArrayHelper`] 
| Check whether `t_TYPE` is a potential converting‐constructor match.
| xref:BloombergLP/bslstl/Variant_AssignsFromType.adoc[`Variant_AssignsFromType`] 
| Determine whether `t_TYPE` assigns to a unique alternative of `t_VARIANT`.
| xref:BloombergLP/bslstl/Variant_Base.adoc[`Variant_Base`] 
| Define the data representation and special member functions of `bsl::variant`.
| xref:BloombergLP/bslstl/Variant_CVQualAlt.adoc[`Variant_CVQualAlt`] 
| Compute the alternative type at `t_INDEX`, with `t_VARIANT`'s cv/ref‐quals.
| xref:BloombergLP/bslstl/Variant_CheckForP1957R2-0e0.adoc[`Variant_CheckForP1957R2`] 
| This component‐private metafunction checks whether a conversion from a pointer type to (template parameter) `t_TYPE` is narrowing.
| xref:BloombergLP/bslstl/Variant_ConstructFromStdTag.adoc[`Variant_ConstructFromStdTag`] 
| This component‐private tag type is used as a parameter type for constructors of `Variant_Base` that accept a `std::variant`.
| xref:BloombergLP/bslstl/Variant_ConstructsFromType.adoc[`Variant_ConstructsFromType`] 
| Determine whether `t_TYPE` constructs a unique alternative of `t_VARIANT`.
| xref:BloombergLP/bslstl/Variant_ConvertIndex.adoc[`Variant_ConvertIndex`] 
| Compute the index of the unique best‐match alternative, or `npos`.
| xref:BloombergLP/bslstl/Variant_ConvertsWithoutNarrowing-0b.adoc[`Variant_ConvertsWithoutNarrowing`] 
| Metafunction that is `true_type` when `t_SOURCE` converts to `t_DEST` without narrowing, and `false_type` otherwise.
| xref:BloombergLP/bslstl/Variant_CopyAssignBase-08.adoc[`Variant_CopyAssignBase`] 
| This component‐private class has deleted copy assignment operator if (template parameter) `t_ISCOPYASSIGNABLE` is `false`.
| xref:BloombergLP/bslstl/Variant_CopyAssignVisitor.adoc[`Variant_CopyAssignVisitor`] 
| This component‐private class is a visitor that is used to implement the copy assignment operator for `bsl::variant`.
| xref:BloombergLP/bslstl/Variant_CopyConstructVisitor.adoc[`Variant_CopyConstructVisitor`] 
| This component‐private class is a visitor that is used to implement the copy constructor for `bsl::variant`.
| xref:BloombergLP/bslstl/Variant_CopyConstructorBase-01.adoc[`Variant_CopyConstructorBase`] 
| This component‐private class has deleted copy constructor if (template parameter) `t_ISCOPYCONSTRUCTIBLE` is `false`.
| xref:BloombergLP/bslstl/Variant_CorrespondingStdVariant-02.adoc[`Variant_CorrespondingStdVariant`] 
| Provide the `std::variant` type corresponding to `t_TYPE`, or `void`.
| xref:BloombergLP/bslstl/Variant_CountCVType-03.adoc[`Variant_CountCVType`] 
| Count occurrences of `t_TYPE` in `t_HEAD, t_TAIL...`, ignoring cv‐quals.
| xref:BloombergLP/bslstl/Variant_CountType-0d.adoc[`Variant_CountType`] 
| Count how many times `t_TYPE` occurs among the listed alternatives.
| xref:BloombergLP/bslstl/Variant_DataImp.adoc[`Variant_DataImp`] 
| This component‐private class manages an object of type (template parameter) `t_TYPE` that is stored in a `variant` object.
| xref:BloombergLP/bslstl/Variant_DestructorVisitor.adoc[`Variant_DestructorVisitor`] 
| This component‐private struct is a visitor that destroys the active alternative of the visited `variant` object.
| xref:BloombergLP/bslstl/Variant_EqualVisitor.adoc[`Variant_EqualVisitor`] 
| Component‐private visitor for variant `==` comparison.
| xref:BloombergLP/bslstl/Variant_Function-0b.adoc[`Variant_Function`] 
| Component‐private vtable entry invoking a visitor on alternative `t_INDEX`.
| xref:BloombergLP/bslstl/Variant_FunctionId.adoc[`Variant_FunctionId`] 
| Component‐private vtable entry invoking a tagged visitor on alternative `t_INDEX`.
| xref:BloombergLP/bslstl/Variant_GreaterOrEqualVisitor.adoc[`Variant_GreaterOrEqualVisitor`] 
| Component‐private visitor for variant `>=` comparison.
| xref:BloombergLP/bslstl/Variant_GreaterThanVisitor.adoc[`Variant_GreaterThanVisitor`] 
| Component‐private visitor for variant `>` comparison.
| xref:BloombergLP/bslstl/Variant_HasUniqueCVType-06.adoc[`Variant_HasUniqueCVType`] 
| Determine whether `t_TYPE` occurs exactly once, ignoring cv‐quals.
| xref:BloombergLP/bslstl/Variant_HasUniqueType-0d.adoc[`Variant_HasUniqueType`] 
| Determine whether `t_TYPE` occurs exactly once in `t_VARIANT`.
| xref:BloombergLP/bslstl/Variant_HashVisitor.adoc[`Variant_HashVisitor`] 
| This component‐private class is a visitor that is used to implement `hashAppend` for `bsl::variant`.
| xref:BloombergLP/bslstl/Variant_IsAlternativeConstructibleFrom-0e.adoc[`Variant_IsAlternativeConstructibleFrom`] 
| Determine whether the unique best‐match alternative is constructible.
| xref:BloombergLP/bslstl/Variant_IsAssignable.adoc[`Variant_IsAssignable`] 
| This component‐private metafunction derives from `std::is_assignable<t_LHS, t_RHS>` in C++11 and later, and `bsl::true_type` in C++03.
| xref:BloombergLP/bslstl/Variant_IsBitwiseMoveableAll-0c.adoc[`Variant_IsBitwiseMoveableAll`] 
| This component‐private metafunction is derived from `bsl::true_type` if all template arguments are bitwise moveable, and from `bsl::false_type` otherwise.
| xref:BloombergLP/bslstl/Variant_IsConstructible.adoc[`Variant_IsConstructible`] 
| Determine whether `t_TO` is constructible from `t_FROM`.
| xref:BloombergLP/bslstl/Variant_IsCopyAssignableAll-0d.adoc[`Variant_IsCopyAssignableAll`] 
| This component‐private metafunction is derived from `bsl::true_type` if all template parameters are copy assignable, and `bsl::false_type` otherwise.
| xref:BloombergLP/bslstl/Variant_IsCopyConstructibleAll-03.adoc[`Variant_IsCopyConstructibleAll`] 
| This component‐private metafunction is derived from `bsl::true_type` if all template parameters are copy constructible, and `bsl::false_type` otherwise.
| xref:BloombergLP/bslstl/Variant_IsMoveAssignableAll-0e.adoc[`Variant_IsMoveAssignableAll`] 
| This component‐private metafunction is derived from `bsl::true_type` if all template parameters are move assignable, and `bsl::false_type` otherwise.
| xref:BloombergLP/bslstl/Variant_IsMoveConstructibleAll-05.adoc[`Variant_IsMoveConstructibleAll`] 
| This component‐private metafunction is derived from `bsl::true_type` if all template parameters are move constructible, and `bsl::false_type` otherwise.
| xref:BloombergLP/bslstl/Variant_IsSameReturnType-02.adoc[`Variant_IsSameReturnType`] 
| Determine whether `t_VISITOR` yields `t_RET` for every alternative.
| xref:BloombergLP/bslstl/Variant_IsTag-01.adoc[`Variant_IsTag`] 
| Determine whether `t_TYPE` is a recognized `bsl::variant` tag type.
| xref:BloombergLP/bslstl/Variant_LessOrEqualVisitor.adoc[`Variant_LessOrEqualVisitor`] 
| Component‐private visitor for variant `<=` comparison.
| xref:BloombergLP/bslstl/Variant_LessThanVisitor.adoc[`Variant_LessThanVisitor`] 
| Component‐private visitor for variant `<` comparison.
| xref:BloombergLP/bslstl/Variant_MoveAssignBase-05.adoc[`Variant_MoveAssignBase`] 
| This component‐private class has deleted move assignment operator if (template parameter) `t_ISMOVEASSIGNABLE` is `false`.
| xref:BloombergLP/bslstl/Variant_MoveAssignVisitor.adoc[`Variant_MoveAssignVisitor`] 
| This component‐private class is a visitor that is used to implement the move assignment operator for `bsl::variant`.
| xref:BloombergLP/bslstl/Variant_MoveConstructVisitor.adoc[`Variant_MoveConstructVisitor`] 
| This component‐private class is a visitor that is used to implement the move constructor for `bsl::variant`.
| xref:BloombergLP/bslstl/Variant_MoveConstructorBase-01.adoc[`Variant_MoveConstructorBase`] 
| This component‐private class has deleted move constructor if (template parameter) `t_ISMOVECONSTRUCTIBLE` is `false`.
| xref:BloombergLP/bslstl/Variant_NoSuchType.adoc[`Variant_NoSuchType`] 
| This component‐private trivial tag type is used to distinguish between arguments passed by a user, and an `enable_if` argument.
| xref:BloombergLP/bslstl/Variant_NotEqualVisitor.adoc[`Variant_NotEqualVisitor`] 
| Component‐private visitor for variant `!=` comparison.
| xref:BloombergLP/bslstl/Variant_OverloadHelper-05.adoc[`Variant_OverloadHelper`] 
| This component‐private metafunction provides a member typedef `Index` representing the value that should be computed by `Variant_ConvertIndex`.
| xref:BloombergLP/bslstl/Variant_OverloadSetImp-07.adoc[`Variant_OverloadSetImp`] 
| Compute an overload set of `candidate` functions, one per alternative.
| xref:BloombergLP/bslstl/Variant_SMFBase.adoc[`Variant_SMFBase`] 
| This component‐private class has special member functions that are either deleted or defaulted according to the specified template parameters.
| xref:BloombergLP/bslstl/Variant_SwapVisitor.adoc[`Variant_SwapVisitor`] 
| This component‐private class is a visitor that is used to implement `bsl::variant::swap`.
| xref:BloombergLP/bslstl/Variant_TypeToIndex-0d.adoc[`Variant_TypeToIndex`] 
| Compute the zero‐based index of `t_TYPE` in `t_VARIANT`'s alternatives.
| xref:BloombergLP/bslstl/Variant_TypeToIndexImpl-0a.adoc[`Variant_TypeToIndexImpl`] 
| Compute `t_INDEX + i` where `i` is the index of `t_TYPE`, or `npos`.
| xref:BloombergLP/bslstl/Variant_Union-0a.adoc[`Variant_Union`] 
| This component‐private union stores a `Variant_DataImp` for any alternative.
| xref:BloombergLP/bslstl/Variant_UsesBslmaAllocatorAny-0e.adoc[`Variant_UsesBslmaAllocatorAny`] 
| This component‐private metafunction is derived from `bsl::true_type` if at least one template argument uses an allocator, and from `bsl::false_type` otherwise.
| xref:BloombergLP/bslstl/Variant_VTable-09.adoc[`Variant_VTable`] 
| This component‐private struct computes an array in which element `i` is a pointer to `Variant_Function<t_RET, t_VISITOR, t_VARIANT, i>::functionImpl`.
| xref:BloombergLP/bslstl/Variant_VTableId-05.adoc[`Variant_VTableId`] 
| This component‐private struct computes an array in which element `i` is a pointer to `Variant_FunctionId<t_RET, t_VISITOR, t_VARIANT, i>::functionImpl`.
| xref:BloombergLP/bslstl/Variant_isAlternativeAssignableFrom-07.adoc[`Variant_isAlternativeAssignableFrom`] 
| Determine whether the unique best‐match alternative is assignable.
| xref:BloombergLP/bslstl/to_chars_result.adoc[`to_chars_result`] 
| Result type for the `to_chars` function.
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/Pair_IndexSequence.adoc[`Pair_IndexSequence`] 
| Alias for `bslmf::IntegerSequence` with `std::size_t` elements.
| xref:BloombergLP/bslstl/Pair_MakeIndexSequence.adoc[`Pair_MakeIndexSequence`] 
| Alias for `bslmf::MakeIntegerSequence` with `std::size_t` elements.
| xref:BloombergLP/bslstl/StringRef.adoc[`StringRef`] 
| This `typedef` is an alias to `StringRefImp<char>`.
| xref:BloombergLP/bslstl/StringRefWide.adoc[`StringRefWide`] 
| Wide‐character string ref type (`StringRefImp<wchar_t>`).
|===


== 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+`] 
| Addition operators
| xref:BloombergLP/bslstl/operator_inc-0e.adoc[`operator++`] 
| Increment operators
| xref:BloombergLP/bslstl/operator_minus-08.adoc[`operator‐`] 
| Subtraction operators
| xref:BloombergLP/bslstl/operator_dec-00.adoc[`operator‐‐`] 
| Decrement operators
| xref:BloombergLP/bslstl/operator_rshift.adoc[`operator>>`] 
| Read a quoted string from the specified `input` stream into `object`.
| xref:BloombergLP/bslstl/optional_acceptsBslOptional.adoc[`optional_acceptsBslOptional`] 
| Component‐private constraint helper for `Optional_DerivedFromBslOptional`.
| xref:BloombergLP/bslstl/optional_acceptsStdOptional.adoc[`optional_acceptsStdOptional`] 
| Component‐private constraint helper for `Optional_DerivedFromStdOptional`.
| xref:BloombergLP/bslstl/swap-010.adoc[`swap`] 
| `swap` overloads
| xref:BloombergLP/bslstl/to_chars.adoc[`to_chars`] 
| Write the specified `value` into the character buffer `[first, last)]`.
| xref:BloombergLP/bslstl/variant_swapImpl-0a2.adoc[`variant_swapImpl`] 
| `variant_swapImpl` overloads
| xref:BloombergLP/bslstl/operator_lshift-02.adoc[`operator<<`] 
| Write the value of the specified `object` to the specified `output` stream.
| xref:BloombergLP/bslstl/operator_eq-0c1.adoc[`operator==`] 
| Equality operators
| xref:BloombergLP/bslstl/operator_not_eq-0ac.adoc[`operator!=`] 
| Inequality operators
| xref:BloombergLP/bslstl/operator_lt.adoc[`operator<`] 
| Return `true` if `lhs` precedes `rhs` in the iteration sequence.
| xref:BloombergLP/bslstl/operator_le.adoc[`operator<=`] 
| Return `true` if `lhs` precedes or equals `rhs` in the iteration sequence.
| xref:BloombergLP/bslstl/operator_gt.adoc[`operator>`] 
| Return `true` if `lhs` follows `rhs` in the iteration sequence.
| xref:BloombergLP/bslstl/operator_ge.adoc[`operator>=`] 
| Return `true` if `lhs` follows or equals `rhs` in the iteration sequence.
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/variant_constructsFromStd.adoc[`variant_constructsFromStd`] 
| Determine whether `t_VARIANT` is constructible from `t_STD_VARIANT`.
|===


== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/IteratorUtil_ModernIterator.adoc[`IteratorUtil_ModernIterator`] 
| Concept identifying iterators that expose an `iterator_concept` type.
| xref:BloombergLP/bslstl/Optional_ConvertibleToBool.adoc[`Optional_ConvertibleToBool`] 
| Component‐private concept modeling the exposition‐only `boolean‐testable` concept.
| xref:BloombergLP/bslstl/Optional_DerivedFromBslOptional.adoc[`Optional_DerivedFromBslOptional`] 
| Component‐private concept that is satisfied when `t_TYPE` derives from `bsl::optional`.
| xref:BloombergLP/bslstl/Optional_DerivedFromOptional.adoc[`Optional_DerivedFromOptional`] 
| This component‐private concept models whether a type is derived from one of `std::optional` or `bsl::optional`.
| xref:BloombergLP/bslstl/Optional_DerivedFromStdOptional.adoc[`Optional_DerivedFromStdOptional`] 
| Component‐private concept that is satisfied when `t_TYPE` derives from `std::optional`.
|===



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