bsl

This meta‐function selects the appropriate implementation for comparing the parameterized TYPE. This generic template uses the std::equal_to functor.

Deque_Base

This class describes the basic layout for a deque class. It is important that this class has the same layout as the deque class implementation. It is parameterized by VALUE_TYPE only and implements the portion of bsl::deque that does not need to know about its (template parameter) type ALLOCATOR (in order to generate shorter debug strings). Note that this class must have the same layout as Deque_Imp (see implementation file).

Deque_BlockCreator

This class allocates blocks at the front or back of a deque and tentatively adds them to the deque. It also keeps track of how many of the newly allocated blocks have actually been used by the deque. The destructor automatically frees any unused blocks (e.g., in case an exception is thrown).

Deque_BlockLengthCalcUtil

This struct provides a namespace for the calculation of block length (the number of elements per block within a deque). This ensures that each block in the deque can hold at least 16 elements.

Deque_BlockProctor

This class implements a proctor that, upon destruction and unless its release method has previously been invoked, deallocates empty blocks at one end (i.e., front or back) of a proctored deque. The end at which empty blocks are to be proctored is indicated by a flag supplied at construction. See emplace for a use case.

Deque_ClearGuard

This class provides a proctor which, at destruction, calls clear on the deque supplied at construction, unless the guard has been released prior.

Deque_Guard

This class provides a proctor that maintains a count of the number of elements constructed at the front or back of a deque, but not yet committed to the deque's range of valid elements; if the count is non‐zero at destruction, the destructor destroys the elements in the range [d_deque_p‐>end() .. d_deque_p‐>end() + d_count)], or the range [d_deque_p‐>begin() ‐ d_count .. d_deque_p‐>begin())], depending on whether this proctor guards the back or front. This guard is used to undo element constructors in the event of an exception. It is up to the client code to increment the count whenever a new element is constructed and to decrement the count whenever d_start or d_finish of the guarded deque is moved to incorporate more elements.

Deque_Util

This struct provides a namespace to implement the swap member function of deque<VALUE_TYPE, ALLOCATOR>. This function can be implemented irrespective of the VALUE_TYPE or ALLOCATOR template parameters, which is why we implement it in this non‐parameterized, non‐inlined utility.

FunctionDeductionHelper

This struct provides a set of template meta‐functions that extract the signature of a class member function, stripping any qualifiers such as const, noexcept or &.

List_AllocAndSizeWrapper

This struct is a wrapper around the allocator and size data members of a list. It takes advantage of the empty‐base optimization (EBO) so that if the allocator is stateless, it takes up no space.

List_DefaultLessThan

Binary predicate type for comparing two VALUE objects using operator<. This operation is usually, but not always, the same as that provided by std::less<VALUE>. The standard requires that certain functions use operator<, which means that divergent specializations of std::less are to be ignored.

List_Iterator

List_Node

PRIVATE CLASS TEMPLATE. For use only by bsl::list implementation. An instance of List_Node<T> is a single node in a doubly‐linked list used to implement bsl::list<T,A>, for a given element type T and allocator type A. Note that an instantiation of this class for a given bsl::list is independent of the allocator type.

List_NodeProctor

This class provides a proctor to free a node containing an uninitialized VALUE object in the event that an exception is thrown.

Pair_BslmaIdiom

This component‐private meta‐function determines whether the specified TYPE template parameter takes a bslma::Allocator* constructor argument and, if so, whether that argument is at the end of the argument list or at the beginning of the argument list following an argument of type bsl::allocator_arg_t. This type derived from bsl::integral_constant<int, N> where N is the number of additional parameters required to pass an allocator to a constructor using the chosen idiom.

Pair_ConstructionParametersPackLength

This component‐private component‐private meta‐function determines the number of elements in a tuple containing parameters for piecewise construction of a bsl::pair member having the specified TYPE. Result value depends on the TYPE, whether it takes a bslma::Allocator* constructor argument and, if so, whether that argument follows an argument of type bsl::allocator_arg_t.

Pair_First

This component‐private class holds the first data member of a pair and constructs it appropriately. Note the partial specializations below for the cases that (template parameter) 'TYPE' is a reference.

Pair_Second

This component‐private class holds the second data member of a pair and constructs it appropriately. Note the partial specializations below for the cases that (template parameter) 'TYPE' is a reference.

StringBufContainer

This class enables the implementation of string‐stream types by providing a trivial type containing a basic_stringbuf that is suitable as a (private) base class for a string‐stream. Inheriting from StringBufContainer allows the string‐stream to ensure that the contained basic_stringbuf is initialized before initializing other base classes or data members without potentially overriding virtual methods in the basic_stringbuf type. Note that implementations of string‐stream types must pass the address of a string‐buffer to their public base class (e.g., basic_stream), so the string‐stream must ensure (using private inheritance) that the string‐buffer is initialized before constructing the public base class. If a string‐stream implementation were to directly inherit from basic_streambuf, then virtual methods defined in that string‐stream (e.g., underflow) might incorrectly override those in the basic_stringbuf implementation.

StringComparator

This class is a functor that provides comparison between two const char * strings.

String_ClearProctor

This component private class implements a proctor that sets the length of a string to zero, and, if release is not called, will restore that string upon it's destruction. The intended usage is to implement assign methods in terms of append (by clearing the string before appending to it), while maintaining the strong exceptions guarantee. Note that after constructing this proctor for a string s, the invariant s[s.length()]== CHAR_TYPE() is violated for non‐empty s. This invariant will be restored by either a successful append or by the proctor's destructor if an exception is thrown. Note that the template parameter was renamed from STRING_TYPE to FULL_STRING_TYPE due to a name clash with a define elsewhere in the code base (see DRQS 112049582).

String_ComparisonCategory

This meta‐function selects the comparison category type for basic_string with the specified CHAR_TRAITS.

SyncBuf_MutexUtil

Internal mutex‐related utils.

Variant_VariantAlternativeImpl

This component‐private metafunction provides the implementation of bsl::variant_alternative.

Vector_DeduceIteratorCategory

