BloombergLP::bslstl

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.

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>).

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.

Name

Description

variant_constructsFromStd

Determine whether t_VARIANT is constructible from t_STD_VARIANT.

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.