BloombergLP::bslstl

Types

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

Type Aliases

Name	Description
`Pair_IndexSequence`	Alias for `bslmf::IntegerSequence` with `std::size_t` elements.
`Pair_MakeIndexSequence`	Alias for `bslmf::MakeIntegerSequence` with `std::size_t` elements.
`StringRef`	This `typedef` is an alias to `StringRefImp<char>`.
`StringRefWide`	Wide-character string ref type (`StringRefImp<wchar_t>`).

Functions

Name	Description
`hashAppend`	Pass the specified `input` to the specified `hashAlg`
`operator+`	Addition operators
`operator++`	Increment operators
`operator-`	Subtraction operators
`operator--`	Decrement operators
`operator>>`	Read a quoted string from the specified `input` stream into `object`.
`optional_acceptsBslOptional`	Component-private constraint helper for `Optional_DerivedFromBslOptional`.
`optional_acceptsStdOptional`	Component-private constraint helper for `Optional_DerivedFromStdOptional`.
`swap`	`swap` overloads
`to_chars`	Write the specified `value` into the character buffer `[first, last)]`.
`variant_swapImpl`	`variant_swapImpl` overloads
`operator<<`	Write the value of the specified `object` to the specified `output` stream.
`operator==`	Equality operators
`operator!=`	Inequality operators
`operator<`	Return `true` if `lhs` precedes `rhs` in the iteration sequence.
`operator<=`	Return `true` if `lhs` precedes or equals `rhs` in the iteration sequence.
`operator>`	Return `true` if `lhs` follows `rhs` in the iteration sequence.
`operator>=`	Return `true` if `lhs` follows or equals `rhs` in the iteration sequence.

Variables

Name	Description
`variant_constructsFromStd`	Determine whether `t_VARIANT` is constructible from `t_STD_VARIANT`.

Concepts

Name	Description
`IteratorUtil_ModernIterator`	Concept identifying iterators that expose an `iterator_concept` type.
`Optional_ConvertibleToBool`	Component-private concept modeling the exposition-only `boolean-testable` concept.
`Optional_DerivedFromBslOptional`	Component-private concept that is satisfied when `t_TYPE` derives from `bsl::optional`.
`Optional_DerivedFromOptional`	This component-private concept models whether a type is derived from one of `std::optional` or `bsl::optional`.
`Optional_DerivedFromStdOptional`	Component-private concept that is satisfied when `t_TYPE` derives from `std::optional`.