This struct provides a primitive means to distinguish between iterator types and fundamental types, in order to dispatch to the correct implementation of a function template (or constructor template) passed two arguments of identical type. By default, it is assumed that any type that is not a fundamental type, as determined by the type trait bsl::is_fundamental, must be an iterator type. std::iterator_traits is updated in C++17 to provide a SFINAE‐friendly instantiation of the primary‐template for types that do not provide all of the nested typedef names, but we cannot portably rely on such a scheme yet.

Vector_PushProctor

This class template provides a proctor for a newly created object that is managed by an allocator. The object will be constructed through a call to allocator_traits<ALLOCATOR>::construct, and it should be destroyed by a call to allocator_traits<ALLOCATOR>::destroy. Note that this proctor takes no responsibility for the allocated memory that the supplied value is constructed in.

Vector_RangeIteratorCategory

This struct provides a primitive means to determine the iterator category for an iterator/sentinel pair where there is a preference to treat any iterator where the insertDistance can be computed as a forward iterator, even if it does not meet the ranges concepts needed to be treated as one.

Vector_Util

This struct provides a namespace for implementing the swap member function of vector<VALUE_TYPE, ALLOCATOR>. swap can be implemented irrespective of the VALUE_TYPE or ALLOCATOR template parameters, which is why we implement it in this non‐parameterized, non‐inlined utility.

_Alloc_traits

Traits for rebinding STLPort allocators to a different value type.

_Const_traits

Iterator traits for const access to objects of type _Tp.

_Hashtable_iterator

_Hashtable_node

Internal hashtable node holding a value and a next‐node pointer.

_Ht_iterator

_Nonconst_traits

Iterator traits for modifiable access to objects of type _Tp.

_STLP_alloc_proxy

Proxy combining an allocator with a stored value for STLPort containers.

_Sl_global

Shared algorithms for intrusive singly‐linked list node manipulation.

_Slist_base

Allocator‐aware base that owns the sentinel head node of an slist.

_Slist_iterator

Forward iterator over an slist of _Tp with constness from _Traits.

_Slist_iterator_base

Non‐templated base for forward iterators over an slist.

_Slist_node

Singly‐linked list node storing a value of type _Tp.

_Slist_node_base

Intrusive singly‐linked list node base holding a next pointer.

_Stl_prime

Table of prime bucket counts used for hash table sizing.

add_const

This struct template implements the add_const meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, type, that returns the result. If the (template parameter) t_TYPE is not a reference type, nor a function type, nor already const‐qualified at the top‐level, then type is an alias to t_TYPE with a top‐level const‐qualifier added; otherwise, type is an alias to t_TYPE.

add_cv

This struct template implements the add_cv meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, type, that returns the result. If the (template parameter) t_TYPE is not a reference type, nor a function type, nor already const‐qualified and volatile‐qualified at the top‐level, then type is an alias to t_TYPE with a top‐level const‐qualifier and a volatile‐qualifier added; otherwise, type is an alias to t_TYPE.

add_lvalue_reference

This struct template implements a meta‐function to transform the (template parameter) t_TYPE to its lvalue reference type.

add_pointer

This struct template implements the add_pointer meta‐function defined in the C++11 standard [meta.trans.ptr], providing an alias, type, that returns the result. If the (template parameter) t_TYPE is not a reference type, then type is an alias to a pointer type that points to t_TYPE; otherwise, type is an alias to a pointer type that points to the type referred to by the reference t_TYPE, unless it is not legal to form such a pointer type, in which case type is an alias for t_TYPE.

add_rvalue_reference

This struct template implements a meta‐function to transform the (template parameter) t_TYPE to its rvalue reference type.

add_volatile

This struct template implements the add_volatile meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, type, that returns the result. If the (template parameter) t_TYPE is not a reference type, nor a function type, nor already volatile‐qualified at the top‐level, then type is an alias to t_TYPE with a top‐level volatile‐qualifier added; otherwise, type is an alias to t_TYPE.

allocator

An STL‐compatible allocator that forwards allocation calls to an underlying mechanism object of a type derived from bslma::Allocator. This class template adheres to the allocator requirements defined in section [allocator.requirements]and implements a superset of the std::pmr::polymorphic_allocator class template described in section [mem.poly.allocator.class]of the C++ standard and may be used to instantiate any [container]class template that follows the STL allocator protocol. The allocation mechanism is chosen at run‐time, giving the programmer run‐time control over how a container allocates and frees memory.

allocator_arg_t

Tag type indicating that next argument is an allocator. TBD: If native library declares std::allocator_arg_t, then this struct should be an replaced by an alias for std::allocator_arg_t.

allocator_traits

This class supports the complete interface of the C++11 allocator_traits class template, which provides a uniform mechanism for accessing nested types within, and operations on, any standard‐conforming allocator. A specialization of this class template for bsl::allocator provides support for Bloomberg's bslma allocator model (see the bslma_bslallocator component for more details). In C++11 compilation environments, the construct methods forward to the allocator's construct method if such a method matching the (variable number of) specified constructor arguments exists; otherwise, the construct method falls back to invoking the constructor of the element type directly. In C++03 compilation environments, there is no reliable way to detect if the type provide a method that matches a (variable number of) specified arguments; therefore, we require that standard allocator types define construct methods taking a variable number of arguments in those environments. This implementation is not fully‐standard‐conforming in that it does not support deduce data types that are not specified in the allocator.

basic_istringstream

This class implements a standard input stream that provides a constructor and manipulator for setting the sequence of characters from which input is streamed to a supplied bsl::basic_string.

basic_ostringstream

This class implements a standard output stream that provides an accessor for obtaining a bsl::basic_string containing the sequence of characters that have been written to the stream.

basic_osyncstream

Forward declaration of basic_osyncstream.

basic_string

This class template provides an STL‐compliant string that conforms to the bslma::Allocator model. For the requirements of a string class, consult the second revision of the ISO/IEC 14882 Programming Language C++ (2003). Note that the (template parameter) CHAR_TYPE must be equal to ALLOCATOR::value_type. In addition, this implementation offers strong exception guarantees (see below), with the general rules that:

basic_stringbuf

This class implements a standard stream buffer providing an unformatted character input sequence and an unformatted character output sequence that may be initialized or accessed using a string value.

basic_stringstream

This class implements a standard stream providing operations using bsl::basic_string for modifying or accessing the sequence of characters read from, or written to, the stream.

basic_syncbuf

Forward declaration of basic_syncbuf.

binary_compose

This class provides a function object adaptor for three other functors. When given two adaptable unary functions g1 and g2, and a third adaptable binary function f, and if g1 and g2`s argument type is convertible to `f`s argument type, this class can be used to create a function object `h that is equivalent to f(g1(x), g2(x)).

bitset

This class template provides an STL‐compliant bitset. For the requirements of a bitset class, consult the second revision of the ISO/IEC 14882 Programming Language c++ (2011).

conditional

This struct template implements the conditional meta‐function defined in the C++ standard [meta.trans.other], providing an alias, type, that returns the result. If the (template parameter) value t_COND is true, then type has the same type as the (template parameter) type t_TRUE_TYPE; otherwise, type has the same type as the (template parameter) type t_FALSE_TYPE. Note that this generic default template defines type to be an alias to t_TRUE_TYPE for when t_COND is true. A template specialization is provided (below) handles the case for when t_COND is false.

decay

Metafunction to return the variant of the specified parameter t_TYPE used for pass‐by‐reference, e.g., by applying array‐to‐pointer and function‐to‐pointer conversion.

decay_imp

Component‐private implementation of decay. Do not use.

deque

This class template provides an STL‐compliant deque that conforms to the bslma::Allocator model. For the requirements of a deque class, consult the C++11 standard. In particular, this implementation offers the general rules that: 1. A call to any method that would result in a deque having a size greater than the value returned by max_size triggers a call to bslstl::StdExceptUtil::throwLengthError. 2. A call to an at method that attempts to access a position outside of the valid range of a deque triggers a call to bslstl::StdExceptUtil::throwOutOfRange.

enable_if

This struct template implements the enable_if meta‐function defined in the C++11 standard [meta.trans.ptr]. This struct template provides a typedef type that is an alias to the (template parameter) t_TYPE if the (template parameter) t_COND is true; otherwise, type is not provided. If t_TYPE is not specified, it is set to void. Note that this generic default template provides type for when t_COND is true; a template specialization is provided (below) that omits type for when t_COND is false.

enable_shared_from_this

This class allows an object that is currently managed by a shared_ptr to safely generate a copy of the managing shared_ptr object. Inheriting from enable_shared_from_this<ELEMENT_TYPE> provides the (template parameter) ELEMENT_TYPE type with a member function shared_from_this. If an object of type ELEMENT_TYPE is managed by a shared_ptr then calling shared_from_this will return a shared_ptr<ELEMENT_TYPE> that shares ownership of that object. It is undefined behavior to call shared_from_this on an object unless that object is managed by a shared_ptr.

equal_to

This struct defines a binary comparison functor applying operator== to two VALUE_TYPE objects. This class conforms to the C++11 standard specification of std::equal_to that does not require inheriting from std::binary_function. Note that this class is an empty POD type.

formatter

This is the base template for the bsl::formatter class. Its members are deleted to ensure attempts to format a type without a partial specialization of formatter for that type will result in a compile time error.

function

Forward declaration.

hash

Empty base class for hashing. This class, and all explicit and partial specializations of this class, shall conform to the C++11 Hash Requirements (C++11 17.6.3.4, [hash.requirements]). Unless this template is explicitly specialized, it will use the default hash algorithm provided by bslh::Hash<> to supply hash values. In order to hash a user‐defined type using bsl::hash, bsl::hash must be explicitly specialized for the type, or, preferably, hashAppend must be implemented for the type. For more details on hashAppend and bslh::Hash see the component bslh_hash.

hash_map

Legacy STLPort hash container mapping unique keys to values.

hash_multimap

Legacy STLPort hash container mapping keys to possibly duplicate values.

hash_multiset

Legacy STLPort hash container storing possibly duplicate values.

hash_set

Legacy STLPort hash container storing unique values.

hashtable

Internal STLPort hash table used to implement legacy hash containers.

integral_constant

Metafunction representing a compile‐time constant of the specified (template parameter) t_TYPE with the specified (template parameter) t_VALUE.

invoke_result

This class is a metafunction that conditionally provides a type member that is the type resulting from invoking an object of the specified t_FN template parameter with arguments of the specified t_ARGTYPES template parameters. More precisely, given types F, T1, T2, ..., TN corresponding to expressions f, t1, t2, ..., tN, bslmf::ResultType<F, T1, T2, ..., TN>::type is usually the type of the psuedo‐expression (f, t1, t2, ..., tN), as defined in section [func.rquire]of the C++11 standard. If the compiler supports C++11 decltype and the psuedo‐expression (f, t1, t2, ..., tN) is not well‐formed, this class provides no type member. If t_FN is a class (functor) type and the compiler doesn't support C++11 decltype, the return type is automatically deduced for fundamental types, void, pointers or references to those, or bsl::nullptr_t and is deduced by bslmf::ResultType<t_FN>::type otherwise. If deduction fails, this metafunction yields bslmf::InvokeResultDeductionFailed. See component‐level documentation for more detail.

is_arithmetic

This struct template implements the is_arithmetic meta‐function defined in the C++11 standard [meta.unary.comp]to determine if the (template parameter) t_TYPE is an arithmetic type. This struct derives from bsl::true_type if the t_TYPE is an arithmetic type, and from bsl::false_type otherwise.

is_array

This struct template implements the is_array meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is an array type. This struct derives from bsl::true_type if the t_TYPE is an array type, and bsl::false_type otherwise.

is_bounded_array

This struct template implements the is_bounded_array meta‐function defined in the C++20 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is an array type of known bound. This struct derives from bsl::true_type if the t_TYPE is an array type of known bound, and bsl::false_type otherwise.

is_class

This struct template implements the is_class meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is a class. Note that for implementations without native library support, this component will mis‐diagnose union types as classes. This would be correct according to the core language definition of a class type, but is an error according to the standard library definition of this type trait.

is_const

This struct template implements the is_const meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is const‐qualified. This struct derives from bsl::true_type if the t_TYPE is const‐qualified, and bsl::false_type otherwise. Note that this generic default template derives from bsl::false_type. A template specialization is provided (below) that derives from bsl::true_type.

is_convertible

This struct template implements the is_convertible meta‐function defined in the C++11 standard to determine whether the (template parameter) t_FROM_TYPE is implicitly convertible to the (template parameter) t_TO_TYPE.

is_copy_constructible

This struct template implements a meta‐function to determine whether the (template parameter) t_TYPE is copy constructible. This struct derives from bsl::true_type if the t_TYPE is copy constructible, and from bsl::false_type otherwise. This meta‐function has the same syntax as the is_copy_constructible meta‐function defined in the C++11 standard [meta.unary.prop]; on C++03 platforms, however, this meta‐function defaults to true_type for all types that are not explicitly declared to have the bslmf::IsNonCopyable trait using the BSLMF_NESTED_TRAIT_DECLARATION macro. To mark a type as non‐copyable, bslmf::IsNonCopyable must be specialized (for that type) to inherit from bsl::true_type.

is_empty

This struct is a meta‐function to determine whether the (template parameter) t_TYPE is an empty class type. This struct derives from bsl::true_type if the t_TYPE is empty, and from bsl::false_type otherwise. This meta‐function has the same syntax as the is_empty meta‐function defined in the C++11 standard [meta.unary.prop]; on C++03 platforms, however, this meta‐function defaults to true_type if t_TYPE is a class or struct with no non‐static data members other than bit‐fields of length 0, no virtual member functions, no virtual base classes, and no base class B for which is_empty<B>::value is false; otherwise is_empty defaults to false_type. Note that this meta‐function will fail to compile for a union that is the same size as an empty class in C++03.

is_enum

This struct template implements the is_enum meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is an enumerated type. This struct derives from bsl::true_type if the t_TYPE is an enumerated type, and from bsl::false_type otherwise.

is_floating_point

This struct template implements the is_floating_point meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is a floating‐point type.

is_function

This struct template implements the is_function meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is a function type. This struct derives from bsl::true_type if the t_TYPE is a function type, and from bsl::false_type otherwise. This implementation relies on the fact that neither function types nor reference types can be cv‐qualified so that is_const<const t_TYPE> will actually yield false.

is_fundamental

This struct template implements a meta‐function for checking if a type is fundamental as defined in the C++11 standard [basic.fundamental]. Note that this is subtly differemt from bslmf::IsFundamental, which also returns true_type for references to fundamental types.

is_integral

This struct template implements the is_integral meta‐function defined in the C++11 standard to determine if the (template parameter) t_TYPE is an integral type.

is_lvalue_reference

Metafunction that is true if the (template parameter) t_TYPE is an lvalue reference type.

is_member_function_pointer

This struct template implements the is_member_function_pointer meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is a pointer to non‐static member function type. This struct derives from bsl::true_type if the t_TYPE is a pointer to non‐static member function type, and from bsl::false_type otherwise. Additional specializations are provided below to give the correct answer in all cases.

is_member_object_pointer

This struct template implements the is_member_object_pointer meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is a pointer to non‐static data member type. This struct derives from bsl::true_type if the t_TYPE is a pointer to non‐static data member type, and from bsl::false_type otherwise.

is_member_pointer

This struct template implements the is_member_pointer meta‐function defined in the C++11 standard [meta.unary.comp]to determine if the (template parameter) t_TYPE is a member pointer type. This struct derives from bsl::true_type if the t_TYPE is a member pointer type, and from bsl::false_type otherwise. Additional specializations are provided below to give the correct answer in all cases.

is_nothrow_move_constructible

This struct template implements a metafunction to determine whether the (template parameter) t_TYPE has a no‐throw move constructor. This struct derives from bsl::true_type if the t_TYPE has a no‐throw move constructor, and from bsl::false_type otherwise. This metafunction has the same syntax as the is_nothrow_move_constructible metafunction defined in the C++11 standard [meta.unary.prop]; on C++03 platforms, however, this metafunction can automatically determine the value for trivially copyable types (including scalar types), for reference types, and for class types associating with the bsl::is_nothrow_move_constructible trait using the BSLMF_NESTED_TRAIT_DECLARATION macro. To support other no‐throw move constructible types, this template should be specialized to inherit from bsl::true_type. Note that cv‐qualified user defined types are rarely no‐throw move constructible unless they are also trivially copyable, so there are no cv‐qualified partial specializations of this trait.

is_pointer

This struct template implements the is_pointer meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is a pointer. This struct derives from bsl::true_type if the t_TYPE is a pointer type (but not a pointer‐to‐non‐static‐member type), and bsl::false_type otherwise.

is_polymorphic

This struct template implements the is_polymorphic meta‐function defined in the C++11 standard [meta.unary.prop]to determine if the (template parameter) t_TYPE is a (possibly cv‐qualified) polymorphic type. This struct derives from bsl::true_type if the t_TYPE is a polymorphic type, and bsl::false_type otherwise.

is_reference

This struct template implements the is_reference meta‐function defined in the C++11 standard [meta.unary.comp]to determine if the (template parameter) t_TYPE is a (lvalue or rvalue) reference type.

is_rvalue_reference

This struct template provides a meta‐function to determine whether the (template parameter) t_TYPE is a (possibly cv‐qualified) rvalue reference type. This generic default template derives from bsl::false_type. A template specialization is provided (below) that derives from bsl::true_type.

is_same

This struct template provides a meta‐function to determine whether the (template parameter) t_TYPE1 and the (template parameter) t_TYPE2 are the same. This generic default template derives from bsl::false_type. A template specialization is provided (below) that derives from bsl::true_type.

is_trivially_copyable

This struct template implements a meta‐function to determine whether the (template parameter) t_TYPE is trivially copyable. This struct derives from bsl::true_type if the t_TYPE is trivially copyable, and from bsl::false_type otherwise. This meta‐function has the same syntax as the is_trivially_copyable meta‐function defined in the C++11 standard [meta.unary.prop]; however, this meta‐function can automatically determine the value for the following types only: reference types, fundamental types, enumerated types, pointers to members, and types declared to have the bsl::is_trivially_copyable trait using the BSLMF_NESTED_TRAIT_DECLARATION macro (the value for other types defaults to false). To support other trivially copyable types, this template must be specialized to inherit from bsl::true_type for them.

is_trivially_default_constructible

This struct template implements a meta‐function to determine whether the (template parameter) t_TYPE is trivially default‐constructible. This struct derives from bsl::true_type if the t_TYPE is trivially default‐constructible, and from bsl::false_type otherwise. This meta‐function has the same syntax as the is_trivially_default_constructible meta‐function defined in the C++11 standard [meta.unary.prop]; however, this meta‐function can automatically determine the value for the following types only: reference types, fundamental types, enums, pointers to members, and types declared to have the bsl::is_trivially_default_constructible trait using the BSLMF_NESTED_TRAIT_DECLARATION macro (and the value for other types defaults to false). To support other trivially default‐constructible types, this template must be specialized to inherit from bsl::true_type for them.

is_unbounded_array

This struct template implements the is_unbounded_array meta‐function defined in the C++20 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is an array type of unknown bound. This struct derives from bsl::true_type if the t_TYPE is an array type of unknown bound, and bsl::false_type otherwise.

is_void

This struct template implements the is_void meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is the (possibly cv‐qualified) void type. This struct derives from bsl::true_type if t_TYPE is the void type, and bsl::false_type otherwise.

is_volatile

This struct template implements the is_volatile meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) t_TYPE is volatile‐qualified. This struct derives from bsl::true_type if the t_TYPE is volatile‐qualified, and bsl::false_type otherwise. Note that this generic default template derives from bsl::false_type. A template specialization is provided (below) that derives from bsl::true_type.

list

Forward declaration required by List_NodeProctor.

map

This class template implements a value‐semantic container type holding an ordered sequence of key‐value pairs having unique keys that provide a mapping from keys (of the template parameter type, KEY) to their associated values (of another template parameter type, VALUE).

multimap

This class template implements a value‐semantic container type holding an ordered sequence of key‐value pairs having possibly duplicate keys that provide a mapping from keys (of the template parameter type, KEY) to their associated values (of another template parameter type, VALUE).

multiset

This class template implements a value‐semantic container type holding an ordered sequence of possibly duplicate keys (of the template parameter type, KEY).

nostopstate_t

An object of this empty struct can be passed to the constructor of stop_source to create a stop_source object that does not refer to any stop state.

optional

owner_equal

Function object that compares shared_ptr/`weak_ptr` owner equality.

owner_hash

Function object that hashes shared_ptr/`weak_ptr` owner identity.

owner_less

Function‐object type that orders two pointers by the ownership of their shared/weak pointer objects rather than by the pointer addresses.

pair

The class template pair provides a pair of public data members, first and second, of type T1 and T2 respectively. If either T1 or T2 uses bslma::Allocator for memory management, then provide an optional bslma::Allocator argument for each constructor, to be passed through to the constructors of first and/or second as appropriate. The interface to this class is identical to the standard std::pair except for the addition of the allocators. Note that the implementation of this class provides first and second through multiple base classes in order to simplify construction of each member when allowing for the various rules for passing allocators in C++11.

priority_queue

This class is a value‐semantic class template, adapting a container of the (template parameter) type CONTAINER, that holds elements of the (template parameter) type VALUE, to provide a highest‐priority‐first priority queue data structure, where the priorities of elements are compared by a comparator of the template parameter type, COMPARATOR. The container object held by a priority_queue class object is referenced as c in the following documentation.

queue

This class is a value‐semantic class template, having a container of the parameterized CONTAINER type that holds elements of the parameterized VALUE type, to provide a first‐in‐first‐out queue data structure. The container object held by a queue class object is referenced as c in the following function‐level documentation.

reference

Proxy providing a mutable reference to a single bit in a bitset.

remove_const

This struct template implements the remove_const meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, type, that returns the result. type has the same type as the (template parameter) t_TYPE except that any top‐level const‐qualifier has been removed. Note that this generic default template provides a type that is an alias to t_TYPE for when t_TYPE is not const‐qualified. A template specialization is provided (below) that removes the const‐qualifier for when t_TYPE is const‐qualified.

remove_cv

This struct template implements the remove_cv meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, type, that returns the result. type has the same type as the (template parameter) t_TYPE except that any top‐level cv‐qualifiers have been removed.

remove_extent

From the C++14 standard: If T names a type "array of U", the member typedef type shall be U, otherwise T. [ Note: For] multidimensional arrays, only the first array dimension is removed. For a type "array of const U", the resulting type is const U. ‐‐ *end note* ]

remove_pointer

This struct template implements the remove_pointer meta‐function defined in the C++11 standard [meta.trans.ptr], providing an alias, type, that returns the result. If the (template parameter) t_TYPE is a (possibly cv‐qualified) pointer type, then type is an alias to the type pointed to by t_TYPE; otherwise, type is an alias to t_TYPE.

remove_volatile

This struct template implements the remove_volatile meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, type, that returns the result. type has the same type as the (template parameter) t_TYPE except that any top‐level volatile‐qualifier has been removed. Note that this generic default template provides a type that is an alias to t_TYPE for when t_TYPE is not volatile‐qualified. A template specialization is provided (below) that removes the volatile‐qualifier for when t_TYPE is volatile‐qualified.

select1st

This struct is a functor that returns the first member of its PAIR argument.

select2nd

This struct is a functor that returns the second member of its PAIR argument.

set

This class template implements a value‐semantic container type holding an ordered sequence of unique keys (of the template parameter type, KEY).

shared_ptr

This class provides a thread‐safe reference‐counted "smart pointer" to support "shared ownership" of objects: a shared pointer ensures that the shared object is destroyed, using the appropriate deletion method, only when there are no shared references to it. The object (of template parameter type ELEMENT_TYPE) referred to by a shared pointer may be accessed directly using the ‐> operator, or the dereference operator (operator *) can be used to obtain a reference to that object.

slist

Singly‐linked list container with constant‐time front insertion.

stack

This class defines a container adapter which supports access primarily via push, pop, and top. This type can be based on a variety of other container types, including deque, vector, and list. This type is value‐semantic if the supporting CONTAINER and VALUE are value‐semantic.

stop_callback

This class holds an object or reference of type t_CALLBACK and, when constructed using a stop_token that owns a stop state, schedules the held object or reference to be executed by the thread that requests cancellation on that stop state (if any). However, if cancellation was already requested before the stop_callback was constructed, the constructor invokes the callback immediately. If there is no stop state, or request_stop is never called for the stop state, then the callback is not invoked. stop_callback stores its callback within its own footprint, and thus never requires memory allocation; however, stop_callback<t_CALLBACK> is an allocator‐aware class, if t_CALLBACK is an allocator‐aware class, and any supplied allocator will then be passed to the constructor of t_CALLBACK.

stop_source

This class is a mechanism for making and observing cancellation requests. An object of this class may have (possibly shared) ownership of a stop state, in which case it can be used to make a cancellation request or observe whether a cancellation request has been made on the owned stop state; it is also possible for a stop_source object to not own a stop state. Due to its shared ownership semantics, it is safe to pass a copy of a stop_source object to a callback that might outlive the original stop_source object; however, a callback that should only be able to observe a cancellation request, without being able to request cancellation itself, should instead be passed a stop_token, which can be created by calling stop_source::get_token.

stop_token

This class is a mechanism for observing cancellation requests. An object of this class either has (possibly shared) ownership of a stop state and can be used to observe whether a cancellation request has been made on that stop state, or does not own a stop state. A stop_token cannot be used to make a cancellation request.

type_index

This class implements an in‐core value‐semantic type wrapping a standard type_info object.

unary_compose

This class provides a function object adaptor for two other functors. When given two adaptable unary functions f and g, and when g`s return type is convertible to `f`s argument type, this class can be used to create a function object `h that is equivalent to f(g(x)).

unordered_map

This class template implements a value‐semantic container type holding an unordered set of KEY‐VALUE pairs having unique keys that provide a mapping from keys (of template parameter type KEY) to their associated mapped values (of template parameter type VALUE).

unordered_multimap

This class template implements a value‐semantic container type holding a collection of (possibly equivalent) keys (of the template parameter type KEY), each mapped to their associated values (of another template parameter type VALUE).

unordered_multiset

This class template implements a value‐semantic container type holding an unordered multiset of values (of template parameter type KEY).

unordered_set

This class template implements a value‐semantic container type holding an unordered set of unique values (of template parameter type KEY).

uses_allocator

This struct template implements a meta‐function to determine whether a (template parameter) t_TYPE uses a given (template parameter) t_ALLOCATOR_TYPE. This struct derives from bsl::true_type if t_TYPE uses t_ALLOCATOR_TYPE and from bsl::false_type otherwise. This meta‐function has the same syntax as the uses_allocator meta‐function defined in the C++11 standard [allocator.uses.trait].

variant

variant_alternative

This metafunction calculates the type of the alternative whose index is (template parameter) t_INDEX in the possibly cv‐qualified bsl::variant type of (template parameter) t_TYPE. If t_TYPE is cv‐qualified, its cv‐qualifiers are applied to the alternative.

variant_size

This metafunction calculates the number of alternatives in the (possibly cv‐qualified) bsl::variant type of (template parameter) t_BSL_VARIANT. The primary template is not defined.

vector

This class template provides an STL‐compliant vector that conforms to the bslma::Allocator model. For the requirements of a vector class, consult the C++11 standard. In particular, this implementation offers the general rules that:

vectorBase

This class describes the basic layout for a vector class, to be included into the vector layout before the allocator (provided by bslalg::ContainerBase) to take better advantage of cache prefetching. It is parameterized by VALUE_TYPE only, and implements the portion of vector that does not need to know about its (template parameter) type ALLOCATOR (in order to generate shorter debug strings). This class intentionally has no creators (other than the compiler‐generated ones).

vector_ForwardIteratorForPtrs

This metafunction provides an appropriate iterator adaptor for the specified (template parameter) type ITERATOR in order to implement members of the vector partial template specialization for vectors of pointers to the (template parameter) type TARGET. The metafunction will return the original ITERATOR type unless it truly is an iterator, using is_integral as a proxy for testing that a type is NOT an iterator. This is needed to disambiguate only the cases of users passing 0 as a null‐pointer value to functions requesting a number of identical copies of an element.

vector_UintPtrConversionIterator

This class provides a minimal proxy iterator adapter, transforming pointers to uintptr_t values on the fly, for only the operations needed to implement the member functions and constructors of the vector partial template specialization that take iterator ranges as arguments. While it does not provide a standard conforming iterator itself, if provides exactly sufficient behavior to implement all the needed members. VALUE_TYPE shall be a pointer type, and ITERATOR shall be a standard conforming iterator that dereferences to a type implicitly convertible to VALUE_TYPE

vector_UintPtrRangeAdapter

This class provides a minimal proxy range adapter, transforming pointers to uintptr_t values on the fly, for only the operations needed to implement the member functions and constructors of the vector partial template specialization that take iterator ranges as arguments. While it does not provide a standard conforming iterator itself, if provides exactly sufficient behavior to implement all the needed members. t_VALUE_TYPE shall be a pointer type, and [d_begin, d_end)] is a range of the input values.

weak_ptr

This friend declaration provides access to the internal data members while constructing a weak pointer from a weak pointer of a different type.

Type Aliases

Name

Description

ErrcEnum

Portable typedef for std::errc.

Pair_BslmaIdiomAllocatorArgT

Type tag for types that take a bslma::Allocator* as the second argument of their constructors, following an argument of type bsl::allocator_arg_t.

Pair_BslmaIdiomAtEnd

Type tag for types that take a bslma::Allocator* as the last argument of their constructors.

Pair_BslmaIdiomNone

Type tag for types that do not take a bslma::Allocator* constructor argument.

String_ComparisonCategoryType

Alias for the comparison category type of basic_string.

SyncBuf_Mutex

Mutex type used to synchronize basic_syncbuf emission.

_Sl_global_inst

Instantiation of _Sl_global providing shared slist node algorithms.

_Stl_prime_type

Alias for _Stl_prime<bool> providing the prime bucket‐count table.

__oom_handler_type

Function‐pointer type for an out‐of‐memory handler.

add_const_t

add_const_t is an alias to the return type of the add_const meta‐function. Note, that the add_const_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

add_cv_t

add_cv_t is an alias to the return type of the bsl::add_cv meta‐function. Note, that the add_cv_t avoids the ::type suffix and typename prefix when we want to use the result of the bsl::add_cv in templates.

add_lvalue_reference_t

add_lvalue_reference_t is an alias to the return type of add_lvalue_reference meta‐function. Note, that the add_const_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

add_pointer_t

add_pointer_t is an alias to the return type of the bsl::add_pointer meta‐function. Note, that the remove_pointer_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

add_rvalue_reference_t

add_rvalue_reference_t is an alias to the return type of add_rvalue_reference meta‐function. Note, that the add_const_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

add_volatile_t

add_volatile_t is an alias to the return type of the bsl::add_volatile meta‐function. Note, that the bsl::add_volatile_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

aligned_storage [deprecated]

Alias for std::aligned_storage in the bsl namespace.

aligned_storage_t [deprecated]

Alias for std::aligned_storage_t in the bsl namespace.

aligned_union [deprecated]

Alias for std::aligned_union in the bsl namespace.

aligned_union_t [deprecated]

Alias for std::aligned_union_t in the bsl namespace.

bad_optional_access

Alias for std::bad_optional_access in the bsl namespace.

bad_weak_ptr

Alias for BloombergLP::bslstl::BadWeakPtr.

bool_constant

Alias for integral_constant<bool, t_VALUE>.

common_type_t

Alias for std::common_type_t in the bsl namespace.

conditional_t

conditional_t is an alias to the return type of the bsl::conditional meta‐function. Note, that the conditional_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

decay_t

decay_t is an alias to the return type of the bsl::decay meta‐function. Note, that the enable_if_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

enable_if_t

enable_if_t is an alias to the return type of the bsl::enable_if meta‐function. Note, that the enable_if_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

false_type

Metafunction representing the boolean constant false.

forward_list

Singly‐linked list with bsl::allocator as the default allocator.

generator

invoke_result_t

invoke_result_t is an alias to the return type of the bsl::invoke_result meta‐function. Note, that the invoke_result_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

istringstream

This typedef is an alias to basic_istringstream<char>.

make_signed_t

Alias for std::make_signed_t<TYPE> in the bsl namespace.

make_unsigned_t

Alias for std::make_unsigned_t in the bsl namespace.

nullopt_t

This typedef is an alias to std::nullopt_t.

nullptr_t

Standard null pointer type for platforms with native nullptr support.

nullptr_t

Standard null pointer type for platforms with native nullptr support.

ostringstream

This typedef is an alias to basic_ostringstream<char>.

osyncstream

This typedef is an alias to basic_osyncstream<char>.

polymorphic_allocator

Alias for std::pmr::polymorphic_allocator in the bsl namespace.

remove_all_extents_t

Alias for std::remove_all_extents_t in the bsl namespace.

remove_const_t

remove_const_t is an alias to the return type of the bsl::remove_const meta‐function. Note, that the remove_const_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

remove_cv_t

remove_cv_t is an alias to the return type of the bsl::remove_cv meta‐function. Note, that the remove_cv_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

remove_extent_t

remove_extent_t is an alias to the return type of the bsl::remove_extent meta‐function. Note, that the enable_if_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

remove_pointer_t

remove_pointer_t is an alias to the return type of the bsl::remove_pointer meta‐function. Note, that the remove_pointer_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

remove_volatile_t

remove_volatile_t is an alias to the return type of the bsl::remove_volatile meta‐function. Note, that the remove_volatile_t avoids the ::type suffix and typename prefix when we want to use the result of the meta‐function in templates.

result_of_t

string

Narrow character string type (basic_string<char>).

stringbuf

This typedef is an alias to basic_stringbuf<char>.

stringstream

This typedef is an alias to basic_stringstream<char>.

syncbuf

This typedef is an alias to basic_syncbuf<char>.

true_type

Metafunction representing the boolean constant true.

tuple_element_t

Alias for the element type at index I of tuple‐like TYPE.

u16string

UTF‐16 string type (basic_string<char16_t>).

u32string

UTF‐32 string type (basic_string<char32_t>).

u8string

UTF‐8 string type (basic_string<char8_t>).

underlying_type_t

Alias for std::underlying_type_t in the bsl namespace.

variant_alternative_t

variant_alternative_t is an alias to the return type of the variant_alternative metafunction.

void_t

Alias template that always yields void.

wistringstream

This typedef is an alias to basic_istringstream<wchar_t>.

wostringstream

This typedef is an alias to basic_ostringstream<wchar_t>.

wosyncstream

This typedef is an alias to basic_osyncstream<wchar_t>.

wstring

Wide character string type (basic_string<wchar_t>).

wstringbuf

Wide‐character string stream buffer type.

wstringstream

This typedef is an alias to basic_stringstream<wchar_t>.

wsyncbuf

This typedef is an alias to basic_syncbuf<wchar_t>.

Enums

Name

Description

AllocConstants

Constants controlling the internal memory pool used by STLPort allocators.

MaxDecimalStringLengths

This enum give upper bounds on the maximum string lengths storing each scalar numerical type, and the starting value for long double that can get way too long for stack storage when printed. It is safe to use stack‐allocated buffers of these sizes for generating decimal representations of the corresponding type, including sign and terminating null character, using the default precision of 6 significant digits for floating point types.

Functions

Name

Description

PrintTo

PrintTo overloads

__slist_make_link

Link __new_node immediately after __prev_node and return __new_node.

allocate_shared

allocate_shared overloads

allocate_shared_for_overwrite

allocate_shared_for_overwrite overloads

bdlat_valueTypeAssign

Assign the specified rhs vector to the specified lhs vector and return 0.

compose1

Return an unary_compose function object constructed using the specified fn1 and fn2 unary functions. The returned function object is equivalent to fn1(fn2(x)).

compose2

Return a binary_compose function object constructed using the specified fn1 binary function, and the specified fn2 and fn3 unary functions. The returned function object is equivalent to fn1(fn2(x), fn3(x)).

const_pointer_cast

Return a shared_ptr<TO_TYPE> object sharing ownership of the same object as the specified source shared pointer to the (template parameter) FROM_TYPE, and referring to const_cast<TO_TYPE *>(source.get()). Note that if source cannot be const‐cast to TO_TYPE *, then a compiler diagnostic will be emitted indicating the error.

dynamic_pointer_cast

Return a shared_ptr<TO_TYPE> object sharing ownership of the same object as the specified source shared pointer to the (template parameter) FROM_TYPE, and referring to dynamic_cast<TO_TYPE*>(source.get()). If source cannot be dynamically cast to TO_TYPE *, then an empty shared_ptr<TO_TYPE> object is returned.

emit_on_flush

If, for the specified stream, stream.rdbuf() is a basic_syncbuf<CHAR,TRAITS,ALLOCATOR>, make stream emit (i.e., transmit data to the wrapped stream buffer) when flushed, otherwise has no effect. Return stream.

erase

erase overloads

erase_if

erase_if overloads

flush_emit

Flush the specified stream as if by calling stream.flush(). Then, if stream.rdbuf() actually points to a basic_syncbuf<CHAR,TRAITS,ALLOCATOR> buf, call buf.emit(). Return stream.

format

format overloads

format_to

format_to overloads

get

get overloads

get_deleter

Return the address of deleter used by the specified p shared pointer if the (template parameter) type DELETER is the type of the deleter installed in p, and a null pointer value otherwise.

get_if

get_if overloads

getline

getline overloads

hashAppend

hashAppend overloads

hashBasicString

Return a hash value for the specified str.

holds_alternative

Return true if the specified obj currently holds the (template parameter) t_TYPE alternative, and false otherwise. t_TYPE shall appear exactly once in the variant's list of alternatives.

make_format_args

Return an object, whose type is not specified, holding an array of format_arg types constructed from the specified args. The type returned is implicitly convertible to a format_args holding a reference to the contained array. This function will statically assert if any of the specified template parameters t_ARGS is of type long double.

make_optional

make_optional overloads

make_shared

make_shared overloads

make_shared_for_overwrite

make_shared_for_overwrite overloads

make_wformat_args

Return an object, whose type is not specified, holding an array of wformat_arg types constructed from the specified args. The type returned is implicitly convertible to a wformat_args holding a reference to the contained array. This function will statically assert if any of the specified template parameters t_ARGS is of type long double.

noemit_on_flush

If, for the specified stream, stream.rdbuf() is a basic_syncbuf<CHAR,TRAITS,ALLOCATOR>, make stream not emit (i.e., don't transmit data to the wrapped stream buffer) when flushed, otherwise has no effect. Return stream.

operator""_S

operator""_S overloads

operator""_h

operator""_h overloads

operator""_i

operator""_i overloads

operator""_if

operator""_if overloads

operator""_il

operator""_il overloads

operator""_min

operator""_min overloads

operator""_ms

operator""_ms overloads

operator""_ns

operator""_ns overloads

operator""_s

operator""_s overloads

operator""_sv

operator""_sv overloads

operator""_us

operator""_us overloads

operator&

Return a bitset that results from a bitwise AND of the specified lhs and rhs.

operator+

Addition operators

operator‐

Subtraction operators

operator/

Division operators

operator/=

Append the specified string to the specified path using the preferred directory separator if appropriate. Return a reference to path.

operator>>

Right shift operators

operatorˆ

Return a bitset that results from a bitwise XOR of the specified lhs and rhs.

operator|

Return a bitset that results from a bitwise OR of the specified lhs and rhs.

quoted

quoted overloads

reinterpret_pointer_cast

Return a shared_ptr<TO_TYPE> object sharing ownership of the same object as the specified source shared pointer to the (template parameter) FROM_TYPE, and referring to reinterpret_cast<TO_TYPE *>(source.get()). Note that if source cannot be reinterpret_cast‐ed to TO_TYPE *, then a compiler diagnostic will be emitted indicating the error.

static_pointer_cast

Return a shared_ptr<TO_TYPE> object sharing ownership of the same object as the specified source shared pointer to the (template parameter) FROM_TYPE, and referring to static_cast<TO_TYPE *>(source.get()). Note that if source cannot be statically cast to TO_TYPE *, then a compiler diagnostic will be emitted indicating the error.

stod overloads

stof overloads

stoi overloads

stol overloads

stold overloads

stoll overloads

stoul overloads

stoull overloads

swap overloads

to_string overloads

to_wstring

to_wstring overloads

vector_makeUintPtrRangeAdapter

Factory function for vector_UintPtrRangeAdapter.

vformat

vformat overloads

vformat_to

vformat_to overloads

visit

visit overloads

visitR

Return the result of invoking the specified visitor with the currently active alternative of the specified variant, implicitly converting the result to the explicitly specified (template parameter) t_RET. If variant does not hold a value, throw an exception of type bsl::bad_variant_access. This function is provided in all language versions for compatibility with the C++03 version (see below), but in new code in C++11 and later, bsl::visit should be used instead of this function.

bsl

Namespaces

Namespace Aliases

Types

Type Aliases

Enums

Functions

Variables

Using Declarations