bsl Namespace Reference

Namespaces
namespace	chrono

Classes
struct	_Alloc_traits
struct	_Const_traits
struct	_Hashtable_iterator
struct	_Hashtable_node
struct	_Ht_iterator
struct	_Nonconst_traits
class	_Sl_global
struct	_Slist_base
struct	_Slist_iterator
struct	_Slist_iterator_base
struct	_Slist_node
struct	_Slist_node_base
class	_Stl_prime
class	_STLP_alloc_proxy
struct	add_const
struct	add_cv
struct	add_lvalue_reference
struct	add_lvalue_reference< t_TYPE & >
struct	add_lvalue_reference< void >
struct	add_lvalue_reference< void const >
struct	add_lvalue_reference< void const volatile >
struct	add_lvalue_reference< void volatile >
struct	add_pointer
struct	add_pointer< t_TYPE & >
struct	add_volatile
class	allocator
class	allocator< void >
struct	allocator_traits
struct	allocator_traits< allocator< TYPE > >
struct	allocator_traits< ALLOCATOR_TYPE * >
struct	allocator_traits< polymorphic_allocator< TYPE > >
struct	array
class	basic_istringstream
class	basic_ostringstream
class	basic_osyncstream
class	basic_string
class	basic_string_view
class	basic_stringbuf
class	basic_stringstream
class	basic_syncbuf
struct	BasicStringView_IsCompatibleIterator
struct	BasicStringView_IsCompatibleSentinel
class	binary_compose
class	bitset
class	Bitset_ImpBase
class	Bitset_ImpBase< BITSETSIZE, 1 >
class	Bitset_ImpBase< BITSETSIZE, 2 >
struct	Bitset_ImpUtil
struct	ComparatorSelector
struct	ComparatorSelector< const char * >
struct	conditional
struct	conditional< false, t_TRUE_TYPE, t_FALSE_TYPE >
struct	conjunction
struct	conjunction< B1 >
struct	conjunction< B1, B2, Bn... >
struct	conjunction<>
class	decay
struct	decay_imp
struct	decay_imp< t_TYPE, false, true >
struct	decay_imp< t_TYPE, true, false >
class	default_searcher
class	deque
class	Deque_Base
class	Deque_BlockCreator
struct	Deque_BlockLengthCalcUtil
class	Deque_BlockProctor
class	Deque_ClearGuard
class	Deque_Guard
struct	Deque_Util
struct	disjunction
struct	disjunction< B1 >
struct	disjunction< B1, B2, Bn... >
struct	disjunction<>
struct	EffectiveFromType
struct	enable_if
struct	enable_if< false, t_TYPE >
class	enable_shared_from_this
struct	equal_to
struct	equal_to< void >
class	function
	Forward declaration. More...
struct	hash
struct	hash< basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > >
struct	hash< basic_string_view< CHAR_TYPE, CHAR_TRAITS > >
struct	hash< bool >
	Specialization of hash for bool values. More...
struct	hash< char >
	Specialization of hash for char values. More...
struct	hash< const BSLSTL_KEY >
struct	hash< int >
	Specialization of hash for int values. More...
struct	hash< long >
	Specialization of hash for long values. More...
struct	hash< long long >
	Specialization of hash for long long values. More...
struct	hash< short >
	Specialization of hash for short values. More...
struct	hash< signed char >
	Specialization of hash for signed char values. More...
struct	hash< unsigned char >
	Specialization of hash for unsigned char values. More...
struct	hash< unsigned int >
	Specialization of hash for unsigned int values. More...
struct	hash< unsigned long >
	Specialization of hash for unsigned long values. More...
struct	hash< unsigned long long >
	Specialization of hash for unsigned long long values. More...
struct	hash< unsigned short >
	Specialization of hash for unsigned short values. More...
struct	hash< wchar_t >
	Specialization of hash for wchar_t values. More...
class	hash_map
class	hash_multimap
class	hash_multiset
class	hash_set
class	hashtable
struct	in_place_index_t
struct	in_place_t
struct	in_place_type_t
struct	integral_constant
struct	integral_constant< bool, t_VAL >
class	invoke_result
struct	is_arithmetic
struct	is_array
struct	is_array< t_TYPE[]>
struct	is_array< t_TYPE[t_NUM_ELEMENTS]>
struct	is_bounded_array
struct	is_bounded_array< t_TYPE[t_NUM_ELEMENTS]>
struct	is_class
struct	is_const
struct	is_const< const t_TYPE >
struct	is_convertible
struct	is_convertible_dispatch
struct	is_convertible_dispatch< const t_TYPE &, const t_TYPE & >
struct	is_convertible_dispatch< const t_TYPE &, const volatile t_TYPE & >
struct	is_convertible_dispatch< const t_TYPE &, t_TYPE & >
struct	is_convertible_dispatch< const t_TYPE &, volatile t_TYPE & >
struct	is_convertible_dispatch< const t_TYPE, const t_TYPE & >
struct	is_convertible_dispatch< const t_TYPE, const volatile t_TYPE & >
struct	is_convertible_dispatch< const t_TYPE, t_TYPE & >
struct	is_convertible_dispatch< const t_TYPE, volatile t_TYPE & >
struct	is_convertible_dispatch< const volatile t_TYPE &, const t_TYPE & >
struct	is_convertible_dispatch< const volatile t_TYPE &, const volatile t_TYPE & >
struct	is_convertible_dispatch< const volatile t_TYPE &, t_TYPE & >
struct	is_convertible_dispatch< const volatile t_TYPE &, volatile t_TYPE & >
struct	is_convertible_dispatch< const volatile t_TYPE, const t_TYPE & >
struct	is_convertible_dispatch< const volatile t_TYPE, const volatile t_TYPE & >
struct	is_convertible_dispatch< const volatile t_TYPE, t_TYPE & >
struct	is_convertible_dispatch< const volatile t_TYPE, volatile t_TYPE & >
struct	is_convertible_dispatch< t_FROM_TYPE, const volatile t_TO_TYPE & >
struct	is_convertible_dispatch< t_FROM_TYPE, volatile t_TO_TYPE & >
struct	is_convertible_dispatch< t_TYPE &, const t_TYPE & >
struct	is_convertible_dispatch< t_TYPE &, const volatile t_TYPE & >
struct	is_convertible_dispatch< t_TYPE &, t_TYPE & >
struct	is_convertible_dispatch< t_TYPE &, volatile t_TYPE & >
struct	is_convertible_dispatch< t_TYPE, const t_TYPE & >
struct	is_convertible_dispatch< t_TYPE, const volatile t_TYPE & >
struct	is_convertible_dispatch< t_TYPE, t_TYPE & >
struct	is_convertible_dispatch< t_TYPE, volatile t_TYPE & >
struct	is_convertible_dispatch< volatile t_FROM_TYPE &, const volatile t_TO_TYPE & >
struct	is_convertible_dispatch< volatile t_FROM_TYPE &, t_TO_TYPE >
struct	is_convertible_dispatch< volatile t_FROM_TYPE &, volatile t_TO_TYPE & >
struct	is_convertible_dispatch< volatile t_TYPE &, const t_TYPE & >
struct	is_convertible_dispatch< volatile t_TYPE &, const volatile t_TYPE & >
struct	is_convertible_dispatch< volatile t_TYPE &, t_TYPE & >
struct	is_convertible_dispatch< volatile t_TYPE &, volatile t_TYPE & >
struct	is_convertible_dispatch< volatile t_TYPE, const t_TYPE & >
struct	is_convertible_dispatch< volatile t_TYPE, const volatile t_TYPE & >
struct	is_convertible_dispatch< volatile t_TYPE, t_TYPE & >
struct	is_convertible_dispatch< volatile t_TYPE, t_TYPE >
struct	is_convertible_dispatch< volatile t_TYPE, volatile t_TYPE & >
struct	is_copy_constructible
struct	is_copy_constructible< BloombergLP::bsltf::MoveOnlyAllocTestType >
struct	is_copy_constructible< BloombergLP::bsltf::WellBehavedMoveOnlyAllocTestType >
struct	is_copy_constructible< const t_TYPE >
struct	is_copy_constructible< const t_TYPE[]>
struct	is_copy_constructible< const t_TYPE[t_LEN]>
struct	is_copy_constructible< const volatile t_TYPE[]>
struct	is_copy_constructible< const volatile t_TYPE[t_LEN]>
struct	is_copy_constructible< t_TYPE[]>
struct	is_copy_constructible< t_TYPE[t_LEN]>
struct	is_copy_constructible< volatile t_TYPE[]>
struct	is_copy_constructible< volatile t_TYPE[t_LEN]>
struct	is_empty
struct	is_empty< const t_TYPE >
struct	is_empty< const volatile t_TYPE >
struct	is_empty< volatile t_TYPE >
struct	Is_Empty_Class_Imp
struct	Is_Empty_Class_Imp< t_TYPE, true >
struct	Is_Empty_Imp
struct	Is_Empty_Imp< t_TYPE, BSLMF_VOIDTYPE(int t_TYPE::*)>
struct	Is_Empty_Size
struct	is_enum
struct	is_enum< const t_TYPE >
struct	is_enum< const volatile t_TYPE >
struct	is_enum< t_TYPE * >
struct	is_enum< void >
struct	is_enum< volatile t_TYPE >
struct	is_floating_point
struct	is_function
struct	is_function< t_TYPE & >
struct	is_fundamental
struct	is_integral
struct	is_lvalue_reference
struct	is_member_function_pointer
struct	is_member_function_pointer< t_TYPE t_CLASS::* >
struct	is_member_function_pointer< t_TYPE t_CLASS::*const >
struct	is_member_function_pointer< t_TYPE t_CLASS::*const volatile >
struct	is_member_function_pointer< t_TYPE t_CLASS::*volatile >
struct	is_member_object_pointer
struct	is_member_object_pointer< t_TYPE t_CLASS::* >
struct	is_member_object_pointer< t_TYPE t_CLASS::*const >
struct	is_member_object_pointer< t_TYPE t_CLASS::*const volatile >
struct	is_member_object_pointer< t_TYPE t_CLASS::*volatile >
struct	is_member_pointer
struct	is_member_pointer< t_TARGET_TYPE t_HOST_TYPE::* >
struct	is_member_pointer< t_TARGET_TYPE t_HOST_TYPE::*const >
struct	is_member_pointer< t_TARGET_TYPE t_HOST_TYPE::*const volatile >
struct	is_member_pointer< t_TARGET_TYPE t_HOST_TYPE::*volatile >
struct	is_nothrow_move_constructible
struct	is_nothrow_move_constructible< BloombergLP::bdlb::ScopeExit< EXIT_FUNC > >
struct	is_nothrow_move_constructible< BloombergLP::bslma::ManagedPtr< TARGET_TYPE > >
struct	is_nothrow_move_constructible< BloombergLP::bsltf::WellBehavedMoveOnlyAllocTestType >
struct	is_pointer
struct	is_pointer< t_TYPE * >
struct	is_pointer< t_TYPE *const >
struct	is_pointer< t_TYPE *const volatile >
struct	is_pointer< t_TYPE *volatile >
struct	is_polymorphic
struct	is_reference
struct	is_reference< t_TYPE & >
struct	is_rvalue_reference
struct	is_same
struct	is_same< t_TYPE, t_TYPE >
struct	is_trivially_copyable
struct	is_trivially_copyable< ::BloombergLP::bslh::Hash< TYPE > >
struct	is_trivially_copyable< BloombergLP::bdlde::Base64DecoderOptions >
struct	is_trivially_copyable< BloombergLP::bdlde::Base64EncoderOptions >
struct	is_trivially_copyable< BloombergLP::bslmf::Nil >
struct	is_trivially_copyable< BloombergLP::bsls::TimeInterval >
struct	is_trivially_copyable< BloombergLP::bslstl::TreeIterator< VALUE, NODE, DIFFERENCE_TYPE > >
struct	is_trivially_copyable< const t_TYPE >
struct	is_trivially_copyable< const t_TYPE[]>
struct	is_trivially_copyable< const t_TYPE[t_LEN]>
struct	is_trivially_copyable< const volatile t_TYPE >
struct	is_trivially_copyable< const volatile t_TYPE[]>
struct	is_trivially_copyable< const volatile t_TYPE[t_LEN]>
struct	is_trivially_copyable< equal_to< VALUE_TYPE > >
struct	is_trivially_copyable< hash< TYPE > >
struct	is_trivially_copyable< owner_equal >
struct	is_trivially_copyable< owner_hash >
struct	is_trivially_copyable< owner_less< POINTER_TYPE > >
struct	is_trivially_copyable< pair< T1, T2 > >
struct	is_trivially_copyable< polymorphic_allocator< TYPE > >
struct	is_trivially_copyable< t_TYPE & >
struct	is_trivially_copyable< t_TYPE[]>
struct	is_trivially_copyable< t_TYPE[t_LEN]>
struct	is_trivially_copyable< type_index >
struct	is_trivially_copyable< volatile t_TYPE >
struct	is_trivially_copyable< volatile t_TYPE[]>
struct	is_trivially_copyable< volatile t_TYPE[t_LEN]>
struct	is_trivially_default_constructible
struct	is_trivially_default_constructible< ::BloombergLP::bslh::Hash< TYPE > >
struct	is_trivially_default_constructible< bsl::pair< T1, T2 > >
struct	is_trivially_default_constructible< const t_TYPE >
struct	is_trivially_default_constructible< const t_TYPE[]>
struct	is_trivially_default_constructible< const t_TYPE[t_LEN]>
struct	is_trivially_default_constructible< const volatile t_TYPE >
struct	is_trivially_default_constructible< const volatile t_TYPE[]>
struct	is_trivially_default_constructible< const volatile t_TYPE[t_LEN]>
struct	is_trivially_default_constructible< equal_to< VALUE_TYPE > >
struct	is_trivially_default_constructible< hash< TYPE > >
struct	is_trivially_default_constructible< owner_equal >
struct	is_trivially_default_constructible< owner_hash >
struct	is_trivially_default_constructible< owner_less< POINTER_TYPE > >
struct	is_trivially_default_constructible< t_TYPE[]>
struct	is_trivially_default_constructible< t_TYPE[t_LEN]>
struct	is_trivially_default_constructible< volatile t_TYPE >
struct	is_trivially_default_constructible< volatile t_TYPE[]>
struct	is_trivially_default_constructible< volatile t_TYPE[t_LEN]>
struct	is_unbounded_array
struct	is_unbounded_array< t_TYPE[]>
struct	is_void
struct	is_void< const void >
struct	is_void< const volatile void >
struct	is_void< void >
struct	is_void< volatile void >
struct	is_volatile
struct	is_volatile< volatile t_TYPE >
class	list
	Forward declaration required by List_NodeProctor. More...
class	List_AllocAndSizeWrapper
struct	List_DefaultLessThan
class	List_Iterator
class	List_Node
class	List_NodeProctor
class	map
class	memory_resource
struct	monostate
class	multimap
class	multiset
struct	negation
struct	nostopstate_t
struct	nullopt_t
class	optional
struct	owner_equal
struct	owner_hash
struct	owner_less
struct	owner_less< shared_ptr< ELEMENT_TYPE > >
struct	owner_less< void >
struct	owner_less< weak_ptr< ELEMENT_TYPE > >
class	pair
struct	Pair_BslmaIdiom
struct	Pair_First
struct	Pair_First< TYPE & >
struct	Pair_ImpUtil
struct	Pair_Second
struct	Pair_Second< TYPE & >
class	polymorphic_allocator
class	priority_queue
class	queue
struct	remove_const
struct	remove_const< t_TYPE const >
struct	remove_cv
struct	remove_cvref
struct	remove_extent
struct	remove_extent< t_TYPE[]>
	Specialization of remove_extent for array of unknown bound. More...
struct	remove_extent< t_TYPE[t_SZ]>
	Specialization of remove_extent for array of known bound. More...
struct	remove_pointer
struct	remove_volatile
struct	remove_volatile< t_TYPE volatile >
struct	select1st
	public type names More...
struct	select2nd
	public type names More...
class	set
class	shared_ptr
class	slist
class	span
class	span< TYPE, dynamic_extent >
struct	Span_Utility
class	stack
class	stop_callback
class	stop_source
class	stop_token
class	String_ClearProctor
class	String_Imp
struct	String_IsConvertibleToCString
struct	String_IsConvertibleToCString< CHAR_TYPE, const CHAR_TYPE(&)[]>
struct	String_IsConvertibleToStringView
struct	String_IsConvertibleToStringView< CHAR_TYPE, CHAR_TRAITS, const CHAR_TYPE(&)[]>
class	StringBufContainer
struct	StringComparator
struct	SyncBuf_MutexUtil
	Internal mutex-related utils. More...
struct	type_identity
	Metafunction returning t_TYPE unchanged. More...
class	type_index
class	unary_compose
class	unordered_map
class	unordered_multimap
class	unordered_multiset
class	unordered_set
struct	uses_allocator
class	variant
struct	variant_alternative
struct	variant_alternative< t_INDEX, const t_TYPE >
struct	variant_alternative< t_INDEX, const volatile t_TYPE >
struct	variant_alternative< t_INDEX, variant< t_HEAD, t_TAIL... > >
struct	variant_alternative< t_INDEX, volatile t_TYPE >
struct	Variant_GetIndexReturnType
struct	Variant_GetIndexReturnType< t_INDEX, t_ARG, bsl::variant< t_HEAD, t_TAIL... > >
struct	Variant_GetIndexReturnTypeImpl
struct	Variant_GetIndexReturnTypeImpl< true, t_INDEX, BloombergLP::bslmf::MovableRef< t_VARIANT >, t_VARIANT >
struct	Variant_GetIndexReturnTypeImpl< true, t_INDEX, const t_VARIANT, t_VARIANT >
struct	Variant_GetIndexReturnTypeImpl< true, t_INDEX, t_VARIANT, t_VARIANT >
struct	Variant_GetTypeReturnType
struct	Variant_GetTypeReturnType< t_TYPE, bsl::variant< t_HEAD, t_TAIL... > >
struct	variant_size
struct	variant_size< const t_BSL_VARIANT >
struct	variant_size< const volatile t_BSL_VARIANT >
struct	variant_size< variant< t_HEAD, t_TAIL... > >
struct	variant_size< volatile t_BSL_VARIANT >
struct	Variant_VariantAlternativeImpl
struct	Variant_VariantAlternativeImpl< 0, BSLSTL_VARIANT_NOT_A_TYPE >
struct	Variant_VariantAlternativeImpl< 0, t_HEAD, t_TAIL... >
struct	Variant_VariantAlternativeImpl< t_INDEX, BSLSTL_VARIANT_NOT_A_TYPE >
class	vector
class	vector< VALUE_TYPE *, ALLOCATOR >
struct	Vector_DeduceIteratorCategory
struct	Vector_DeduceIteratorCategory< BSLSTL_ITERATOR, true >
struct	vector_ForwardIteratorForPtrs
struct	vector_ForwardIteratorForPtrs< TARGET, ITERATOR, false >
class	Vector_PushProctor
class	vector_UintPtrConversionIterator
struct	Vector_Util
class	vectorBase
class	weak_ptr

Typedefs
typedef integral_constant< bool, false >	false_type
typedef integral_constant< bool, true >	true_type
typedef BloombergLP::bsls::Nullptr_Impl::Type	nullptr_t
typedef ::BloombergLP::bslstl::BadWeakPtr	bad_weak_ptr
typedef std::errc	ErrcEnum
typedef basic_stringbuf< char, char_traits< char >, allocator< char > >	stringbuf
typedef basic_istringstream< char, char_traits< char >, allocator< char > >	istringstream
typedef basic_ostringstream< char, char_traits< char >, allocator< char > >	ostringstream
typedef basic_stringstream< char, char_traits< char >, allocator< char > >	stringstream
typedef basic_stringbuf< wchar_t, char_traits< wchar_t >, allocator< wchar_t > >	wstringbuf
typedef basic_istringstream< wchar_t, char_traits< wchar_t >, allocator< wchar_t > >	wistringstream
typedef basic_ostringstream< wchar_t, char_traits< wchar_t >, allocator< wchar_t > >	wostringstream
typedef basic_stringstream< wchar_t, char_traits< wchar_t >, allocator< wchar_t > >	wstringstream
typedef basic_syncbuf< char >	syncbuf
typedef basic_syncbuf< wchar_t >	wsyncbuf
typedef basic_osyncstream< char >	osyncstream
typedef basic_osyncstream< wchar_t >	wosyncstream
typedef bsl::integral_constant< int, 0 >	Pair_BslmaIdiomNone
typedef bsl::integral_constant< int, 1 >	Pair_BslmaIdiomAtEnd
typedef bsl::integral_constant< int, 2 >	Pair_BslmaIdiomAllocatorArgT
typedef basic_string< char >	string
typedef basic_string< wchar_t >	wstring
typedef basic_string_view< char >	string_view
typedef basic_string_view< wchar_t >	wstring_view
typedef BloombergLP::bsls::BslLock	SyncBuf_Mutex
typedef void(*	__oom_handler_type) ()
typedef _Stl_prime< bool >	_Stl_prime_type
typedef _Sl_global< bool >	_Sl_global_inst

Enumerations
enum	{ dynamic_extent = size_t(-1) }
enum	MaxDecimalStringLengths {   e_MAX_SHORT_STRLEN10 = 2 + sizeof(short) * 3 , e_MAX_INT_STRLEN10 = 2 + sizeof(int) * 3 , e_MAX_INT64_STRLEN10 = 26 , e_MAX_FLOAT_STRLEN10 = 48 ,   e_MAX_DOUBLE_STRLEN10 = 318 , e_MAX_LONGDOUBLE_STRLEN10 = 318 , e_MAX_SCALAR_STRLEN10 = e_MAX_INT64_STRLEN10 }
enum	{ _ALIGN = 8 , _ALIGN_SHIFT =3 , _MAX_BYTES = 128 }

Functions
void	PrintTo (const string &value, ostream *stream)
void	PrintTo (const wstring &value, ostream *stream)
void	PrintTo (const BloombergLP::bslstl::StringRef &value, ostream *stream)
template<class TYPE >
void	PrintTo (const optional< TYPE > &value, ostream *stream)
bool	operator== (const memory_resource &a, const memory_resource &b)
bool	operator!= (const memory_resource &a, const memory_resource &b)
template<class T1 , class T2 >
bool	operator== (const polymorphic_allocator< T1 > &a, const polymorphic_allocator< T2 > &b) BSLS_KEYWORD_NOEXCEPT
template<class T1 , class T2 >
bool	operator!= (const polymorphic_allocator< T1 > &a, const polymorphic_allocator< T2 > &b) BSLS_KEYWORD_NOEXCEPT
template<class TYPE , class COMPARE >
BSLS_KEYWORD_CONSTEXPR_CPP14 const TYPE &	clamp (const TYPE &value, const TYPE &low, const TYPE &high, COMPARE comp)
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR_CPP14 const TYPE &	clamp (const TYPE &value, const TYPE &low, const TYPE &high)
template<class FORWARD_ITERATOR , class SEARCHER >
BSLS_KEYWORD_CONSTEXPR_CPP14 FORWARD_ITERATOR	search (FORWARD_ITERATOR first, FORWARD_ITERATOR last, const SEARCHER &searcher)
template<class VALUE_TYPE , size_t SIZE>
bool	operator== (const array< VALUE_TYPE, SIZE > &lhs, const array< VALUE_TYPE, SIZE > &rhs)
template<class VALUE_TYPE , size_t SIZE>
bool	operator!= (const array< VALUE_TYPE, SIZE > &lhs, const array< VALUE_TYPE, SIZE > &rhs)
template<class VALUE_TYPE , size_t SIZE>
bool	operator< (const array< VALUE_TYPE, SIZE > &lhs, const array< VALUE_TYPE, SIZE > &rhs)
template<class VALUE_TYPE , size_t SIZE>
bool	operator> (const array< VALUE_TYPE, SIZE > &lhs, const array< VALUE_TYPE, SIZE > &rhs)
template<class VALUE_TYPE , size_t SIZE>
bool	operator<= (const array< VALUE_TYPE, SIZE > &lhs, const array< VALUE_TYPE, SIZE > &rhs)
template<class VALUE_TYPE , size_t SIZE>
bool	operator>= (const array< VALUE_TYPE, SIZE > &lhs, const array< VALUE_TYPE, SIZE > &rhs)
template<class VALUE_TYPE , size_t SIZE>
void	swap (array< VALUE_TYPE, SIZE > &lhs, array< VALUE_TYPE, SIZE > &rhs)
template<size_t INDEX, class TYPE , size_t SIZE>
BSLS_KEYWORD_CONSTEXPR_CPP14 TYPE &	get (array< TYPE, SIZE > &a) BSLS_KEYWORD_NOEXCEPT
template<size_t INDEX, class TYPE , size_t SIZE>
BSLS_KEYWORD_CONSTEXPR const TYPE &	get (const array< TYPE, SIZE > &a) BSLS_KEYWORD_NOEXCEPT
template<class HASH_ALGORITHM , class TYPE , size_t SIZE>
void	hashAppend (HASH_ALGORITHM &hashAlgorithm, const array< TYPE, SIZE > &input)
	Pass the specified input to the specified hashAlgorithm
template<class TYPE , std::size_t SIZE>
BSLS_KEYWORD_CONSTEXPR_CPP14 array< typename remove_cv< TYPE >::type, SIZE >	to_array (TYPE(&src)[SIZE])
template<std::size_t N>
bitset< N >	operator& (const bitset< N > &lhs, const bitset< N > &rhs) BSLS_KEYWORD_NOEXCEPT
template<std::size_t N>
bitset< N >	operator| (const bitset< N > &lhs, const bitset< N > &rhs) BSLS_KEYWORD_NOEXCEPT
template<std::size_t N>
bitset< N >	operator^ (const bitset< N > &lhs, const bitset< N > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class TRAITS , std::size_t N>
std::basic_istream< CHAR_TYPE, TRAITS > &	operator>> (std::basic_istream< CHAR_TYPE, TRAITS > &is, bitset< N > &x)
template<class CHAR_TYPE , class TRAITS , std::size_t N>
std::basic_ostream< CHAR_TYPE, TRAITS > &	operator<< (std::basic_ostream< CHAR_TYPE, TRAITS > &os, const bitset< N > &x)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator== (const deque< VALUE_TYPE, ALLOCATOR > &lhs, const deque< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator!= (const deque< VALUE_TYPE, ALLOCATOR > &lhs, const deque< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator< (const deque< VALUE_TYPE, ALLOCATOR > &lhs, const deque< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator> (const deque< VALUE_TYPE, ALLOCATOR > &lhs, const deque< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator<= (const deque< VALUE_TYPE, ALLOCATOR > &lhs, const deque< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator>= (const deque< VALUE_TYPE, ALLOCATOR > &lhs, const deque< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR , class BDE_OTHER_TYPE >
deque< VALUE_TYPE, ALLOCATOR >::size_type	erase (deque< VALUE_TYPE, ALLOCATOR > &deq, const BDE_OTHER_TYPE &value)
template<class VALUE_TYPE , class ALLOCATOR , class PREDICATE >
deque< VALUE_TYPE, ALLOCATOR >::size_type	erase_if (deque< VALUE_TYPE, ALLOCATOR > &deq, PREDICATE predicate)
template<class VALUE_TYPE , class ALLOCATOR >
void	swap (deque< VALUE_TYPE, ALLOCATOR > &a, deque< VALUE_TYPE, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
int	uncaught_exceptions () throw ()
template<class PROTOTYPE >
bool	operator== (const function< PROTOTYPE > &, nullptr_t) BSLS_KEYWORD_NOEXCEPT
template<class PROTOTYPE >
bool	operator== (nullptr_t, const function< PROTOTYPE > &) BSLS_KEYWORD_NOEXCEPT
	Return true if the function argument is empty, otherwise return false.
template<class PROTOTYPE >
bool	operator!= (const function< PROTOTYPE > &, nullptr_t) BSLS_KEYWORD_NOEXCEPT
template<class PROTOTYPE >
bool	operator!= (nullptr_t, const function< PROTOTYPE > &) BSLS_KEYWORD_NOEXCEPT
	Return false if the function argument is empty, otherwise return true.
template<class PROTOTYPE >
void	swap (function< PROTOTYPE > &a, function< PROTOTYPE > &b) BSLS_KEYWORD_NOEXCEPT
template<class T >
T::iterator	begin (T &container)
template<class T >
T::const_iterator	begin (const T &container)
template<class T , size_t N>
T *	begin (T(&array)[N])
template<class T , size_t N>
const T *	begin (const T(&array)[N])
template<class T >
T::iterator	end (T &container)
template<class T >
T::const_iterator	end (const T &container)
template<class T , size_t N>
T *	end (T(&array)[N])
template<class T , size_t N>
const T *	end (const T(&array)[N])
template<class T >
T::const_iterator	cbegin (const T &container)
template<class T , size_t N>
const T *	cbegin (const T(&array)[N])
template<class T >
T::reverse_iterator	rbegin (T &container)
template<class T >
T::const_reverse_iterator	rbegin (const T &container)
template<class T , size_t N>
reverse_iterator< T * >	rbegin (T(&array)[N])
template<class T >
T::const_reverse_iterator	crbegin (const T &container)
template<class T , size_t N>
reverse_iterator< const T * >	crbegin (const T(&array)[N])
template<class T >
T::const_iterator	cend (const T &container)
template<class T , size_t N>
const T *	cend (const T(&array)[N])
template<class T >
T::reverse_iterator	rend (T &container)
template<class T >
T::const_reverse_iterator	rend (const T &container)
template<class T , size_t N>
reverse_iterator< T * >	rend (T(&array)[N])
template<class T >
T::const_reverse_iterator	crend (const T &container)
template<class T , size_t N>
reverse_iterator< const T * >	crend (const T(&array)[N])
template<class CONTAINER >
BSLS_KEYWORD_CONSTEXPR CONTAINER::value_type *	data (CONTAINER &container)
template<class CONTAINER >
BSLS_KEYWORD_CONSTEXPR CONTAINER::value_type const *	data (const CONTAINER &container)
template<class CONTAINER >
BSLS_KEYWORD_CONSTEXPR bool	empty (const CONTAINER &container)
template<class TYPE , size_t DIMENSION>
BSLS_KEYWORD_CONSTEXPR bool	empty (const TYPE(&)[DIMENSION])
	Return false (Zero-length arrays are not allowed).
template<class TYPE , size_t DIMENSION>
BSLS_KEYWORD_CONSTEXPR size_t	size (const TYPE(&)[DIMENSION]) BSLS_KEYWORD_NOEXCEPT
	Return the dimension of the specified array argument.
template<class CONTAINER >
BSLS_KEYWORD_CONSTEXPR size_t	size (const CONTAINER &container)
template<class TYPE , std::ptrdiff_t DIMENSION>
BSLS_KEYWORD_CONSTEXPR std::ptrdiff_t	ssize (const TYPE(&)[DIMENSION]) BSLS_KEYWORD_NOEXCEPT
	Return the dimension of the specified array argument.
template<class CONTAINER >
BSLS_KEYWORD_CONSTEXPR std::ptrdiff_t	ssize (const CONTAINER &container)
template<class T1 , class T2 >
bool	operator== (List_Iterator< T1 > lhs, List_Iterator< T2 > rhs)
template<class T1 , class T2 >
bool	operator!= (List_Iterator< T1 > lhs, List_Iterator< T2 > rhs)
template<class VALUE , class ALLOCATOR >
bool	operator== (const list< VALUE, ALLOCATOR > &lhs, const list< VALUE, ALLOCATOR > &rhs)
template<class VALUE , class ALLOCATOR >
bool	operator!= (const list< VALUE, ALLOCATOR > &lhs, const list< VALUE, ALLOCATOR > &rhs)
template<class VALUE , class ALLOCATOR >
bool	operator< (const list< VALUE, ALLOCATOR > &lhs, const list< VALUE, ALLOCATOR > &rhs)
template<class VALUE , class ALLOCATOR >
bool	operator> (const list< VALUE, ALLOCATOR > &lhs, const list< VALUE, ALLOCATOR > &rhs)
template<class VALUE , class ALLOCATOR >
bool	operator<= (const list< VALUE, ALLOCATOR > &lhs, const list< VALUE, ALLOCATOR > &rhs)
template<class VALUE , class ALLOCATOR >
bool	operator>= (const list< VALUE, ALLOCATOR > &lhs, const list< VALUE, ALLOCATOR > &rhs)
template<class VALUE , class ALLOCATOR , class BDE_OTHER_TYPE >
list< VALUE, ALLOCATOR >::size_type	erase (list< VALUE, ALLOCATOR > &l, const BDE_OTHER_TYPE &value)
template<class VALUE , class ALLOCATOR , class PREDICATE >
list< VALUE, ALLOCATOR >::size_type	erase_if (list< VALUE, ALLOCATOR > &l, PREDICATE predicate)
template<class VALUE , class ALLOCATOR >
void	swap (list< VALUE, ALLOCATOR > &a, list< VALUE, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator== (const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator!= (const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator< (const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator> (const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator<= (const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator>= (const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR , class PREDICATE >
map< KEY, VALUE, COMPARATOR, ALLOCATOR >::size_type	erase_if (map< KEY, VALUE, COMPARATOR, ALLOCATOR > &m, PREDICATE predicate)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
void	swap (map< KEY, VALUE, COMPARATOR, ALLOCATOR > &a, map< KEY, VALUE, COMPARATOR, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
BSLS_KEYWORD_CONSTEXPR bool	operator== (monostate, monostate) BSLS_KEYWORD_NOEXCEPT
BSLS_KEYWORD_CONSTEXPR bool	operator!= (monostate, monostate) BSLS_KEYWORD_NOEXCEPT
BSLS_KEYWORD_CONSTEXPR bool	operator< (monostate, monostate) BSLS_KEYWORD_NOEXCEPT
BSLS_KEYWORD_CONSTEXPR bool	operator> (monostate, monostate) BSLS_KEYWORD_NOEXCEPT
BSLS_KEYWORD_CONSTEXPR bool	operator<= (monostate, monostate) BSLS_KEYWORD_NOEXCEPT
BSLS_KEYWORD_CONSTEXPR bool	operator>= (monostate, monostate) BSLS_KEYWORD_NOEXCEPT
template<class t_HASHALG >
void	hashAppend (t_HASHALG &hashAlg, const monostate &)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator== (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator!= (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator< (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator> (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator<= (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool	operator>= (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
void	swap (multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &a, multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator== (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator!= (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator< (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator> (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator<= (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator>= (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR , class PREDICATE >
multiset< KEY, COMPARATOR, ALLOCATOR >::size_type	erase_if (multiset< KEY, COMPARATOR, ALLOCATOR > &ms, PREDICATE predicate)
template<class KEY , class COMPARATOR , class ALLOCATOR >
void	swap (multiset< KEY, COMPARATOR, ALLOCATOR > &a, multiset< KEY, COMPARATOR, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class t_TYPE >
bsl::enable_if< BloombergLP::bslma::UsesBslmaAllocator< t_TYPE >::value, void >::type	swap (bsl::optional< t_TYPE > &lhs, bsl::optional< t_TYPE > &rhs)
template<class t_TYPE >
bsl::enable_if<!BloombergLP::bslma::UsesBslmaAllocator< t_TYPE >::value, void >::type	swap (bsl::optional< t_TYPE > &lhs, bsl::optional< t_TYPE > &rhs)
template<class t_HASHALG , class t_TYPE >
void	hashAppend (t_HASHALG &hashAlg, const optional< t_TYPE > &input)
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator== (const bsl::optional< t_LHS_TYPE > &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator!= (const bsl::optional< t_LHS_TYPE > &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator< (const bsl::optional< t_LHS_TYPE > &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator> (const bsl::optional< t_LHS_TYPE > &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator<= (const bsl::optional< t_LHS_TYPE > &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator>= (const bsl::optional< t_LHS_TYPE > &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator== (const bsl::optional< t_TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator== (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator!= (const bsl::optional< t_TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator!= (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator< (const bsl::optional< t_TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator< (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator> (const bsl::optional< t_TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator> (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator<= (const bsl::optional< t_TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator<= (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator>= (const bsl::optional< t_TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bool	operator>= (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE , class... t_ARGS>
BSLS_KEYWORD_CONSTEXPR bsl::optional< t_TYPE >	make_optional (bsl::allocator_arg_t, typename bsl::optional< t_TYPE >::allocator_type const &alloc, BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS)... args)
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bsl::optional< typename bsl::decay< t_TYPE >::type >	make_optional (BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) rhs)
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bsl::optional< t_TYPE >	make_optional ()
template<class t_TYPE , class t_ARG , class... t_ARGS>
BSLS_KEYWORD_CONSTEXPR	BSLSTL_OPTIONAL_ENABLE_IF_NOT_ALLOCATOR_TAG (t_ARG) make_optional(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARG) arg
BSLS_KEYWORD_CONSTEXPR	BSLS_COMPILERFEATURES_FORWARD_REF (t_ARGS)... args)
template<class t_DERIVED >
	BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_DERIVED (t_TYPE, t_DERIVED) &optional< t_TYPE >
template<class t_ANY_TYPE >
	BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_BSL_OPTIONAL (t_TYPE, const t_ANY_TYPE &) &optional< t_TYPE >
template<class t_ANY_TYPE >
	BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_BSL_OPTIONAL (t_TYPE, t_ANY_TYPE) &optional< t_TYPE >
template<class t_ANY_TYPE >
	BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_ANY_TYPE (t_TYPE, t_ANY_TYPE) &optional< t_TYPE >
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator== (const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator== (const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator!= (const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator!= (const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator< (const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator< (const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator> (const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator> (const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator<= (const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator<= (const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator>= (const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_LHS_TYPE , class t_RHS_TYPE >
bool	operator>= (const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP
template<class t_TYPE >
BSLS_KEYWORD_CONSTEXPR bsl::optional< typename bsl::decay< t_TYPE >::type >	make_optional (bsl::allocator_arg_t, const typename bsl::optional< typename bsl::decay< t_TYPE >::type >::allocator_type &alloc, BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) rhs)
template<class CHAR , class TRAITS >
basic_ostream< CHAR, TRAITS > &	emit_on_flush (basic_ostream< CHAR, TRAITS > &stream)
template<class CHAR , class TRAITS >
basic_ostream< CHAR, TRAITS > &	flush_emit (basic_ostream< CHAR, TRAITS > &stream)
template<class CHAR , class TRAITS >
basic_ostream< CHAR, TRAITS > &	noemit_on_flush (basic_ostream< CHAR, TRAITS > &stream)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool	operator== (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool	operator!= (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool	operator< (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool	operator> (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool	operator<= (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool	operator>= (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
void	swap (pair< T1, T2 > &a, pair< T1, T2 > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class HASHALG , class T1 , class T2 >
void	hashAppend (HASHALG &hashAlg, const pair< T1, T2 > &input)
	Pass the specified input to the specified hashAlg
template<class VALUE , class CONTAINER , class COMPARATOR >
void	swap (priority_queue< VALUE, CONTAINER, COMPARATOR > &a, priority_queue< VALUE, CONTAINER, COMPARATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class VALUE , class CONTAINER >
bool	operator== (const queue< VALUE, CONTAINER > &lhs, const queue< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator!= (const queue< VALUE, CONTAINER > &lhs, const queue< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator< (const queue< VALUE, CONTAINER > &lhs, const queue< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator> (const queue< VALUE, CONTAINER > &lhs, const queue< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator<= (const queue< VALUE, CONTAINER > &lhs, const queue< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator>= (const queue< VALUE, CONTAINER > &lhs, const queue< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
void	swap (queue< VALUE, CONTAINER > &lhs, queue< VALUE, CONTAINER > &rhs) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator== (const set< KEY, COMPARATOR, ALLOCATOR > &lhs, const set< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator!= (const set< KEY, COMPARATOR, ALLOCATOR > &lhs, const set< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator< (const set< KEY, COMPARATOR, ALLOCATOR > &lhs, const set< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator> (const set< KEY, COMPARATOR, ALLOCATOR > &lhs, const set< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator<= (const set< KEY, COMPARATOR, ALLOCATOR > &lhs, const set< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool	operator>= (const set< KEY, COMPARATOR, ALLOCATOR > &lhs, const set< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR , class PREDICATE >
set< KEY, COMPARATOR, ALLOCATOR >::size_type	erase_if (set< KEY, COMPARATOR, ALLOCATOR > &s, PREDICATE predicate)
template<class KEY , class COMPARATOR , class ALLOCATOR >
void	swap (set< KEY, COMPARATOR, ALLOCATOR > &a, set< KEY, COMPARATOR, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class LHS_TYPE , class RHS_TYPE >
bool	operator== (const shared_ptr< LHS_TYPE > &lhs, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE , class RHS_TYPE >
bool	operator!= (const shared_ptr< LHS_TYPE > &lhs, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE , class RHS_TYPE >
bool	operator< (const shared_ptr< LHS_TYPE > &lhs, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE , class RHS_TYPE >
bool	operator> (const shared_ptr< LHS_TYPE > &lhs, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE , class RHS_TYPE >
bool	operator<= (const shared_ptr< LHS_TYPE > &lhs, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE , class RHS_TYPE >
bool	operator>= (const shared_ptr< LHS_TYPE > &lhs, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE >
bool	operator== (const shared_ptr< LHS_TYPE > &lhs, nullptr_t) BSLS_KEYWORD_NOEXCEPT
template<class RHS_TYPE >
bool	operator== (nullptr_t, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE >
bool	operator!= (const shared_ptr< LHS_TYPE > &lhs, nullptr_t) BSLS_KEYWORD_NOEXCEPT
template<class RHS_TYPE >
bool	operator!= (nullptr_t, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE >
bool	operator< (const shared_ptr< LHS_TYPE > &lhs, nullptr_t) BSLS_KEYWORD_NOEXCEPT
template<class RHS_TYPE >
bool	operator< (nullptr_t, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE >
bool	operator<= (const shared_ptr< LHS_TYPE > &lhs, nullptr_t) BSLS_KEYWORD_NOEXCEPT
template<class RHS_TYPE >
bool	operator<= (nullptr_t, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE >
bool	operator> (const shared_ptr< LHS_TYPE > &lhs, nullptr_t) BSLS_KEYWORD_NOEXCEPT
template<class RHS_TYPE >
bool	operator> (nullptr_t, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE >
bool	operator>= (const shared_ptr< LHS_TYPE > &lhs, nullptr_t) BSLS_KEYWORD_NOEXCEPT
template<class RHS_TYPE >
bool	operator>= (nullptr_t, const shared_ptr< RHS_TYPE > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ELEMENT_TYPE >
std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &	operator<< (std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &stream, const shared_ptr< ELEMENT_TYPE > &rhs)
template<class HASHALG , class ELEMENT_TYPE >
void	hashAppend (HASHALG &hashAlg, const shared_ptr< ELEMENT_TYPE > &input)
template<class ELEMENT_TYPE >
void	swap (shared_ptr< ELEMENT_TYPE > &a, shared_ptr< ELEMENT_TYPE > &b) BSLS_KEYWORD_NOEXCEPT
template<class DELETER , class ELEMENT_TYPE >
DELETER *	get_deleter (const shared_ptr< ELEMENT_TYPE > &p) BSLS_KEYWORD_NOEXCEPT
template<class TO_TYPE , class FROM_TYPE >
shared_ptr< TO_TYPE >	const_pointer_cast (const shared_ptr< FROM_TYPE > &source) BSLS_KEYWORD_NOEXCEPT
template<class TO_TYPE , class FROM_TYPE >
shared_ptr< TO_TYPE >	dynamic_pointer_cast (const shared_ptr< FROM_TYPE > &source) BSLS_KEYWORD_NOEXCEPT
template<class TO_TYPE , class FROM_TYPE >
shared_ptr< TO_TYPE >	static_pointer_cast (const shared_ptr< FROM_TYPE > &source) BSLS_KEYWORD_NOEXCEPT
template<class TO_TYPE , class FROM_TYPE >
shared_ptr< TO_TYPE >	reinterpret_pointer_cast (const shared_ptr< FROM_TYPE > &source) BSLS_KEYWORD_NOEXCEPT
template<class ELEMENT_TYPE , class ALLOC , class... ARGS>
enable_if<!is_array< ELEMENT_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ELEMENT_TYPE > >::type	allocate_shared (ALLOC basicAllocator, ARGS &&... args)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_bounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared (ALLOC basicAllocator)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_bounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared (ALLOC basicAllocator, const typename remove_extent< ARRAY_TYPE >::type &value)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_unbounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared (ALLOC basicAllocator, size_t numElements)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_unbounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared (ALLOC basicAllocator, size_t numElements, const typename remove_extent< ARRAY_TYPE >::type &value)
template<class ELEMENT_TYPE , class ALLOC >
enable_if<!is_array< ELEMENT_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ELEMENT_TYPE > >::type	allocate_shared_for_overwrite (ALLOC basicAllocator)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_bounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared_for_overwrite (ALLOC basicAllocator)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_unbounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared_for_overwrite (ALLOC basicAllocator, size_t numElements)
template<class ELEMENT_TYPE , class ALLOC , class... ARGS>
enable_if<!is_array< ELEMENT_TYPE >::value, shared_ptr< ELEMENT_TYPE > >::type	allocate_shared (ALLOC *basicAllocator, ARGS &&... args)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared (ALLOC *basicAllocator)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared (ALLOC *basicAllocator, const typename remove_extent< ARRAY_TYPE >::type &value)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared (ALLOC *basicAllocator, size_t numElements)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared (ALLOC *basicAllocator, size_t numElements, const typename remove_extent< ARRAY_TYPE >::type &value)
template<class ELEMENT_TYPE , class ALLOC >
enable_if<!is_array< ELEMENT_TYPE >::value, shared_ptr< ELEMENT_TYPE > >::type	allocate_shared_for_overwrite (ALLOC *basicAllocator)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared_for_overwrite (ALLOC *basicAllocator)
template<class ARRAY_TYPE , class ALLOC >
enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	allocate_shared_for_overwrite (ALLOC *basicAllocator, size_t numElements)
template<class ELEMENT_TYPE , class... ARGS>
bsl::enable_if<!bsl::is_array< ELEMENT_TYPE >::value, bsl::shared_ptr< ELEMENT_TYPE > >::type	make_shared (ARGS &&... args)
template<class ARRAY_TYPE >
enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	make_shared ()
template<class ARRAY_TYPE >
enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	make_shared (const typename remove_extent< ARRAY_TYPE >::type &value)
template<class ARRAY_TYPE >
enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	make_shared (size_t numElements)
template<class ARRAY_TYPE >
enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	make_shared (size_t numElements, const typename remove_extent< ARRAY_TYPE >::type &value)
template<class ELEMENT_TYPE >
enable_if<!is_array< ELEMENT_TYPE >::value, shared_ptr< ELEMENT_TYPE > >::type	make_shared_for_overwrite ()
template<class ARRAY_TYPE >
enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	make_shared_for_overwrite ()
template<class ARRAY_TYPE >
enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type	make_shared_for_overwrite (size_t numElements)
template<class ELEMENT_TYPE >
void	swap (weak_ptr< ELEMENT_TYPE > &a, weak_ptr< ELEMENT_TYPE > &b) BSLS_KEYWORD_NOEXCEPT
template<class TYPE , size_t EXTENT>
BSLS_KEYWORD_CONSTEXPR_CPP14 void	swap (span< TYPE, EXTENT > &a, span< TYPE, EXTENT > &b) BSLS_KEYWORD_NOEXCEPT
template<class VALUE , class CONTAINER >
bool	operator== (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator!= (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator< (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator> (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator<= (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool	operator>= (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
void	swap (stack< VALUE, CONTAINER > &lhs, stack< VALUE, CONTAINER > &rhs) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator== (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator== (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator== (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator== (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator== (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator!= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator!= (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator!= (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator!= (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator!= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator< (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator< (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator< (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator< (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator< (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator> (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator> (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator> (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator> (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator> (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator<= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator<= (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator<= (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator<= (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator<= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator>= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator>= (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool	operator>= (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator>= (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool	operator>= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	operator+ (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 >	operator+ (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 >	operator+ (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	operator+ (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	operator+ (CHAR_TYPE lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	operator+ (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >	operator+ (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &lhs, CHAR_TYPE rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &	operator<< (std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &os, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &	operator>> (std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &is, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
void	swap (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &a, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &	getline (std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &is, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str, CHAR_TYPE delim)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &	getline (std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &is, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
int	stoi (const string &str, std::size_t *pos=0, int base=10)
int	stoi (const wstring &str, std::size_t *pos=0, int base=10)
long	stol (const string &str, std::size_t *pos=0, int base=10)
long	stol (const wstring &str, std::size_t *pos=0, int base=10)
unsigned long	stoul (const string &str, std::size_t *pos=0, int base=10)
unsigned long	stoul (const wstring &str, std::size_t *pos=0, int base=10)
long long	stoll (const string &str, std::size_t *pos=0, int base=10)
long long	stoll (const wstring &str, std::size_t *pos=0, int base=10)
unsigned long long	stoull (const string &str, std::size_t *pos=0, int base=10)
unsigned long long	stoull (const wstring &str, std::size_t *pos=0, int base=10)
float	stof (const string &str, std::size_t *pos=0)
float	stof (const wstring &str, std::size_t *pos=0)
double	stod (const string &str, std::size_t *pos=0)
double	stod (const wstring &str, std::size_t *pos=0)
long double	stold (const string &str, std::size_t *pos=0)
long double	stold (const wstring &str, std::size_t *pos=0)
string	to_string (int value)
string	to_string (long value)
string	to_string (long long value)
string	to_string (unsigned value)
string	to_string (unsigned long value)
string	to_string (unsigned long long value)
string	to_string (float value)
string	to_string (double value)
string	to_string (long double value)
wstring	to_wstring (int value)
wstring	to_wstring (long value)
wstring	to_wstring (long long value)
wstring	to_wstring (unsigned value)
wstring	to_wstring (unsigned long value)
wstring	to_wstring (unsigned long long value)
wstring	to_wstring (float value)
wstring	to_wstring (double value)
wstring	to_wstring (long double value)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class OTHER_CHAR_TYPE >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >::size_type	erase (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str, const OTHER_CHAR_TYPE &c)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class UNARY_PREDICATE >
basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >::size_type	erase_if (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str, const UNARY_PREDICATE &pred)
template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
void	hashAppend (HASHALG &hashAlg, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &input)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::size_t	hashBasicString (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
	Return a hash value for the specified str.
std::size_t	hashBasicString (const string &str)
	Return a hash value for the specified str.
std::size_t	hashBasicString (const wstring &str)
	Return a hash value for the specified str.
template<class CHAR_TYPE , class CHAR_TRAITS >
void	swap (basic_string_view< CHAR_TYPE, CHAR_TRAITS > &a, basic_string_view< CHAR_TYPE, CHAR_TRAITS > &b) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS >
std::basic_ostream< CHAR_TYPE > &	operator<< (std::basic_ostream< CHAR_TYPE > &stream, basic_string_view< CHAR_TYPE, CHAR_TRAITS > stringView)
template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS >
void	hashAppend (HASHALG &hashAlg, const basic_string_view< CHAR_TYPE, CHAR_TRAITS > &input)
template<class HASHALG >
void	hashAppend (HASHALG &hashAlg, const type_index &object)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
bool	operator== (const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
bool	operator!= (const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR , class PREDICATE >
unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR >::size_type	erase_if (unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &m, PREDICATE predicate)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
void	swap (unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &a, unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
bool	operator== (const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
bool	operator!= (const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
void	swap (unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &a, unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
bool	operator== (const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
bool	operator!= (const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR , class PREDICATE >
unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR >::size_type	erase_if (unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &ms, PREDICATE predicate)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
void	swap (unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &a, unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
bool	operator== (const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
bool	operator!= (const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR , class PREDICATE >
unordered_set< KEY, HASH, EQUAL, ALLOCATOR >::size_type	erase_if (unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &s, PREDICATE predicate)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
void	swap (unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &a, unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bsl::add_const< TYPE >::type &	as_const (TYPE &t) BSLS_KEYWORD_NOEXCEPT
	return a reference offering non-modifiable access to the specified t.
template<class t_HEAD , class... t_TAIL>
void	swap (bsl::variant< t_HEAD, t_TAIL... > &lhs, bsl::variant< t_HEAD, t_TAIL... > &rhs)
template<class t_HASHALG , class t_HEAD , class... t_TAIL>
void	hashAppend (t_HASHALG &hashAlg, const variant< t_HEAD, t_TAIL... > &input)
template<class t_TYPE , class t_HEAD , class... t_TAIL>
bool	holds_alternative (const variant< t_HEAD, t_TAIL... > &obj) BSLS_KEYWORD_NOEXCEPT
template<size_t t_INDEX, class t_VARIANT >
Variant_GetIndexReturnType< t_INDEX, t_VARIANT >::type	get (t_VARIANT &obj)
template<size_t t_INDEX, class t_VARIANT >
Variant_GetIndexReturnType< t_INDEX, BloombergLP::bslmf::MovableRef< t_VARIANT > >::type	get (BloombergLP::bslmf::MovableRef< t_VARIANT > obj)
template<class t_TYPE , class t_VARIANT >
Variant_GetTypeReturnType< t_TYPE &, t_VARIANT >::type	get (t_VARIANT &obj)
template<class t_TYPE , class t_VARIANT >
Variant_GetTypeReturnType< constt_TYPE &, t_VARIANT >::type	get (const t_VARIANT &obj)
template<class t_TYPE , class t_VARIANT >
Variant_GetTypeReturnType< BloombergLP::bslmf::MovableRef< t_TYPE >, t_VARIANT >::type	get (BloombergLP::bslmf::MovableRef< t_VARIANT > obj)
template<size_t t_INDEX, class t_VARIANT >
Variant_GetIndexReturnType< t_INDEX, t_VARIANT >::pointer	get_if (t_VARIANT *obj) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE , class t_VARIANT >
Variant_GetTypeReturnType< t_TYPE, t_VARIANT >::pointer	get_if (t_VARIANT *obj) BSLS_KEYWORD_NOEXCEPT
template<class t_TYPE , class t_VARIANT >
Variant_GetTypeReturnType< constt_TYPE, t_VARIANT >::pointer	get_if (const t_VARIANT *obj) BSLS_KEYWORD_NOEXCEPT
template<class t_HEAD , class... t_TAIL>
bool	operator== (const variant< t_HEAD, t_TAIL... > &lhs, const variant< t_HEAD, t_TAIL... > &rhs)
template<class t_HEAD , class... t_TAIL>
bool	operator!= (const variant< t_HEAD, t_TAIL... > &lhs, const variant< t_HEAD, t_TAIL... > &rhs)
template<class t_HEAD , class... t_TAIL>
bool	operator< (const variant< t_HEAD, t_TAIL... > &lhs, const variant< t_HEAD, t_TAIL... > &rhs)
template<class t_HEAD , class... t_TAIL>
bool	operator> (const variant< t_HEAD, t_TAIL... > &lhs, const variant< t_HEAD, t_TAIL... > &rhs)
template<class t_HEAD , class... t_TAIL>
bool	operator<= (const variant< t_HEAD, t_TAIL... > &lhs, const variant< t_HEAD, t_TAIL... > &rhs)
template<class t_HEAD , class... t_TAIL>
bool	operator>= (const variant< t_HEAD, t_TAIL... > &lhs, const variant< t_HEAD, t_TAIL... > &rhs)
template<class t_RET , class t_VISITOR , class t_VARIANT >
t_RET	visitR (t_VISITOR &visitor, t_VARIANT &variant)
template<class t_RET , class t_VISITOR , class t_VARIANT >
t_RET	visitR (t_VISITOR &visitor, BloombergLP::bslmf::MovableRef< t_VARIANT > variant)
template<class t_VISITOR , class t_VARIANT >
bsl::invoke_result< t_VISITOR &, typenamebsl::variant_alternative< 0, t_VARIANT >::type & >::type	visit (t_VISITOR &visitor, t_VARIANT &variant)
template<class t_VISITOR , class t_VARIANT >
bsl::invoke_result< t_VISITOR &, BloombergLP::bslmf::MovableRef< typenamebsl::variant_alternative< 0, t_VARIANT >::type > >::type	visit (t_VISITOR &visitor, BloombergLP::bslmf::MovableRef< t_VARIANT > variant)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator== (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator!= (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator< (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator> (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator<= (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR >
bool	operator>= (const vector< VALUE_TYPE, ALLOCATOR > &lhs, const vector< VALUE_TYPE, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class ALLOCATOR , class BDE_OTHER_TYPE >
vector< VALUE_TYPE, ALLOCATOR >::size_type	erase (vector< VALUE_TYPE, ALLOCATOR > &vec, const BDE_OTHER_TYPE &value)
template<class VALUE_TYPE , class ALLOCATOR , class PREDICATE >
vector< VALUE_TYPE, ALLOCATOR >::size_type	erase_if (vector< VALUE_TYPE, ALLOCATOR > &vec, PREDICATE predicate)
template<class VALUE_TYPE , class ALLOCATOR >
void	swap (vector< VALUE_TYPE, ALLOCATOR > &a, vector< VALUE_TYPE, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class HASHALG , class VALUE_TYPE , class ALLOCATOR >
void	hashAppend (HASHALG &hashAlg, const vector< VALUE_TYPE, ALLOCATOR > &input)
template<class OPERATION1 , class OPERATION2 >
unary_compose< OPERATION1, OPERATION2 >	compose1 (const OPERATION1 &fn1, const OPERATION2 &fn2)
template<class OPERATION1 , class OPERATION2 , class OPERATION3 >
binary_compose< OPERATION1, OPERATION2, OPERATION3 >	compose2 (const OPERATION1 &fn1, const OPERATION2 &fn2, const OPERATION3 &fn3)
template<class _Key , class _Tp , class _HashFcn , class _EqualKey , class _Alloc >
void	swap (hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > &lhs, hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > &rhs)
template<class _Key , class _Tp , class _HashFcn , class _EqualKey , class _Alloc >
void	swap (hash_multimap< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > &lhs, hash_multimap< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > &rhs)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
bool	operator== (const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
bool	operator!= (const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
bool	operator== (const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
bool	operator!= (const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >
void	swap (hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &lhs, hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &rhs)
template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >
void	swap (hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &lhs, hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &rhs)
template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >
bool	operator== (const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hm1, const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hm2)
template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >
bool	operator!= (const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hm1, const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hm2)
template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >
bool	operator== (const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &__hm1, const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &__hm2)
template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >
bool	operator!= (const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &__hm1, const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &__hm2)
template<class _Val , class _Traits , class _Traits1 , class _Key , class _HF , class _ExK , class _EqK , class _All >
bool	operator== (const _Ht_iterator< _Val, _Traits, _Key, _HF, _ExK, _EqK, _All > &__x, const _Ht_iterator< _Val, _Traits1, _Key, _HF, _ExK, _EqK, _All > &__y)
template<class _Val , class _Key , class _HF , class _ExK , class _EqK , class _All >
bool	operator!= (const _Hashtable_iterator< _Val, _Key, _HF, _ExK, _EqK, _All > &__x, const _Hashtable_iterator< _Val, _Key, _HF, _ExK, _EqK, _All > &__y)
template<class _Val , class _Key , class _HF , class _ExK , class _EqK , class _All >
bool	operator== (const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &__hm1, const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &__hm2)
template<class _Val , class _Key , class _HF , class _ExK , class _EqK , class _All >
bool	operator!= (const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &__hm1, const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &__hm2)
template<class _Tp , class _Alloc >
bool	operator== (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)
template<class _Tp , class _Alloc >
bool	operator< (const slist< _Tp, _Alloc > &__x, const slist< _Tp, _Alloc > &__y)
template<class _Tp , class _Alloc >
bool	operator!= (const slist< _Tp, _Alloc > &__x, const slist< _Tp, _Alloc > &__y)
template<class _Tp , class _Alloc >
bool	operator> (const slist< _Tp, _Alloc > &__x, const slist< _Tp, _Alloc > &__y)
template<class _Tp , class _Alloc >
bool	operator<= (const slist< _Tp, _Alloc > &__x, const slist< _Tp, _Alloc > &__y)
template<class _Tp , class _Alloc >
bool	operator>= (const slist< _Tp, _Alloc > &__x, const slist< _Tp, _Alloc > &__y)
_Slist_node_base *	__slist_make_link (_Slist_node_base *__prev_node, _Slist_node_base *__new_node)

Variables
const in_place_t	in_place
const nullopt_t	nullopt
template<class t_TYPE >
bool operator==(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator==(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator!=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator!=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator<(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator<(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator>(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator>(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator<=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator<=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator>=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator>=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLS_KEYWORD_CONSTEXPR bsl::optional< typename bsl::decay< t_TYPE >::type >	make_optional (bsl::allocator_arg_t, const typename bsl::optional< typename bsl::decay< t_TYPE >::type >::allocator_type &alloc, BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) rhs)
const nostopstate_t	nostopstate
BSLS_KEYWORD_INLINE_CONSTEXPR size_t	variant_npos = -1

Typedef Documentation

__oom_handler_type

typedef void(* bsl::__oom_handler_type) ()

_Sl_global_inst

typedef _Sl_global<bool> bsl::_Sl_global_inst

_Stl_prime_type

typedef _Stl_prime<bool> bsl::_Stl_prime_type

bad_weak_ptr

typedef ::BloombergLP::bslstl::BadWeakPtr bsl::bad_weak_ptr

ErrcEnum

typedef std::errc bsl::ErrcEnum

false_type

typedef integral_constant<bool, false> bsl::false_type

istringstream

typedef basic_istringstream< char, char_traits< char >, allocator< char > > bsl::istringstream

nullptr_t

typedef BloombergLP::bsls::Nullptr_Impl::Type bsl::nullptr_t

Alias for a type that can match a null pointer literal, but is not a pointer type itself.

ostringstream

typedef basic_ostringstream< char, char_traits< char >, allocator< char > > bsl::ostringstream

osyncstream

typedef basic_osyncstream< char > bsl::osyncstream

Pair_BslmaIdiomAllocatorArgT

typedef bsl::integral_constant<int, 2> bsl::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

typedef bsl::integral_constant<int, 1> bsl::Pair_BslmaIdiomAtEnd

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

Pair_BslmaIdiomNone

typedef bsl::integral_constant<int, 0> bsl::Pair_BslmaIdiomNone

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

string

typedef basic_string<char> bsl::string

string_view

typedef basic_string_view<char> bsl::string_view

stringbuf

typedef basic_stringbuf< char, char_traits< char >, allocator< char > > bsl::stringbuf

stringstream

typedef basic_stringstream< char, char_traits< char >, allocator< char > > bsl::stringstream

syncbuf

typedef basic_syncbuf< char > bsl::syncbuf

SyncBuf_Mutex

typedef BloombergLP::bsls::BslLock bsl::SyncBuf_Mutex

true_type

typedef integral_constant<bool, true> bsl::true_type

wistringstream

typedef basic_istringstream< wchar_t, char_traits< wchar_t >, allocator< wchar_t > > bsl::wistringstream

wostringstream

typedef basic_ostringstream< wchar_t, char_traits< wchar_t >, allocator< wchar_t > > bsl::wostringstream

wosyncstream

typedef basic_osyncstream< wchar_t > bsl::wosyncstream

wstring

typedef basic_string<wchar_t> bsl::wstring

wstring_view

typedef basic_string_view<wchar_t> bsl::wstring_view

wstringbuf

typedef basic_stringbuf< wchar_t, char_traits< wchar_t >, allocator< wchar_t > > bsl::wstringbuf

wstringstream

typedef basic_stringstream< wchar_t, char_traits< wchar_t >, allocator< wchar_t > > bsl::wstringstream

wsyncbuf

typedef basic_syncbuf< wchar_t > bsl::wsyncbuf

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
dynamic_extent

anonymous enum

anonymous enum

Enumerator
_ALIGN
_ALIGN_SHIFT
_MAX_BYTES

MaxDecimalStringLengths

enum bsl::MaxDecimalStringLengths

This enum give upper bounds on the maximum string lengths storing each scalar numerical type. 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.

Enumerator
e_MAX_SHORT_STRLEN10
e_MAX_INT_STRLEN10
e_MAX_INT64_STRLEN10
e_MAX_FLOAT_STRLEN10
e_MAX_DOUBLE_STRLEN10
e_MAX_LONGDOUBLE_STRLEN10
e_MAX_SCALAR_STRLEN10

Function Documentation

__slist_make_link()

_Slist_node_base * bsl::__slist_make_link ( _Slist_node_base *  __prev_node, _Slist_node_base *  __new_node  )

inline

allocate_shared() [1/10]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared

(

ALLOC *

basicAllocator

)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a bounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE object, and each element in the array is default constructed. If basicAllocator is 0, then the default allocator will be used instead.

allocate_shared() [2/10]

template<class ELEMENT_TYPE , class ALLOC , class... ARGS>

enable_if<!is_array< ELEMENT_TYPE >::value, shared_ptr< ELEMENT_TYPE > >::type bsl::allocate_shared	(	ALLOC *	basicAllocator,
		ARGS &&...	args
	)

Return a shared_ptr object referring to and managing a new ELEMENT_TYPE object. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ELEMENT_TYPE object, which is initialized using the ELEMENT_TYPE constructor that takes the specified arguments std::forward<ARGS>(args).... If ELEMENT_TYPE uses bslma allocators, then basicAllocator is passed as an extra argument in the final position. If basicAllocator is 0, then the default allocator will be used instead, and passed as the allocator, when appropriate, to the ELEMENT_TYPE constructor.

allocate_shared() [3/10]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared	(	ALLOC *	basicAllocator,
		const typename remove_extent< ARRAY_TYPE >::type &	value
	)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a bounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE object, and each element in the array is constructed from the specified value. If basicAllocator is 0, then the default allocator will be used instead.

allocate_shared() [4/10]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared	(	ALLOC *	basicAllocator,
		size_t	numElements
	)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a unbounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE containing the specified numElements number of elements, and each element in the array is default constructed. If basicAllocator is 0, then the default allocator will be used instead.

allocate_shared() [5/10]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared	(	ALLOC *	basicAllocator,
		size_t	numElements,
		const typename remove_extent< ARRAY_TYPE >::type &	value
	)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a unbounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE containing the specified numElements number of elements, and each element in the array is constructed from the specified value. If basicAllocator is 0, then the default allocator will be used instead.

allocate_shared() [6/10]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_bounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared

(

ALLOC

basicAllocator

)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a bounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE object, and each element in the array is default constructed.

allocate_shared() [7/10]

template<class ELEMENT_TYPE , class ALLOC , class... ARGS>

enable_if<!is_array< ELEMENT_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ELEMENT_TYPE > >::type bsl::allocate_shared	(	ALLOC	basicAllocator,
		ARGS &&...	args
	)

Return a shared_ptr object referring to and managing a new ELEMENT_TYPE object. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ELEMENT_TYPE object, which is initialized by calling allocator_traits<ALLOC>::construct passing basicAllocator, an ELEMENT_TYPE * pointer to space for the new shared object, and the specified arguments std::forward<ARGS>(args)....

allocate_shared() [8/10]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_bounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared	(	ALLOC	basicAllocator,
		const typename remove_extent< ARRAY_TYPE >::type &	value
	)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a bounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE object, and each element in the array is constructed from the specified value.

allocate_shared() [9/10]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_unbounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared	(	ALLOC	basicAllocator,
		size_t	numElements
	)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a unbounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE containing the specified numElements number of elements, and each element in the array is default constructed.

allocate_shared() [10/10]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_unbounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared	(	ALLOC	basicAllocator,
		size_t	numElements,
		const typename remove_extent< ARRAY_TYPE >::type &	value
	)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a unbounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE containing the specified numElements number of elements, and each element in the array is constructed from the specified value.

allocate_shared_for_overwrite() [1/6]

template<class ELEMENT_TYPE , class ALLOC >

enable_if<!is_array< ELEMENT_TYPE >::value, shared_ptr< ELEMENT_TYPE > >::type bsl::allocate_shared_for_overwrite

(

ALLOC *

basicAllocator

)

Return a shared_ptr object referring to and managing a new ELEMENT_TYPE object. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ELEMENT_TYPE object, which is default-constructed. If basicAllocator is 0, then the default allocator will be used instead.

allocate_shared_for_overwrite() [2/6]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared_for_overwrite

(

ALLOC *

basicAllocator

)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a bounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE object, and the array is default-constructed. If basicAllocator is 0, then the default allocator will be used instead.

allocate_shared_for_overwrite() [3/6]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared_for_overwrite	(	ALLOC *	basicAllocator,
		size_t	numElements
	)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a unbounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE containing the specified numElements number of elements, and the array is default-constructed. If basicAllocator is 0, then the default allocator will be used instead.

allocate_shared_for_overwrite() [4/6]

template<class ELEMENT_TYPE , class ALLOC >

enable_if<!is_array< ELEMENT_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ELEMENT_TYPE > >::type bsl::allocate_shared_for_overwrite

(

ALLOC

basicAllocator

)

Return a shared_ptr object referring to and managing a new ELEMENT_TYPE object. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ELEMENT_TYPE object, which is default-constructed.

allocate_shared_for_overwrite() [5/6]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_bounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared_for_overwrite

(

ALLOC

basicAllocator

)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a bounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE object, and the array is default-constructed.

allocate_shared_for_overwrite() [6/6]

template<class ARRAY_TYPE , class ALLOC >

enable_if< is_unbounded_array< ARRAY_TYPE >::value &&!is_pointer< ALLOC >::value, shared_ptr< ARRAY_TYPE > >::type bsl::allocate_shared_for_overwrite	(	ALLOC	basicAllocator,
		size_t	numElements
	)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a unbounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE containing the specified numElements number of elements, and the array is default-constructed.

as_const()

template<class TYPE >

BSLS_KEYWORD_CONSTEXPR bsl::add_const< TYPE >::type & bsl::as_const ( TYPE &  t )

inline

begin() [1/4]

template<class T >

T::const_iterator bsl::begin ( const T &  container )

inline

Return an iterator providing non-modifiable access to the first valid element of the specified container.

begin() [2/4]

template<class T , size_t N>

const T * bsl::begin ( const T(&)  array[N] )

inline

Return the address of the non-modifiable first element in the specified array.

begin() [3/4]

template<class T >

T::iterator bsl::begin ( T &  container )

inline

Return an iterator providing modifiable access to the first valid element of the specified container.

begin() [4/4]

template<class T , size_t N>

T * bsl::begin ( T(&)  array[N] )

inline

Return the address of the modifiable first element in the specified array.

BSLS_COMPILERFEATURES_FORWARD_REF()

BSLS_KEYWORD_CONSTEXPR bsl::BSLS_COMPILERFEATURES_FORWARD_REF

(

t_ARGS

)

BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_ANY_TYPE()

template<class t_ANY_TYPE >

bsl::BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_ANY_TYPE	(	t_TYPE	,
		t_ANY_TYPE
	)		&

BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_BSL_OPTIONAL() [1/2]

template<class t_ANY_TYPE >

bsl::BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_BSL_OPTIONAL	(	t_TYPE	,
		const t_ANY_TYPE &
	)		&

BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_BSL_OPTIONAL() [2/2]

template<class t_ANY_TYPE >

bsl::BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_BSL_OPTIONAL	(	t_TYPE	,
		t_ANY_TYPE
	)		&

BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_DERIVED()

template<class t_DERIVED >

bsl::BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_DERIVED	(	t_TYPE	,
		t_DERIVED
	)		&

BSLSTL_OPTIONAL_ENABLE_IF_NOT_ALLOCATOR_TAG()

template<class t_TYPE , class t_ARG , class... t_ARGS>

BSLS_KEYWORD_CONSTEXPR bsl::BSLSTL_OPTIONAL_ENABLE_IF_NOT_ALLOCATOR_TAG

(

t_ARG

)

Return an optional object containing a TYPE object created by invoking a bsl::optional in_place_t constructor with the specified arg and args as the constructor arguments. If t_TYPE uses an allocator, the default allocator will be used for the optional object.

cbegin() [1/2]

template<class T >

T::const_iterator bsl::cbegin ( const T &  container )

inline

Return an iterator providing non-modifiable access to the first valid element of the specified container.

cbegin() [2/2]

template<class T , size_t N>

const T * bsl::cbegin ( const T(&)  array[N] )

inline

Return the address of the non-modifiable first element in the specified array.

cend() [1/2]

template<class T >

T::const_iterator bsl::cend ( const T &  container )

inline

Return the iterator providing non-modifiable access to the position one after the last valid element in the specified container.

cend() [2/2]

template<class T , size_t N>

const T * bsl::cend ( const T(&)  array[N] )

inline

Return the address of the non-modifiable element after the last element in the specified array.

clamp() [1/2]

template<class TYPE >

BSLS_KEYWORD_CONSTEXPR_CPP14 const TYPE & bsl::clamp	(	const TYPE &	value,
		const TYPE &	low,
		const TYPE &	high
	)

Return the specified value adjusted so that it is in the range [low, high).

clamp() [2/2]

template<class TYPE , class COMPARE >

BSLS_KEYWORD_CONSTEXPR_CPP14 const TYPE & bsl::clamp	(	const TYPE &	value,
		const TYPE &	low,
		const TYPE &	high,
		COMPARE	comp
	)

Return the specified value adjusted so that it is in the range [low, high), using the specified comparison predicate comp.

compose1()

template<class OPERATION1 , class OPERATION2 >

unary_compose< OPERATION1, OPERATION2 > bsl::compose1 ( const OPERATION1 &  fn1, const OPERATION2 &  fn2  )

inline

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

template<class OPERATION1 , class OPERATION2 , class OPERATION3 >

binary_compose< OPERATION1, OPERATION2, OPERATION3 > bsl::compose2 ( const OPERATION1 &  fn1, const OPERATION2 &  fn2, const OPERATION3 &  fn3  )

inline

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

template<class TO_TYPE , class FROM_TYPE >

shared_ptr< TO_TYPE > bsl::const_pointer_cast

(

const shared_ptr< FROM_TYPE > &

source

)

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.

crbegin() [1/2]

template<class T >

T::const_reverse_iterator bsl::crbegin ( const T &  container )

inline

Return the reverse iterator providing non-modifiable access to the last valid element of the specified container.

crbegin() [2/2]

template<class T , size_t N>

reverse_iterator< const T * > bsl::crbegin ( const T(&)  array[N] )

inline

Return the reverse iterator providing non-modifiable access to the last element of the specified array.

crend() [1/2]

template<class T >

T::const_reverse_iterator bsl::crend

(

const T &

container

)

Return the reverse iterator providing non-modifiable access to the position one before the first element in the specified container.

crend() [2/2]

template<class T , size_t N>

reverse_iterator< const T * > bsl::crend ( const T(&)  array[N] )

inline

Return the reverse iterator providing non-modifiable access to the position one before the first element in the specified array.

data() [1/2]

template<class CONTAINER >

BSLS_KEYWORD_CONSTEXPR CONTAINER::value_type const * bsl::data ( const CONTAINER &  container )

inline

Return a pointer providing non-modifiable access to the first valid element of the specified container. The CONTAINER template parameter type must provide a data accessor.

data() [2/2]

template<class CONTAINER >

BSLS_KEYWORD_CONSTEXPR CONTAINER::value_type * bsl::data ( CONTAINER &  container )

inline

dynamic_pointer_cast()

template<class TO_TYPE , class FROM_TYPE >

shared_ptr< TO_TYPE > bsl::dynamic_pointer_cast

(

const shared_ptr< FROM_TYPE > &

source

)

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

template<class CHAR , class TRAITS >

basic_ostream< CHAR, TRAITS > & bsl::emit_on_flush

(

basic_ostream< CHAR, TRAITS > &

stream

)

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.

empty() [1/2]

template<class CONTAINER >

BSLS_KEYWORD_CONSTEXPR bool bsl::empty ( const CONTAINER &  container )

inline

Return whether or not the specified container contains zero elements. The CONTAINER template parameter type must provide a empty accessor.

empty() [2/2]

template<class TYPE , size_t DIMENSION>

BSLS_KEYWORD_CONSTEXPR bool bsl::empty ( const   TYPE(&)[DIMENSION] )

inline

end() [1/4]

template<class T >

T::const_iterator bsl::end ( const T &  container )

inline

Return the iterator providing non-modifiable access to the position one after the last valid element in the specified container.

end() [2/4]

template<class T , size_t N>

const T * bsl::end ( const T(&)  array[N] )

inline

Return the address of the non-modifiable element after the last element in the specified array.

end() [3/4]

template<class T >

T::iterator bsl::end ( T &  container )

inline

Return the iterator providing modifiable access to the position one after the last valid element in the specified container.

end() [4/4]

template<class T , size_t N>

T * bsl::end ( T(&)  array[N] )

inline

Return the address of the modifiable element after the last element in the specified array.

erase() [1/4]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class OTHER_CHAR_TYPE >

basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >::size_type bsl::erase	(	basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	str,
		const OTHER_CHAR_TYPE &	c
	)

Erase (in-place) all the elements from the specified str that compare equal to the specified c, and return the number of erased elements.

erase() [2/4]

template<class VALUE_TYPE , class ALLOCATOR , class BDE_OTHER_TYPE >

deque< VALUE_TYPE, ALLOCATOR >::size_type bsl::erase ( deque< VALUE_TYPE, ALLOCATOR > &  deq, const BDE_OTHER_TYPE &  value  )

inline

Erase all the elements in the specified deque deq that compare equal to the specified value. Return the number of elements erased.

erase() [3/4]

template<class VALUE , class ALLOCATOR , class BDE_OTHER_TYPE >

list< VALUE, ALLOCATOR >::size_type bsl::erase	(	list< VALUE, ALLOCATOR > &	l,
		const BDE_OTHER_TYPE &	value
	)

Erase all the elements in the specified list l that compare equal to the specified value. Return the number of elements erased.

erase() [4/4]

template<class VALUE_TYPE , class ALLOCATOR , class BDE_OTHER_TYPE >

vector< VALUE_TYPE, ALLOCATOR >::size_type bsl::erase ( vector< VALUE_TYPE, ALLOCATOR > &  vec, const BDE_OTHER_TYPE &  value  )

inline

Erase all the elements in the specified vector vec that compare equal to the specified value. Return the number of elements erased.

erase_if() [1/10]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class UNARY_PREDICATE >

basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >::size_type bsl::erase_if	(	basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	str,
		const UNARY_PREDICATE &	pred
	)

Erase (in-place) all the elements from the specified str where the specified pred returns true, and return the number of erased elements.

erase_if() [2/10]

template<class VALUE_TYPE , class ALLOCATOR , class PREDICATE >

deque< VALUE_TYPE, ALLOCATOR >::size_type bsl::erase_if ( deque< VALUE_TYPE, ALLOCATOR > &  deq, PREDICATE  predicate  )

inline

Erase all the elements in the specified deque deq that satisfy the specified predicate predicate. Return the number of elements erased.

erase_if() [3/10]

template<class VALUE , class ALLOCATOR , class PREDICATE >

list< VALUE, ALLOCATOR >::size_type bsl::erase_if	(	list< VALUE, ALLOCATOR > &	l,
		PREDICATE	predicate
	)

Erase all the elements in the specified list l that satisfy the specified predicate predicate. Return the number of elements erased.

erase_if() [4/10]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR , class PREDICATE >

map< KEY, VALUE, COMPARATOR, ALLOCATOR >::size_type bsl::erase_if	(	map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	m,
		PREDICATE	predicate
	)

Erase all the elements in the specified map m that satisfy the specified predicate predicate. Return the number of elements erased.

erase_if() [5/10]

template<class KEY , class COMPARATOR , class ALLOCATOR , class PREDICATE >

multiset< KEY, COMPARATOR, ALLOCATOR >::size_type bsl::erase_if	(	multiset< KEY, COMPARATOR, ALLOCATOR > &	ms,
		PREDICATE	predicate
	)

Erase all the elements in the specified multiset ms that satisfy the specified predicate predicate. Return the number of elements erased.

erase_if() [6/10]

template<class KEY , class COMPARATOR , class ALLOCATOR , class PREDICATE >

set< KEY, COMPARATOR, ALLOCATOR >::size_type bsl::erase_if	(	set< KEY, COMPARATOR, ALLOCATOR > &	s,
		PREDICATE	predicate
	)

Erase all the elements in the specified set s that satisfy the specified predicate predicate. Return the number of elements erased.

erase_if() [7/10]

template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR , class PREDICATE >

unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR >::size_type bsl::erase_if	(	unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	m,
		PREDICATE	predicate
	)

Erase all the elements in the specified unordered_map m that satisfy the specified predicate predicate. Return the number of elements erased.

erase_if() [8/10]

template<class KEY , class HASH , class EQUAL , class ALLOCATOR , class PREDICATE >

unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR >::size_type bsl::erase_if	(	unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &	ms,
		PREDICATE	predicate
	)

Erase all the elements in the specified unordered_multiset ms that satisfy the specified predicate predicate. Return the number of elements erased.

erase_if() [9/10]

template<class KEY , class HASH , class EQUAL , class ALLOCATOR , class PREDICATE >

unordered_set< KEY, HASH, EQUAL, ALLOCATOR >::size_type bsl::erase_if	(	unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &	s,
		PREDICATE	predicate
	)

Erase all the elements in the specified unordered_set s that satisfy the specified predicate predicate. Return the number of elements erased.

erase_if() [10/10]

template<class VALUE_TYPE , class ALLOCATOR , class PREDICATE >

vector< VALUE_TYPE, ALLOCATOR >::size_type bsl::erase_if ( vector< VALUE_TYPE, ALLOCATOR > &  vec, PREDICATE  predicate  )

inline

Erase all the elements in the specified vector vec that satisfy the specified predicate predicate. Return the number of elements erased.

flush_emit()

template<class CHAR , class TRAITS >

basic_ostream< CHAR, TRAITS > & bsl::flush_emit

(

basic_ostream< CHAR, TRAITS > &

stream

)

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.

get() [1/7]

template<size_t INDEX, class TYPE , size_t SIZE>

BSLS_KEYWORD_CONSTEXPR_CPP14 TYPE & bsl::get

(

array< TYPE, SIZE > &

a

)

Return a reference providing modifiable access to the element of the specified a, having the ordinal number specified by the (template parameter) INDEX. This function will not compile unless INDEX < N.

get() [2/7]

template<size_t t_INDEX, class t_VARIANT >

Variant_GetIndexReturnType< t_INDEX, BloombergLP::bslmf::MovableRef< t_VARIANT > >::type bsl::get

(

BloombergLP::bslmf::MovableRef< t_VARIANT >

obj

)

get() [3/7]

template<class t_TYPE , class t_VARIANT >

Variant_GetTypeReturnType< BloombergLP::bslmf::MovableRef< t_TYPE >, t_VARIANT >::type bsl::get

(

BloombergLP::bslmf::MovableRef< t_VARIANT >

obj

)

get() [4/7]

template<size_t INDEX, class TYPE , size_t SIZE>

BSLS_KEYWORD_CONSTEXPR const TYPE & bsl::get

(

const array< TYPE, SIZE > &

a

)

Return a reference providing non-modifiable access to the element of the specified a, having the ordinal number specified by the (template parameter) INDEX. This function will not compile unless INDEX < N.

get() [5/7]

template<class t_TYPE , class t_VARIANT >

Variant_GetTypeReturnType< constt_TYPE &, t_VARIANT >::type bsl::get

(

const t_VARIANT &

obj

)

get() [6/7]

template<size_t t_INDEX, class t_VARIANT >

Variant_GetIndexReturnType< t_INDEX, t_VARIANT >::type bsl::get

(

t_VARIANT &

obj

)

get() [7/7]

template<class t_TYPE , class t_VARIANT >

Variant_GetTypeReturnType< t_TYPE &, t_VARIANT >::type bsl::get

(

t_VARIANT &

obj

)

get_deleter()

template<class DELETER , class ELEMENT_TYPE >

DELETER * bsl::get_deleter

(

const shared_ptr< ELEMENT_TYPE > &

p

)

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() [1/3]

template<class t_TYPE , class t_VARIANT >

Variant_GetTypeReturnType< constt_TYPE, t_VARIANT >::pointer bsl::get_if

(

const t_VARIANT *

obj

)

get_if() [2/3]

template<size_t t_INDEX, class t_VARIANT >

Variant_GetIndexReturnType< t_INDEX, t_VARIANT >::pointer bsl::get_if

(

t_VARIANT *

obj

)

get_if() [3/3]

template<class t_TYPE , class t_VARIANT >

Variant_GetTypeReturnType< t_TYPE, t_VARIANT >::pointer bsl::get_if

(

t_VARIANT *

obj

)

getline() [1/2]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

std::basic_istream< CHAR_TYPE, CHAR_TRAITS > & bsl::getline	(	std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &	is,
		basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	str
	)

Replace the contents of the specified str string by extracting characters from the specified is stream until a newline character (is.widen('
') is extracted, and return is. The newline character is removed from the input stream but is not appended to str. If an eof is detected before the newline, then the characters up to the eof are put into str and is.eof() becomes true. If is.good() is false on entry, then do nothing, otherwise if no characters are extracted (e.g., because because the stream is at eof), str will become empty and is.fail() will become true.

getline() [2/2]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

std::basic_istream< CHAR_TYPE, CHAR_TRAITS > & bsl::getline	(	std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &	is,
		basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	str,
		CHAR_TYPE	delim
	)

Replace the contents of the specified str string by extracting characters from the specified is stream until the specified delim character is extracted, and return is. The delim character is removed from the input stream but is not appended to str. If an eof is detected before delim, then the characters up to the eof are put into str and is.eof() becomes true. If is.good() is false on entry, then do nothing, otherwise if no characters are extracted (e.g., because because the stream is at eof), str will become empty and is.fail() will become true.

hashAppend() [1/10]

template<class HASH_ALGORITHM , class TYPE , size_t SIZE>

void bsl::hashAppend	(	HASH_ALGORITHM &	hashAlgorithm,
		const array< TYPE, SIZE > &	input
	)

hashAppend() [2/10]

template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

void bsl::hashAppend	(	HASHALG &	hashAlg,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	input
	)

Pass the specified input string to the specified hashAlg hashing algorithm of the (template parameter) type HASHALG.

hashAppend() [3/10]

template<class HASHALG , class CHAR_TYPE , class CHAR_TRAITS >

void bsl::hashAppend	(	HASHALG &	hashAlg,
		const basic_string_view< CHAR_TYPE, CHAR_TRAITS > &	input
	)

Pass the specified input string to the specified hashAlg hashing algorithm of the (template parameter) type HASHALG.

hashAppend() [4/10]

template<class HASHALG , class T1 , class T2 >

void bsl::hashAppend	(	HASHALG &	hashAlg,
		const pair< T1, T2 > &	input
	)

hashAppend() [5/10]

template<class HASHALG , class ELEMENT_TYPE >

void bsl::hashAppend	(	HASHALG &	hashAlg,
		const shared_ptr< ELEMENT_TYPE > &	input
	)

Pass the address of the object referred to by the specified input shared pointer to the specified hashAlg hashing algorithm of (template parameter) type HASHALG.

hashAppend() [6/10]

template<class HASHALG >

void bsl::hashAppend	(	HASHALG &	hashAlg,
		const type_index &	object
	)

Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for type_index.

hashAppend() [7/10]

template<class HASHALG , class VALUE_TYPE , class ALLOCATOR >

void bsl::hashAppend ( HASHALG &  hashAlg, const vector< VALUE_TYPE, ALLOCATOR > &  input  )

inline

hashAppend() [8/10]

template<class t_HASHALG >

void bsl::hashAppend	(	t_HASHALG &	hashAlg,
		const monostate &
	)

Pass a monostate to the specified hashAlg, where hashAlg is a hashing algorithm.

hashAppend() [9/10]

template<class t_HASHALG , class t_TYPE >

void bsl::hashAppend	(	t_HASHALG &	hashAlg,
		const optional< t_TYPE > &	input
	)

Pass the specified input to the specified hashAlg, where hashAlg is a hashing algorithm.

hashAppend() [10/10]

template<class t_HASHALG , class t_HEAD , class... t_TAIL>

void bsl::hashAppend	(	t_HASHALG &	hashAlg,
		const variant< t_HEAD, t_TAIL... > &	input
	)

Pass the specified input to the specified hashAlg, where hashAlg is a hashing algorithm.

hashBasicString() [1/3]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

std::size_t bsl::hashBasicString

(

const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &

str

)

hashBasicString() [2/3]

std::size_t bsl::hashBasicString

(

const string &

str

)

hashBasicString() [3/3]

std::size_t bsl::hashBasicString

(

const wstring &

str

)

holds_alternative()

template<class t_TYPE , class t_HEAD , class... t_TAIL>

bool bsl::holds_alternative

(

const variant< t_HEAD, t_TAIL... > &

obj

)

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_optional() [1/4]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bsl::optional< t_TYPE > bsl::make_optional

(

)

Return an optional object containing a value-initialized t_TYPE object. If t_TYPE uses an allocator, the default allocator will be used for the optional object.

make_optional() [2/4]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bsl::optional< typename bsl::decay< t_TYPE >::type > bsl::make_optional	(	bsl::allocator_arg_t	,
		const typename bsl::optional< typename bsl::decay< t_TYPE >::type >::allocator_type &	alloc,
		BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE)	rhs
	)

make_optional() [3/4]

template<class t_TYPE , class... t_ARGS>

BSLS_KEYWORD_CONSTEXPR bsl::optional< t_TYPE > bsl::make_optional	(	bsl::allocator_arg_t	,
		typename bsl::optional< t_TYPE >::allocator_type const &	alloc,
		BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS)...	args
	)

Return an optional object containing a t_TYPE object created by invoking a bsl::optional allocator-extended in_place_t constructor with the specified alloc as the allocator argument, and specified args as constructor arguments. Note that this function will fail to compile if t_TYPE doesn't use allocators.

make_optional() [4/4]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bsl::optional< typename bsl::decay< t_TYPE >::type > bsl::make_optional

(

BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE)

rhs

)

Return an optional object containing a t_TYPE object created by invoking a bsl::optional constructor with the specified rhs as the constructor argument. If t_TYPE uses an allocator, the default allocator will be used for the optional object.

make_shared() [1/5]

template<class ARRAY_TYPE >

enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::make_shared

(

)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a bounded array. The default allocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE object, and each element in the array is default constructed.

make_shared() [2/5]

template<class ELEMENT_TYPE , class... ARGS>

bsl::enable_if<!bsl::is_array< ELEMENT_TYPE >::value, bsl::shared_ptr< ELEMENT_TYPE > >::type bsl::make_shared

(

ARGS &&...

args

)

Return a shared_ptr object referring to and managing a new ELEMENT_TYPE object. The default allocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ELEMENT_TYPE object, which is initialized using the ELEMENT_TYPE constructor that takes the specified arguments std::forward<ARGS>(args).... If ELEMENT_TYPE uses bslma allocators, then the default allocator is passed as an extra argument in the final position.

make_shared() [3/5]

template<class ARRAY_TYPE >

enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::make_shared

(

const typename remove_extent< ARRAY_TYPE >::type &

value

)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a bounded array. The default allocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE object, and each element in the array is constructed from the specified value.

make_shared() [4/5]

template<class ARRAY_TYPE >

enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::make_shared

(

size_t

numElements

)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a unbounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE containing the specified numElements number of elements, and each element in the array is default constructed.

make_shared() [5/5]

template<class ARRAY_TYPE >

enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::make_shared	(	size_t	numElements,
		const typename remove_extent< ARRAY_TYPE >::type &	value
	)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a unbounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE containing the specified numElements number of elements, and each element in the array is constructed from the specified value.

make_shared_for_overwrite() [1/3]

template<class ELEMENT_TYPE >

enable_if<!is_array< ELEMENT_TYPE >::value, shared_ptr< ELEMENT_TYPE > >::type bsl::make_shared_for_overwrite

(

)

Return a shared_ptr object referring to and managing a new ELEMENT_TYPE object. The default allocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ELEMENT_TYPE object, which is default-constructed.

make_shared_for_overwrite() [2/3]

template<class ARRAY_TYPE >

enable_if< is_bounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::make_shared_for_overwrite

(

)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a bounded array. The default allocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE object, and the array is default-constructed.

make_shared_for_overwrite() [3/3]

template<class ARRAY_TYPE >

enable_if< is_unbounded_array< ARRAY_TYPE >::value, shared_ptr< ARRAY_TYPE > >::type bsl::make_shared_for_overwrite

(

size_t

numElements

)

Return a shared_ptr object referring to and managing a new ARRAY_TYPE object, where ARRAY_TYPE is a unbounded array. The specified basicAllocator will be used to supply a single contiguous region of memory holding the returned shared pointer's internal representation and the new ARRAY_TYPE containing the specified numElements number of elements, and the array is default-constructed.

noemit_on_flush()

template<class CHAR , class TRAITS >

basic_ostream< CHAR, TRAITS > & bsl::noemit_on_flush

(

basic_ostream< CHAR, TRAITS > &

stream

)

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!=() [1/42]

template<class _Val , class _Key , class _HF , class _ExK , class _EqK , class _All >

bool bsl::operator!= ( const _Hashtable_iterator< _Val, _Key, _HF, _ExK, _EqK, _All > &  __x, const _Hashtable_iterator< _Val, _Key, _HF, _ExK, _EqK, _All > &  __y  )

inline

operator!=() [2/42]

template<class VALUE_TYPE , size_t SIZE>

bool bsl::operator!=	(	const array< VALUE_TYPE, SIZE > &	lhs,
		const array< VALUE_TYPE, SIZE > &	rhs
	)

Return true if the specified lhs does not have the same value as the specified rhs; return false otherwise. Two arrays do not have the same value if some element in the ordered sequence of elements of lhs does not have the same value as the corresponding element in the ordered sequence of elements of rhs.

operator!=() [3/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator!=	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

Return true if the specified lhs string has a different value from the specified rhs string, and false otherwise. Two strings have the same value if they have the same length, and the characters at each respective position have the same value according to CHAR_TRAITS::eq.

operator!=() [4/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator!=	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const CHAR_TYPE *	rhs
	)

operator!=() [5/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator!=	(	const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator!=() [6/42]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator!= ( const bsl::nullopt_t &  , const bsl::optional< t_TYPE > &  value  )

inline

operator!=() [7/42]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator!=	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

Initial value:

{
    if (lhs.has_value() && rhs.has_value()) {
        return *lhs == *rhs;                                          
    }
    return lhs.has_value() == rhs.has_value()

operator!=() [8/42]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator!=	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const t_RHS_TYPE &	rhs
	)

operator!=() [9/42]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator!= ( const bsl::optional< t_TYPE > &  value, const bsl::nullopt_t &    )

inline

operator!=() [10/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator!=	(	const CHAR_TYPE *	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

operator!=() [11/42]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator!= ( const deque< VALUE_TYPE, ALLOCATOR > &  lhs, const deque< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator!=() [12/42]

template<class PROTOTYPE >

bool bsl::operator!=	(	const function< PROTOTYPE > &	,
		nullptr_t
	)

operator!=() [13/42]

template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >

bool bsl::operator!= ( const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &  __hm1, const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &  __hm2  )

inline

operator!=() [14/42]

template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >

bool bsl::operator!= ( const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &  __hm1, const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &  __hm2  )

inline

operator!=() [15/42]

template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >

bool bsl::operator!= ( const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &  __hm1, const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &  __hm2  )

inline

operator!=() [16/42]

template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >

bool bsl::operator!= ( const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &  __hm1, const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &  __hm2  )

inline

operator!=() [17/42]

template<class _Val , class _Key , class _HF , class _ExK , class _EqK , class _All >

bool bsl::operator!= ( const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &  __hm1, const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &  __hm2  )

inline

operator!=() [18/42]

template<class VALUE , class ALLOCATOR >

bool bsl::operator!=	(	const list< VALUE, ALLOCATOR > &	lhs,
		const list< VALUE, ALLOCATOR > &	rhs
	)

operator!=() [19/42]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator!=	(	const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator!=() [20/42]

bool bsl::operator!=	(	const memory_resource &	a,
		const memory_resource &	b
	)

Return true if memory allocated from the specified a resource cannot be deallocated from the specified b resource; otherwise return false.

operator!=() [21/42]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator!=	(	const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator!=() [22/42]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator!=	(	const multiset< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const multiset< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

operator!=() [23/42]

template<class T1 , class T2 >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator!= ( const pair< T1, T2 > &  lhs, const pair< T1, T2 > &  rhs  )

inline

Return true if the specified lhs and rhs pair objects do not have the same value and false otherwise. lhs does not have the same value as rhs if lhs == rhs would return false. A call to this operator will not compile unless a call to lhs == rhs would compile.

operator!=() [24/42]

template<class T1 , class T2 >

bool bsl::operator!=	(	const polymorphic_allocator< T1 > &	a,
		const polymorphic_allocator< T2 > &	b
	)

Return true if memory allocated from either of the specified a or b allocators cannot necessarily be deallocated from the other; otherwise return false. Note that, when T1 and T2 are different, this free operator is a better match than the hidden friend operator, which would otherwise be ambiguous.

operator!=() [25/42]

template<class VALUE , class CONTAINER >

bool bsl::operator!= ( const queue< VALUE, CONTAINER > &  lhs, const queue< VALUE, CONTAINER > &  rhs  )

inline

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two queue objects lhs and rhs do not have the same value if they do not have the same number of elements, or some element in the ordered sequence of elements of lhs does not have the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE be equality-comparable (see {Requirements on VALUE}).

operator!=() [26/42]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator!=	(	const set< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const set< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two set objects lhs and rhs do not have the same value if they do not have the same number of keys, or some element in the ordered sequence of keys of lhs does not have the same value as the corresponding element in the ordered sequence of keys of rhs. This method requires that the (template parameter) type KEY be equality-comparable (see {Requirements on KEY}).

operator!=() [27/42]

template<class LHS_TYPE , class RHS_TYPE >

bool bsl::operator!=	(	const shared_ptr< LHS_TYPE > &	lhs,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the specified lhs shared pointer does not refer to the same object (if any) as that referred to by the specified rhs shared pointer (if any), and false otherwise; a compiler diagnostic will be emitted indicating the error unless a (raw) pointer to LHS_TYPE can be compared to a (raw) pointer to RHS_TYPE. Note that two shared pointers that do not compare equal may manage the same object due to aliasing.

operator!=() [28/42]

template<class LHS_TYPE >

bool bsl::operator!=	(	const shared_ptr< LHS_TYPE > &	lhs,
		nullptr_t
	)

Return true if the specified lhs shared pointer refers to an object, and false otherwise.

operator!=() [29/42]

template<class _Tp , class _Alloc >

bool bsl::operator!= ( const slist< _Tp, _Alloc > &  __x, const slist< _Tp, _Alloc > &  __y  )

inline

operator!=() [30/42]

template<class VALUE , class CONTAINER >

bool bsl::operator!= ( const stack< VALUE, CONTAINER > &  lhs, const stack< VALUE, CONTAINER > &  rhs  )

inline

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two stack objects lhs and rhs do not have the same value if they do not have the same number of elements, or some element in the ordered sequence of elements of lhs does not have the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE be equality-comparable (see {Requirements on VALUE}).

operator!=() [31/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator!=	(	const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator!=() [32/42]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator!=	(	const t_LHS_TYPE &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

operator!=() [33/42]

template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >

bool bsl::operator!=	(	const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	lhs,
		const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	rhs
	)

operator!=() [34/42]

template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >

bool bsl::operator!=	(	const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	lhs,
		const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	rhs
	)

operator!=() [35/42]

template<class KEY , class HASH , class EQUAL , class ALLOCATOR >

bool bsl::operator!=	(	const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &	lhs,
		const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &	rhs
	)

operator!=() [36/42]

template<class KEY , class HASH , class EQUAL , class ALLOCATOR >

bool bsl::operator!=	(	const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &	lhs,
		const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &	rhs
	)

operator!=() [37/42]

template<class t_HEAD , class... t_TAIL>

bool bsl::operator!=	(	const variant< t_HEAD, t_TAIL... > &	lhs,
		const variant< t_HEAD, t_TAIL... > &	rhs
	)

Return true if the specified lhs and rhs have different active alternatives or only one holds an alternative, or if they have the same active alternative and the contained values compare unequal; otherwise, return false. All alternatives shall support operator!=.

operator!=() [38/42]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator!= ( const vector< VALUE_TYPE, ALLOCATOR > &  lhs, const vector< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator!=() [39/42]

template<class T1 , class T2 >

bool bsl::operator!= ( bsl::List_Iterator< T1 >  lhs, bsl::List_Iterator< T2 >  rhs  )

inline

operator!=() [40/42]

BSLS_KEYWORD_CONSTEXPR bool bsl::operator!= ( monostate  , monostate    )

inline

operator!=() [41/42]

template<class PROTOTYPE >

bool bsl::operator!=	(	nullptr_t	,
		const function< PROTOTYPE > &
	)

operator!=() [42/42]

template<class RHS_TYPE >

bool bsl::operator!=	(	nullptr_t	,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the specified rhs shared pointer refers to an object, and false otherwise.

operator&()

template<std::size_t N>

bitset< N > bsl::operator&	(	const bitset< N > &	lhs,
		const bitset< N > &	rhs
	)

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

operator+() [1/7]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > bsl::operator+	(	CHAR_TYPE	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	rhs
	)

operator+() [2/7]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > bsl::operator+	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	lhs,
		CHAR_TYPE	rhs
	)

operator+() [3/7]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > bsl::operator+	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	rhs
	)

Return the concatenation of strings constructed from the specified lhs and rhs arguments, i.e., basic_string(lhs).append(rhs). The allocator of the returned string is determined per the rules in P1165 (https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1165r1.html). Note that overloads that accept rvalue references are implemented for C++11 and later only.

operator+() [4/7]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > bsl::operator+	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	lhs,
		const CHAR_TYPE *	rhs
	)

operator+() [5/7]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > bsl::operator+	(	const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator+() [6/7]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > bsl::operator+	(	const CHAR_TYPE *	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	rhs
	)

operator+() [7/7]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > bsl::operator+	(	const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator<() [1/27]

template<class VALUE_TYPE , size_t SIZE>

bool bsl::operator<	(	const array< VALUE_TYPE, SIZE > &	lhs,
		const array< VALUE_TYPE, SIZE > &	rhs
	)

Return true if the specified lhs is lexicographically less than the specified rhs by using the comparison operators of VALUE_TYPE on each element; return false otherwise.

operator<() [2/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator<	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

Return true if the specified lhs string has a lexicographically smaller value than the specified rhs string, and false otherwise. See {Lexicographical Comparisons}.

operator<() [3/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator<	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const CHAR_TYPE *	rhs
	)

operator<() [4/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator<	(	const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator<() [5/27]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator< ( const bsl::nullopt_t &  , const bsl::optional< t_TYPE > &  value  )

inline

operator<() [6/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator<	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

Initial value:

{
    if (lhs.has_value() && rhs.has_value()) {
        return *lhs != *rhs;                                          
    }
 
    return lhs.has_value() != rhs.has_value()

operator<() [7/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator<	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const t_RHS_TYPE &	rhs
	)

operator<() [8/27]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator< ( const bsl::optional< t_TYPE > &  , const bsl::nullopt_t &    )

inline

operator<() [9/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator<	(	const CHAR_TYPE *	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

operator<() [10/27]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator< ( const deque< VALUE_TYPE, ALLOCATOR > &  lhs, const deque< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator<() [11/27]

template<class VALUE , class ALLOCATOR >

bool bsl::operator<	(	const list< VALUE, ALLOCATOR > &	lhs,
		const list< VALUE, ALLOCATOR > &	rhs
	)

operator<() [12/27]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator<	(	const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator<() [13/27]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator<	(	const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator<() [14/27]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator<	(	const multiset< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const multiset< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

operator<() [15/27]

template<class T1 , class T2 >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator< ( const pair< T1, T2 > &  lhs, const pair< T1, T2 > &  rhs  )

inline

Return true if the specified lhs has a value less than the specified rhs and false otherwise. Whether or not lhs is less than rhs is determined by a lexicographical comparison of the first and second data members of lhs and rhs. In other words: return true if lhs.first < rhs.first and false if rhs.first < lhs.first, otherwise return lhs.second < rhs.second. A call to this operator will not compile unless both T1 and T2 supply operator<.

operator<() [16/27]

template<class VALUE , class CONTAINER >

bool bsl::operator< ( const queue< VALUE, CONTAINER > &  lhs, const queue< VALUE, CONTAINER > &  rhs  )

inline

Return true if the value of the specified lhs queue is lexicographically less than that of the specified rhs queue, and false otherwise. Given iterators i and j over the respective sequences [lhs.begin() .. lhs.end()) and [rhs.begin() .. rhs.end()), the value of queue lhs is lexicographically less than that of queue rhs if true == *i < *j for the first pair of corresponding iterator positions where *i < *j and *j < *i are not both false. If no such corresponding iterator position exists, the value of lhs is lexicographically less than that of rhs if lhs.size() < rhs.size(). This method requires that operator<, inducing a total order, be defined for value_type.

operator<() [17/27]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator<	(	const set< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const set< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the value of the specified lhs set is lexicographically less than that of the specified rhs set, and false otherwise. Given iterators i and j over the respective sequences [lhs.begin() .. lhs.end()) and [rhs.begin() .. rhs.end()), the value of set lhs is lexicographically less than that of set rhs if true == *i < *j for the first pair of corresponding iterator positions where *i < *j and *j < *i are not both false. If no such corresponding iterator position exists, the value of lhs is lexicographically less than that of rhs if lhs.size() < rhs.size(). This method requires that operator<, inducing a total order, be defined for value_type.

operator<() [18/27]

template<class LHS_TYPE , class RHS_TYPE >

bool bsl::operator<	(	const shared_ptr< LHS_TYPE > &	lhs,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the address of the object that the specified lhs shared pointer refers to is ordered before the address of the object that the specified rhs shared pointer refers to under the total ordering supplied by std::less<T *>, where T * is the composite pointer type of LHS_TYPE * and RHS_TYPE *, and false otherwise.

operator<() [19/27]

template<class LHS_TYPE >

bool bsl::operator<	(	const shared_ptr< LHS_TYPE > &	lhs,
		nullptr_t
	)

Return true if the address of the object referred to by the specified lhs shared pointer is ordered before the null-pointer value under the total ordering supplied by std::less<LHS_TYPE *>, and false otherwise.

operator<() [20/27]

template<class _Tp , class _Alloc >

bool bsl::operator< ( const slist< _Tp, _Alloc > &  __x, const slist< _Tp, _Alloc > &  __y  )

inline

operator<() [21/27]

template<class VALUE , class CONTAINER >

bool bsl::operator< ( const stack< VALUE, CONTAINER > &  lhs, const stack< VALUE, CONTAINER > &  rhs  )

inline

Return true if the value of the specified lhs stack is lexicographically less than that of the specified rhs stack, and false otherwise. Given iterators i and j over the respective sequences [lhs.begin() .. lhs.end()) and [rhs.begin() .. rhs.end()), the value of stack lhs is lexicographically less than that of stack rhs if true == *i < *j for the first pair of corresponding iterator positions where *i < *j and *j < *i are not both false. If no such corresponding iterator position exists, the value of lhs is lexicographically less than that of rhs if lhs.size() < rhs.size(). This method requires that operator<, inducing a total order, be defined for value_type.

operator<() [22/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator<	(	const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator<() [23/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator<	(	const t_LHS_TYPE &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

operator<() [24/27]

template<class t_HEAD , class... t_TAIL>

bool bsl::operator<	(	const variant< t_HEAD, t_TAIL... > &	lhs,
		const variant< t_HEAD, t_TAIL... > &	rhs
	)

Return true if the index of the active alternative in the specified lhs is less than that of the specified rhs, or if both have the same active alternative and the contained value of lhs compares less than that of rhs, or if lhs is valueless by exception and rhs is not; otherwise, return false. All alternatives shall support operator<.

operator<() [25/27]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator< ( const vector< VALUE_TYPE, ALLOCATOR > &  lhs, const vector< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator<() [26/27]

BSLS_KEYWORD_CONSTEXPR bool bsl::operator< ( monostate  , monostate    )

inline

operator<() [27/27]

template<class RHS_TYPE >

bool bsl::operator<	(	nullptr_t	,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the address of the object referred to by the specified rhs shared pointer is ordered after the null-pointer value under the total ordering supplied by std::less<RHS_TYPE *>, and false otherwise.

operator<<() [1/4]

template<class CHAR_TYPE , class CHAR_TRAITS >

std::basic_ostream< CHAR_TYPE > & bsl::operator<<	(	std::basic_ostream< CHAR_TYPE > &	stream,
		basic_string_view< CHAR_TYPE, CHAR_TRAITS >	stringView
	)

Write the value of the string bound to the specified stringView to the specified output stream and return a reference to the modifiable stream.

operator<<() [2/4]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > & bsl::operator<<	(	std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &	os,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	str
	)

Write the string specified by str into the output stream specified by os, and return os. If the string is shorter than os.width(), then it is padded to os.width() with the current os.fill() character. The padding, if any, is output after the string (on the right) if os.flags() | ios::left is non-zero and before the string otherwise. This function will do nothing unless os.good() is true on entry.

operator<<() [3/4]

template<class CHAR_TYPE , class CHAR_TRAITS , class ELEMENT_TYPE >

std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > & bsl::operator<<	(	std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &	stream,
		const shared_ptr< ELEMENT_TYPE > &	rhs
	)

Print to the specified stream the address of the shared object referred to by the specified rhs shared pointer and return a reference to the modifiable stream.

operator<<() [4/4]

template<class CHAR_TYPE , class TRAITS , std::size_t N>

std::basic_ostream< CHAR_TYPE, TRAITS > & bsl::operator<< ( std::basic_ostream< CHAR_TYPE, TRAITS > &  os, const bitset< N > &  x  )

inline

operator<=() [1/27]

template<class VALUE_TYPE , size_t SIZE>

bool bsl::operator<=	(	const array< VALUE_TYPE, SIZE > &	lhs,
		const array< VALUE_TYPE, SIZE > &	rhs
	)

Return true if the specified lhs is lexicographically less than the specified rhs by using the comparison operators of VALUE_TYPE on each element or if lhs and rhs are equal; return false otherwise.

operator<=() [2/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator<=	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

Return true if the specified lhs string has a value lexicographically smaller than or or equal to the specified rhs string, and false otherwise. See {Lexicographical Comparisons}.

operator<=() [3/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator<=	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const CHAR_TYPE *	rhs
	)

operator<=() [4/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator<=	(	const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator<=() [5/27]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator<= ( const bsl::nullopt_t &  , const bsl::optional< t_TYPE > &    )

inline

operator<=() [6/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator<=	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

Initial value:

{
    if (!lhs.has_value()) {
        return false;                                                 
    }
 
    return !rhs.has_value() || *lhs > *rhs

operator<=() [7/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator<=	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const t_RHS_TYPE &	rhs
	)

operator<=() [8/27]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator<= ( const bsl::optional< t_TYPE > &  value, const bsl::nullopt_t &    )

inline

operator<=() [9/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator<=	(	const CHAR_TYPE *	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

operator<=() [10/27]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator<= ( const deque< VALUE_TYPE, ALLOCATOR > &  lhs, const deque< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator<=() [11/27]

template<class VALUE , class ALLOCATOR >

bool bsl::operator<=	(	const list< VALUE, ALLOCATOR > &	lhs,
		const list< VALUE, ALLOCATOR > &	rhs
	)

operator<=() [12/27]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator<=	(	const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator<=() [13/27]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator<=	(	const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator<=() [14/27]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator<=	(	const multiset< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const multiset< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

operator<=() [15/27]

template<class T1 , class T2 >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator<= ( const pair< T1, T2 > &  lhs, const pair< T1, T2 > &  rhs  )

inline

Return true if the specified lhs has a value less than or equal to the specified rhs and false otherwise. lhs has a value less than or equal to rhs if rhs < lhs would return false. A call to this operator will not compile unless a call to lhs < rhs would compile.

operator<=() [16/27]

template<class VALUE , class CONTAINER >

bool bsl::operator<= ( const queue< VALUE, CONTAINER > &  lhs, const queue< VALUE, CONTAINER > &  rhs  )

inline

Return true if the value of the specified lhs queue is lexicographically less than or equal to that of the specified rhs queue, and false otherwise. The value of queue lhs is lexicographically less than or equal to that of queue rhs if rhs is not lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(rhs < lhs).

operator<=() [17/27]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator<=	(	const set< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const set< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the value of the specified lhs set is lexicographically less than or equal to that of the specified rhs set, and false otherwise. The value of set lhs is lexicographically less than or equal to that of set rhs if rhs is not lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(rhs < lhs).

operator<=() [18/27]

template<class LHS_TYPE , class RHS_TYPE >

bool bsl::operator<=	(	const shared_ptr< LHS_TYPE > &	lhs,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the specified lhs shared pointer refers to the same object as the specified rhs shared pointer, or if the address of the object referred to by lhs (if any) is ordered before the address of the object referred to by rhs (if any) under the total ordering supplied by std::less<T *>, where T * is the composite pointer type

operator<=() [19/27]

template<class LHS_TYPE >

bool bsl::operator<=	(	const shared_ptr< LHS_TYPE > &	lhs,
		nullptr_t
	)

Return true if the specified lhs shared pointer does not refer to an object, or if the address of the object referred to by lhs is ordered before the null-pointer value under the total ordering supplied by std::less<LHS_TYPE *>, and false otherwise.

operator<=() [20/27]

template<class _Tp , class _Alloc >

bool bsl::operator<= ( const slist< _Tp, _Alloc > &  __x, const slist< _Tp, _Alloc > &  __y  )

inline

operator<=() [21/27]

template<class VALUE , class CONTAINER >

bool bsl::operator<= ( const stack< VALUE, CONTAINER > &  lhs, const stack< VALUE, CONTAINER > &  rhs  )

inline

Return true if the value of the specified lhs stack is lexicographically less than or equal to that of the specified rhs stack, and false otherwise. The value of stack lhs is lexicographically less than or equal to that of stack rhs if rhs is not lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(rhs < lhs).

operator<=() [22/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator<=	(	const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator<=() [23/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator<=	(	const t_LHS_TYPE &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

operator<=() [24/27]

template<class t_HEAD , class... t_TAIL>

bool bsl::operator<=	(	const variant< t_HEAD, t_TAIL... > &	lhs,
		const variant< t_HEAD, t_TAIL... > &	rhs
	)

Return true if the index of the active alternative in the specified lhs is less than that of the specified rhs, or if both have the same active alternative and the contained value of lhs compares less than or equal to that of rhs, or if lhs is valueless by exception; otherwise, return false. All alternatives shall support operator<=.

operator<=() [25/27]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator<= ( const vector< VALUE_TYPE, ALLOCATOR > &  lhs, const vector< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator<=() [26/27]

BSLS_KEYWORD_CONSTEXPR bool bsl::operator<= ( monostate  , monostate    )

inline

operator<=() [27/27]

template<class RHS_TYPE >

bool bsl::operator<=	(	nullptr_t	,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the specified rhs shared pointer does not refer to an object, or if the address of the object referred to by rhs is ordered after the null-pointer value under the total ordering supplied by std::less<RHS_TYPE *>, and false otherwise.

operator==() [1/42]

template<class _Val , class _Traits , class _Traits1 , class _Key , class _HF , class _ExK , class _EqK , class _All >

bool bsl::operator== ( const _Ht_iterator< _Val, _Traits, _Key, _HF, _ExK, _EqK, _All > &  __x, const _Ht_iterator< _Val, _Traits1, _Key, _HF, _ExK, _EqK, _All > &  __y  )

inline

operator==() [2/42]

template<class VALUE_TYPE , size_t SIZE>

bool bsl::operator==	(	const array< VALUE_TYPE, SIZE > &	lhs,
		const array< VALUE_TYPE, SIZE > &	rhs
	)

Return true if the specified lhs has the same value as the specified rhs; return false otherwise. Two arrays have the same value if each element has the same value as the corresponding element in the other array.

operator==() [3/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator==	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

operator==() [4/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator==	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const CHAR_TYPE *	rhs
	)

Return true if the specified lhs string has the same value as the specified rhs string, and false otherwise. Two strings have the same value if they have the same length, and the characters at each respective position have the same value according to CHAR_TRAITS::eq.

operator==() [5/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator==	(	const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator==() [6/42]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator== ( const bsl::nullopt_t &  , const bsl::optional< t_TYPE > &  value  )

inline

operator==() [7/42]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator==	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

operator==() [8/42]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator==	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const t_RHS_TYPE &	rhs
	)

operator==() [9/42]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator== ( const bsl::optional< t_TYPE > &  value, const bsl::nullopt_t &    )

inline

Initial value:

{
    if (!rhs.has_value()) {
        return true;                                                  
    }
    return lhs.has_value() && *lhs >= *rhs

operator==() [10/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator==	(	const CHAR_TYPE *	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

operator==() [11/42]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator==	(	const deque< VALUE_TYPE, ALLOCATOR > &	lhs,
		const deque< VALUE_TYPE, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two deque objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE_TYPE be equality-comparable (see {Requirements on VALUE_TYPE}).

operator==() [12/42]

template<class PROTOTYPE >

bool bsl::operator==	(	const function< PROTOTYPE > &	,
		nullptr_t
	)

operator==() [13/42]

template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >

bool bsl::operator== ( const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &  __hm1, const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &  __hm2  )

inline

operator==() [14/42]

template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >

bool bsl::operator== ( const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &  __hm1, const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &  __hm2  )

inline

operator==() [15/42]

template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >

bool bsl::operator== ( const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &  __hm1, const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &  __hm2  )

inline

operator==() [16/42]

template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >

bool bsl::operator== ( const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &  __hm1, const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &  __hm2  )

inline

operator==() [17/42]

template<class _Val , class _Key , class _HF , class _ExK , class _EqK , class _All >

bool bsl::operator== ( const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &  __hm1, const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &  __hm2  )

inline

operator==() [18/42]

template<class VALUE , class ALLOCATOR >

bool bsl::operator==	(	const list< VALUE, ALLOCATOR > &	lhs,
		const list< VALUE, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two list objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE be equality-comparable (see {Requirements on VALUE}).

operator==() [19/42]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator==	(	const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two map objects lhs and rhs have the same value if they have the same number of key-value pairs, and each element in the ordered sequence of key-value pairs of lhs has the same value as the corresponding element in the ordered sequence of key-value pairs of rhs. This method requires that the (template parameter) types KEY and VALUE both be equality-comparable (see {Requirements on KEY and VALUE}).

operator==() [20/42]

bool bsl::operator==	(	const memory_resource &	a,
		const memory_resource &	b
	)

Return true if memory allocated from the specified a resource can be deallocated from the specified b resource; otherwise return false.

operator==() [21/42]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator==	(	const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two multimap objects lhs and rhs have the same value if they have the same number of key-value pairs, and each element in the ordered sequence of key-value pairs of lhs has the same value as the corresponding element in the ordered sequence of key-value pairs of rhs. This method requires that the (template parameter) types KEY and VALUE both be equality-comparable (see {Requirements on KEY and VALUE}).

operator==() [22/42]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator==	(	const multiset< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const multiset< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two multiset objects lhs and rhs have the same value if they have the same number of keys, and each element in the ordered sequence of keys of lhs has the same value as the corresponding element in the ordered sequence of keys of rhs. This method requires that the (template parameter) type KEY be equality-comparable (see {Requirements on KEY}).

operator==() [23/42]

template<class T1 , class T2 >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator== ( const pair< T1, T2 > &  lhs, const pair< T1, T2 > &  rhs  )

inline

Return true if the specified lhs and rhs pair objects have the same value and false otherwise. lhs has the same value as rhs if lhs.first == rhs.first and lhs.second == rhs.second. A call to this operator will not compile unless both T1 and T2 supply operator==.

operator==() [24/42]

template<class T1 , class T2 >

bool bsl::operator==	(	const polymorphic_allocator< T1 > &	a,
		const polymorphic_allocator< T2 > &	b
	)

Return true if memory allocated from either of the specified a or b allocators can be deallocated from the other; otherwise return false. Note that, when T1 and T2 are different, this free operator is a better match than the hidden friend operator, which would otherwise be ambiguous.

operator==() [25/42]

template<class VALUE , class CONTAINER >

bool bsl::operator== ( const queue< VALUE, CONTAINER > &  lhs, const queue< VALUE, CONTAINER > &  rhs  )

inline

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two queue objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE be equality-comparable (see {Requirements on VALUE}).

operator==() [26/42]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator==	(	const set< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const set< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two set objects lhs and rhs have the same value if they have the same number of keys, and each element in the ordered sequence of keys of lhs has the same value as the corresponding element in the ordered sequence of keys of rhs. This method requires that the (template parameter) type KEY be equality-comparable (see {Requirements on KEY}).

operator==() [27/42]

template<class LHS_TYPE , class RHS_TYPE >

bool bsl::operator==	(	const shared_ptr< LHS_TYPE > &	lhs,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the specified lhs shared pointer refers to the same object (if any) as that referred to by the specified rhs shared pointer (if any), and false otherwise; a compiler diagnostic will be emitted indicating the error unless a (raw) pointer to LHS_TYPE can be compared to a (raw) pointer to RHS_TYPE. Note that two shared pointers that compare equal do not necessarily manage the same object due to aliasing.

operator==() [28/42]

template<class LHS_TYPE >

bool bsl::operator==	(	const shared_ptr< LHS_TYPE > &	lhs,
		nullptr_t
	)

Return true if the specified lhs shared pointer does not refer to an object, and false otherwise.

operator==() [29/42]

template<class _Tp , class _Alloc >

bool bsl::operator== ( const slist< _Tp, _Alloc > &  _SL1, const slist< _Tp, _Alloc > &  _SL2  )

inline

operator==() [30/42]

template<class VALUE , class CONTAINER >

bool bsl::operator== ( const stack< VALUE, CONTAINER > &  lhs, const stack< VALUE, CONTAINER > &  rhs  )

inline

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two stack objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE be equality-comparable (see {Requirements on VALUE}).

operator==() [31/42]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator==	(	const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

Return true if the specified lhs string has the same value as the specified rhs string, and false otherwise. Two strings have the same value if they have the same length, and the characters at each respective position have the same value according to CHAR_TRAITS::eq.

operator==() [32/42]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator==	(	const t_LHS_TYPE &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

operator==() [33/42]

template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >

bool bsl::operator==	(	const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	lhs,
		const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two unordered_map objects have the same value if they have the same number of key-value pairs, and for each key-value pair that is contained in lhs there is a key-value pair contained in rhs having the same value, and vice versa. Note that this method requires that the (template parameter) types KEY and VALUE both be equality-comparable (see {Requirements on value_type}).

operator==() [34/42]

template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >

bool bsl::operator==	(	const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	lhs,
		const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two unordered_multimap objects have the same value if they have the same number of key-value pairs, and each key-value pair that is contained in one of the objects is also contained in the other object. This method requires that the (template parameter) types KEY and VALUE both be equality-comparable (see {Requirements on KEY and VALUE}).

operator==() [35/42]

template<class KEY , class HASH , class EQUAL , class ALLOCATOR >

bool bsl::operator==	(	const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &	lhs,
		const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two unordered_multiset objects have the same value if they have the same number of value elements, and for each value-element that is contained in lhs there is a value-element contained in rhs having the same value, and vice-versa. Note that this method requires that the (template parameter) type KEY be equality-comparable (see {Requirements on KEY}).

operator==() [36/42]

template<class KEY , class HASH , class EQUAL , class ALLOCATOR >

bool bsl::operator==	(	const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &	lhs,
		const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two unordered_set objects have the same value if they have the same number of value-elements, and for each value-element that is contained in lhs there is a value-element contained in rhs having the same value, and vice-versa. Note that this method requires that the (template parameter) type KEY be equality-comparable (see {Requirements on KEY}).

operator==() [37/42]

template<class t_HEAD , class... t_TAIL>

bool bsl::operator==	(	const variant< t_HEAD, t_TAIL... > &	lhs,
		const variant< t_HEAD, t_TAIL... > &	rhs
	)

Return true if the specified lhs and rhs are both valueless by exception or if they have the same active alternative and their contained values compare equal; otherwise, return false. All alternatives shall support operator==.

operator==() [38/42]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator== ( const vector< VALUE_TYPE, ALLOCATOR > &  lhs, const vector< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two vector objects lhs and rhs have the same value if they have the same number of elements, and each element in the ordered sequence of elements of lhs has the same value as the corresponding element in the ordered sequence of elements of rhs. This method requires that the (template parameter) type VALUE_TYPE be equality-comparable (see {Requirements on VALUE_TYPE}).

operator==() [39/42]

template<class T1 , class T2 >

bool bsl::operator== ( bsl::List_Iterator< T1 >  lhs, bsl::List_Iterator< T2 >  rhs  )

inline

Return true if the specified lhs and rhs iterators have the same value, and false otherwise. Two iterators have the same value if both refer to the same element of the same list or both are the end() iterator of the same list. The behavior is undefined unless both lhs and rhs refer to the same list. Note that the different types T1 and T2 are to facilitate comparisons between const and non-const iterators and there will be a compilation error if T1 and T2 differ in any way other than const-ness.

operator==() [40/42]

BSLS_KEYWORD_CONSTEXPR bool bsl::operator== ( monostate  , monostate    )

inline

Compare two monostate objects. Since monostate only has one value, the result is true for the ==, <=, and >= operators, and false for the !=, <, and > operators.

operator==() [41/42]

template<class PROTOTYPE >

bool bsl::operator==	(	nullptr_t	,
		const function< PROTOTYPE > &
	)

operator==() [42/42]

template<class RHS_TYPE >

bool bsl::operator==	(	nullptr_t	,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the specified rhs shared pointer does not refer to an object, and false otherwise.

operator>() [1/27]

template<class VALUE_TYPE , size_t SIZE>

bool bsl::operator>	(	const array< VALUE_TYPE, SIZE > &	lhs,
		const array< VALUE_TYPE, SIZE > &	rhs
	)

Return true if the specified lhs is lexicographically greater than the specified rhs by using the comparison operators of VALUE_TYPE on each element; return false otherwise.

operator>() [2/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator>	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

operator>() [3/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator>	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const CHAR_TYPE *	rhs
	)

operator>() [4/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator>	(	const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator>() [5/27]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator> ( const bsl::nullopt_t &  , const bsl::optional< t_TYPE > &    )

inline

operator>() [6/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator>	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

Initial value:

{
    if (!rhs.has_value()) {
        return false;                                                 
    }
 
    return !lhs.has_value() || *lhs < *rhs

operator>() [7/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator>	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const t_RHS_TYPE &	rhs
	)

operator>() [8/27]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator> ( const bsl::optional< t_TYPE > &  value, const bsl::nullopt_t &    )

inline

operator>() [9/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator>	(	const CHAR_TYPE *	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

Return true if the specified lhs string has a lexicographically larger value than the specified rhs string, and false otherwise. See {Lexicographical Comparisons}.

operator>() [10/27]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator> ( const deque< VALUE_TYPE, ALLOCATOR > &  lhs, const deque< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator>() [11/27]

template<class VALUE , class ALLOCATOR >

bool bsl::operator>	(	const list< VALUE, ALLOCATOR > &	lhs,
		const list< VALUE, ALLOCATOR > &	rhs
	)

operator>() [12/27]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator>	(	const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator>() [13/27]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator>	(	const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator>() [14/27]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator>	(	const multiset< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const multiset< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

operator>() [15/27]

template<class T1 , class T2 >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator> ( const pair< T1, T2 > &  lhs, const pair< T1, T2 > &  rhs  )

inline

Return true if the specified lhs has a value greater than the specified rhs and false otherwise. lhs has a value greater than rhs if rhs < lhs would return true. A call to this operator will not compile unless a call to lhs < rhs would compile.

operator>() [16/27]

template<class VALUE , class CONTAINER >

bool bsl::operator> ( const queue< VALUE, CONTAINER > &  lhs, const queue< VALUE, CONTAINER > &  rhs  )

inline

Return true if the value of the specified lhs queue is lexicographically greater than that of the specified rhs queue, and false otherwise. The value of queue lhs is lexicographically greater than that of queue rhs if rhs is lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns rhs < lhs.

operator>() [17/27]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator>	(	const set< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const set< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the value of the specified lhs set is lexicographically greater than that of the specified rhs set, and false otherwise. The value of set lhs is lexicographically greater than that of set rhs if rhs is lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns rhs < lhs.

operator>() [18/27]

template<class LHS_TYPE , class RHS_TYPE >

bool bsl::operator>	(	const shared_ptr< LHS_TYPE > &	lhs,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the address of the object that the specified lhs shared pointer refers to is ordered after the address of the object that the specified rhs shared pointer refers to under the total ordering supplied by std::less<T *>, where T * is the composite pointer type of LHS_TYPE * and RHS_TYPE *, and false otherwise.

operator>() [19/27]

template<class LHS_TYPE >

bool bsl::operator>	(	const shared_ptr< LHS_TYPE > &	lhs,
		nullptr_t
	)

Return true if the address of the object referred to by the specified lhs shared pointer is ordered after the null-pointer value under the total ordering supplied by std::less<LHS_TYPE *>, and false otherwise.

operator>() [20/27]

template<class _Tp , class _Alloc >

bool bsl::operator> ( const slist< _Tp, _Alloc > &  __x, const slist< _Tp, _Alloc > &  __y  )

inline

operator>() [21/27]

template<class VALUE , class CONTAINER >

bool bsl::operator> ( const stack< VALUE, CONTAINER > &  lhs, const stack< VALUE, CONTAINER > &  rhs  )

inline

Return true if the value of the specified lhs stack is lexicographically greater than that of the specified rhs stack, and false otherwise. The value of stack lhs is lexicographically greater than that of stack rhs if rhs is lexicographically less than lhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns rhs < lhs.

operator>() [22/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator>	(	const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator>() [23/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator>	(	const t_LHS_TYPE &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

operator>() [24/27]

template<class t_HEAD , class... t_TAIL>

bool bsl::operator>	(	const variant< t_HEAD, t_TAIL... > &	lhs,
		const variant< t_HEAD, t_TAIL... > &	rhs
	)

Return true if the index of the active alternative in the specified lhs is greater than that of the specified rhs, or if both have the same active alternative and the contained value of lhs compares greater than that of rhs, or if rhs is valueless by exception and lhs is not; otherwise, return false. All alternatives shall support operator>.

operator>() [25/27]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator> ( const vector< VALUE_TYPE, ALLOCATOR > &  lhs, const vector< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator>() [26/27]

BSLS_KEYWORD_CONSTEXPR bool bsl::operator> ( monostate  , monostate    )

inline

operator>() [27/27]

template<class RHS_TYPE >

bool bsl::operator>	(	nullptr_t	,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the address of the object referred to by the specified rhs shared pointer is ordered before the null-pointer value under the total ordering supplied by std::less<RHS_TYPE *>, and false otherwise.

operator>=() [1/27]

template<class VALUE_TYPE , size_t SIZE>

bool bsl::operator>=	(	const array< VALUE_TYPE, SIZE > &	lhs,
		const array< VALUE_TYPE, SIZE > &	rhs
	)

Return true if the specified lhs is lexicographically greater than the specified rhs by using the comparison operators of VALUE_TYPE on each element or if lhs and rhs are equal; return false otherwise.

operator>=() [2/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator>=	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

Return true if the specified lhs string has a value lexicographically larger than or equal to the specified rhs string, and false otherwise. See {Lexicographical Comparisons}.

operator>=() [3/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator>=	(	const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	lhs,
		const CHAR_TYPE *	rhs
	)

operator>=() [4/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator>=	(	const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator>=() [5/27]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator>= ( const bsl::nullopt_t &  , const bsl::optional< t_TYPE > &  value  )

inline

operator>=() [6/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator>=	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

Initial value:

{
    if (!lhs.has_value()) {
        return true;                                                  
    }
 
    return rhs.has_value() && *lhs <= *rhs

operator>=() [7/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator>=	(	const bsl::optional< t_LHS_TYPE > &	lhs,
		const t_RHS_TYPE &	rhs
	)

operator>=() [8/27]

template<class t_TYPE >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator>= ( const bsl::optional< t_TYPE > &  , const bsl::nullopt_t &    )

inline

operator>=() [9/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >

bool bsl::operator>=	(	const CHAR_TYPE *	lhs,
		const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &	rhs
	)

operator>=() [10/27]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator>= ( const deque< VALUE_TYPE, ALLOCATOR > &  lhs, const deque< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator>=() [11/27]

template<class VALUE , class ALLOCATOR >

bool bsl::operator>=	(	const list< VALUE, ALLOCATOR > &	lhs,
		const list< VALUE, ALLOCATOR > &	rhs
	)

operator>=() [12/27]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator>=	(	const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator>=() [13/27]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

bool bsl::operator>=	(	const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	lhs,
		const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	rhs
	)

operator>=() [14/27]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator>=	(	const multiset< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const multiset< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

operator>=() [15/27]

template<class T1 , class T2 >

BSLS_KEYWORD_CONSTEXPR bool bsl::operator>= ( const pair< T1, T2 > &  lhs, const pair< T1, T2 > &  rhs  )

inline

Return true if the specified lhs has a value greater than or equal to the specified rhs and false otherwise. lhs has a value greater than or equal to rhs if lhs < rhs would return false. A call to this operator will not compile unless a call to lhs < rhs would compile.

operator>=() [16/27]

template<class VALUE , class CONTAINER >

bool bsl::operator>= ( const queue< VALUE, CONTAINER > &  lhs, const queue< VALUE, CONTAINER > &  rhs  )

inline

Return true if the value of the specified lhs queue is lexicographically greater than or equal to that of the specified rhs queue, and false otherwise. The value of queue lhs is lexicographically greater than or equal to that of queue rhs if lhs is not lexicographically less than rhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(lhs < rhs).

operator>=() [17/27]

template<class KEY , class COMPARATOR , class ALLOCATOR >

bool bsl::operator>=	(	const set< KEY, COMPARATOR, ALLOCATOR > &	lhs,
		const set< KEY, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the value of the specified lhs set is lexicographically greater than or equal to that of the specified rhs set, and false otherwise. The value of set lhs is lexicographically greater than or equal to that of set rhs if lhs is not lexicographically less than rhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(lhs < rhs).

operator>=() [18/27]

template<class LHS_TYPE , class RHS_TYPE >

bool bsl::operator>=	(	const shared_ptr< LHS_TYPE > &	lhs,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the specified lhs shared pointer refers to the same object as the specified rhs shared pointer, or if the address of the object referred to by lhs (if any) is ordered after the address of the object referred to by rhs (if any) under the total ordering supplied by std::less<T *>, where T * is the composite pointer type of LHS_TYPE * and RHS_TYPE *, and false otherwise.

operator>=() [19/27]

template<class LHS_TYPE >

bool bsl::operator>=	(	const shared_ptr< LHS_TYPE > &	lhs,
		nullptr_t
	)

Return true if the specified lhs shared pointer does not refer to an object, or if the address of the object referred to by lhs is ordered after the null-pointer value under the total ordering supplied by std::less<LHS_TYPE *>, and false otherwise.

operator>=() [20/27]

template<class _Tp , class _Alloc >

bool bsl::operator>= ( const slist< _Tp, _Alloc > &  __x, const slist< _Tp, _Alloc > &  __y  )

inline

operator>=() [21/27]

template<class VALUE , class CONTAINER >

bool bsl::operator>= ( const stack< VALUE, CONTAINER > &  lhs, const stack< VALUE, CONTAINER > &  rhs  )

inline

Return true if the value of the specified lhs stack is lexicographically greater than or equal to that of the specified rhs stack, and false otherwise. The value of stack lhs is lexicographically greater than or equal to that of stack rhs if lhs is not lexicographically less than rhs (see operator<). This method requires that operator<, inducing a total order, be defined for value_type. Note that this operator returns !(lhs < rhs).

operator>=() [22/27]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >

bool bsl::operator>=	(	const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &	lhs,
		const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &	rhs
	)

operator>=() [23/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

bool bsl::operator>=	(	const t_LHS_TYPE &	lhs,
		const bsl::optional< t_RHS_TYPE > &	rhs
	)

operator>=() [24/27]

template<class t_HEAD , class... t_TAIL>

bool bsl::operator>=	(	const variant< t_HEAD, t_TAIL... > &	lhs,
		const variant< t_HEAD, t_TAIL... > &	rhs
	)

Return true if the index of the active alternative in the specified lhs is greater than that of the specified rhs, or if both have the same active alternative and the contained value of lhs compares greater than or equal to that of rhs, or if rhs is valueless by exception; otherwise, return false. All alternatives shall support operator>=.

operator>=() [25/27]

template<class VALUE_TYPE , class ALLOCATOR >

bool bsl::operator>= ( const vector< VALUE_TYPE, ALLOCATOR > &  lhs, const vector< VALUE_TYPE, ALLOCATOR > &  rhs  )

inline

operator>=() [26/27]

BSLS_KEYWORD_CONSTEXPR bool bsl::operator>= ( monostate  , monostate    )

inline

operator>=() [27/27]

template<class RHS_TYPE >

bool bsl::operator>=	(	nullptr_t	,
		const shared_ptr< RHS_TYPE > &	rhs
	)

Return true if the specified rhs shared pointer does not refer to an object, or if the address of the object referred to by rhs is ordered before the null-pointer value under the total ordering supplied by std::less<RHS_TYPE *>, and false otherwise.

operator>>() [1/2]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

std::basic_istream< CHAR_TYPE, CHAR_TRAITS > & bsl::operator>>	(	std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &	is,
		basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	str
	)

Replace the contents of the specified str string with a word read from the specified is input stream, and return is. The word begins at the first non-whitespace character on the input stream and ends when another whitespace character (or eof) is found. The trailing whitespace character is left on the input stream. If is.good() is not true on entry or if eof is found before any non-whitespace characters, then str is unchanged and is.fail() is becomes true. If eof is detected after some characters have been read into str, then is.eof() becomes true, but is.fail() does not.

operator>>() [2/2]

template<class CHAR_TYPE , class TRAITS , std::size_t N>

std::basic_istream< CHAR_TYPE, TRAITS > & bsl::operator>>	(	std::basic_istream< CHAR_TYPE, TRAITS > &	is,
		bitset< N > &	x
	)

operator^()

template<std::size_t N>

bitset< N > bsl::operator^	(	const bitset< N > &	lhs,
		const bitset< N > &	rhs
	)

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

operator|()

template<std::size_t N>

bitset< N > bsl::operator|	(	const bitset< N > &	lhs,
		const bitset< N > &	rhs
	)

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

PrintTo() [1/4]

void bsl::PrintTo	(	const BloombergLP::bslstl::StringRef &	value,
		ostream *	stream
	)

Write the specified value to the specified *stream, surrounded by double quotes.

PrintTo() [2/4]

template<class TYPE >

void bsl::PrintTo	(	const optional< TYPE > &	value,
		ostream *	stream
	)

Write the specified value to the specified *stream, surrounded by double quotes.

PrintTo() [3/4]

void bsl::PrintTo	(	const string &	value,
		ostream *	stream
	)

Write the specified value to the specified *stream, surrounded by double quotes.

PrintTo() [4/4]

void bsl::PrintTo	(	const wstring &	value,
		ostream *	stream
	)

Write the specified value to the specified *stream, surrounded by double quotes, writing non-printable characters with '\x...' escapes.

rbegin() [1/3]

template<class T >

T::const_reverse_iterator bsl::rbegin ( const T &  container )

inline

Return the reverse iterator providing non-modifiable access to the last valid element of the specified container.

rbegin() [2/3]

template<class T >

T::reverse_iterator bsl::rbegin ( T &  container )

inline

Return the reverse iterator providing modifiable access to the last valid element of the specified container.

rbegin() [3/3]

template<class T , size_t N>

reverse_iterator< T * > bsl::rbegin ( T(&)  array[N] )

inline

Return the reverse iterator providing modifiable access to the last element of the specified array.

reinterpret_pointer_cast()

template<class TO_TYPE , class FROM_TYPE >

shared_ptr< TO_TYPE > bsl::reinterpret_pointer_cast

(

const shared_ptr< FROM_TYPE > &

source

)

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.

rend() [1/3]

template<class T >

T::const_reverse_iterator bsl::rend ( const T &  container )

inline

Return the reverse iterator providing non-modifiable access to the position one before the first valid element in the specified container.

rend() [2/3]

template<class T >

T::reverse_iterator bsl::rend ( T &  container )

inline

Return the reverse iterator providing modifiable access to the position one before the first valid element in the specified container.

rend() [3/3]

template<class T , size_t N>

reverse_iterator< T * > bsl::rend ( T(&)  array[N] )

inline

Return the reverse iterator providing modifiable access to the position one before the first element in the specified array.

search()

template<class FORWARD_ITERATOR , class SEARCHER >

BSLS_KEYWORD_CONSTEXPR_CPP14 FORWARD_ITERATOR bsl::search	(	FORWARD_ITERATOR	first,
		FORWARD_ITERATOR	last,
		const SEARCHER &	searcher
	)

Return the position in the specified range [first, last) of the first occurrence of the pattern sought by the specified searcher if found, and last otherwise. See [alg.search].

size() [1/2]

template<class CONTAINER >

BSLS_KEYWORD_CONSTEXPR size_t bsl::size ( const CONTAINER &  container )

inline

Return the size of the specified container. The CONTAINER template parameter type must provide a size accessor.

size() [2/2]

template<class TYPE , size_t DIMENSION>

BSLS_KEYWORD_CONSTEXPR size_t bsl::size ( const   TYPE(&)[DIMENSION] )

inline

ssize() [1/2]

template<class CONTAINER >

BSLS_KEYWORD_CONSTEXPR std::ptrdiff_t bsl::ssize ( const CONTAINER &  container )

inline

Return the size of the specified container. The CONTAINER template parameter type must provide a size accessor.

ssize() [2/2]

template<class TYPE , std::ptrdiff_t DIMENSION>

BSLS_KEYWORD_CONSTEXPR std::ptrdiff_t bsl::ssize ( const   TYPE(&)[DIMENSION] )

inline

static_pointer_cast()

template<class TO_TYPE , class FROM_TYPE >

shared_ptr< TO_TYPE > bsl::static_pointer_cast

(

const shared_ptr< FROM_TYPE > &

source

)

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() [1/2]

double bsl::stod	(	const string &	str,
		std::size_t *	pos = 0
	)

stod() [2/2]

double bsl::stod	(	const wstring &	str,
		std::size_t *	pos = 0
	)

Return the value of the specified str by parsing the string and interpreting its content as an integral number. Optionally specify pos whose value is set to the position of the next character in str after the numerical value. Optionally specify base used to change the interpretation of str to a integral number written in the given base. Valid bases are bases in the range of [2,36] and base 0, where base 0 automatically determines the base while parsing the string: the base will be 16 if the number is prefixed with 0x or 0X, base 8 if the number is prefixed with a 0, and base 10 otherwise. The function ignores leading white space characters and interprets as many characters possible to form a valid integral number in the chosen base. If no conversion could be performed, then an invalid_argument exception is thrown. If the value read is out of range of the return type, then an out_of_range exception is thrown. The behavior is undefined unless base is valid. Note that negative numbers are parsed by interpreting the numeric sequence following the - character, and then negating the result, so that stoul and stoull have defined results for negative numbers where the absolute value falls in the valid range for the corresponding signed conversion.

stof() [1/2]

float bsl::stof	(	const string &	str,
		std::size_t *	pos = 0
	)

stof() [2/2]

float bsl::stof	(	const wstring &	str,
		std::size_t *	pos = 0
	)

stoi() [1/2]

int bsl::stoi	(	const string &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

stoi() [2/2]

int bsl::stoi	(	const wstring &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

stol() [1/2]

long bsl::stol	(	const string &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

stol() [2/2]

long bsl::stol	(	const wstring &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

stold() [1/2]

long double bsl::stold	(	const string &	str,
		std::size_t *	pos = 0
	)

stold() [2/2]

long double bsl::stold	(	const wstring &	str,
		std::size_t *	pos = 0
	)

Parses str interpreting its contents as a floating point number. In C++11 if the number in str is prefixed with 0x or 0X the string will be interpreted as a hex number. If there is no leading 0x or 0X the string will be interpreted as a decimal number. Optionally specify pos whose value is set to the position of the next character after the numerical value. The function ignores leading white space characters and interprets as many characters possible to form a valid floating point number. If no conversion could be performed, then an invalid_argument exception is thrown. If the value read is out of range of the return type, then an out_of_range exception is thrown.

stoll() [1/2]

long long bsl::stoll	(	const string &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

stoll() [2/2]

long long bsl::stoll	(	const wstring &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

stoul() [1/2]

unsigned long bsl::stoul	(	const string &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

stoul() [2/2]

unsigned long bsl::stoul	(	const wstring &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

stoull() [1/2]

unsigned long long bsl::stoull	(	const string &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

stoull() [2/2]

unsigned long long bsl::stoull	(	const wstring &	str,
		std::size_t *	pos = 0,
		int	base = 10
	)

swap() [1/29]

template<class VALUE_TYPE , size_t SIZE>

void bsl::swap	(	array< VALUE_TYPE, SIZE > &	lhs,
		array< VALUE_TYPE, SIZE > &	rhs
	)

Call swap using ADL on each element of the specified lhs with the corresponding element in the specified rhs.

swap() [2/29]

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >

void bsl::swap	(	basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	a,
		basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &	b
	)

Exchange the value of the specified a object with that of the specified b object; also exchange the allocator of a with that of b if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This function provides the no-throw exception-safety guarantee. This operation has O[1] complexity if either a was created with the same allocator as b or ALLOCATOR has the propagate_on_container_swap trait; otherwise, it has O[n + m] complexity, where n and m are the lengths of a and b, respectively. Note that this functions support for swapping objects created with different allocators whenALLOCATORdoes not have the propagate_on_container_swap` trait is a departure from the C++ Standard.

swap() [3/29]

template<class CHAR_TYPE , class CHAR_TRAITS >

void bsl::swap	(	basic_string_view< CHAR_TYPE, CHAR_TRAITS > &	a,
		basic_string_view< CHAR_TYPE, CHAR_TRAITS > &	b
	)

Exchange the value of the specified a object with the value of the specified b object.

swap() [4/29]

template<class t_TYPE >

bsl::enable_if< BloombergLP::bslma::UsesBslmaAllocator< t_TYPE >::value, void >::type bsl::swap ( bsl::optional< t_TYPE > &  lhs, bsl::optional< t_TYPE > &  rhs  )

inline

Efficiently exchange the values of the specified lhs and rhs objects. This method provides the no-throw exception-safety guarantee if the template parameter t_TYPE provides that guarantee, lhs and rhs have equal allocators, and lhs.hasValue() == rhs.hasValue().

swap() [5/29]

template<class t_TYPE >

bsl::enable_if<!BloombergLP::bslma::UsesBslmaAllocator< t_TYPE >::value, void >::type bsl::swap ( bsl::optional< t_TYPE > &  lhs, bsl::optional< t_TYPE > &  rhs  )

inline

Efficiently exchange the values of the specified lhs and rhs objects. This method provides the no-throw exception-safety guarantee if the template parameter t_TYPE provides that guarantee and the result of the hasValue method for lhs and rhs is the same.

swap() [6/29]

template<class t_HEAD , class... t_TAIL>

void bsl::swap	(	bsl::variant< t_HEAD, t_TAIL... > &	lhs,
		bsl::variant< t_HEAD, t_TAIL... > &	rhs
	)

Efficiently exchange the values of the specified lhs and rhs objects. This method provides the no-throw guarantee if the two variant objects being swapped have the same active alternative and that alternative provides that guarantee; otherwise, this method provides the basic guarantee. If lhs and rhs do not contain the same alternative or they have unequal allocators, and an exception is thrown during the swap, either or both variant objects may be left in a valueless state or with an alternative in a moved-from state. All alternatives shall be move constructible and swappable. For simplicity of implementation, this function differs from the standard in the following :

• constraints are not implemented
• constexpr is not implemented

swap() [7/29]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::swap ( deque< VALUE_TYPE, ALLOCATOR > &  a, deque< VALUE_TYPE, ALLOCATOR > &  b  )

inline

swap() [8/29]

template<class PROTOTYPE >

void bsl::swap	(	function< PROTOTYPE > &	a,
		function< PROTOTYPE > &	b
	)

Exchange the targets held by the specified a and specified b objects. The behavior is undefined unless 'a.get_allocator() == b.get_allocator()'.

swap() [9/29]

template<class _Key , class _Tp , class _HashFcn , class _EqualKey , class _Alloc >

void bsl::swap ( hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > &  lhs, hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > &  rhs  )

inline

swap() [10/29]

template<class _Key , class _Tp , class _HashFcn , class _EqualKey , class _Alloc >

void bsl::swap ( hash_multimap< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > &  lhs, hash_multimap< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > &  rhs  )

inline

swap() [11/29]

template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >

void bsl::swap ( hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &  lhs, hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &  rhs  )

inline

swap() [12/29]

template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >

void bsl::swap ( hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &  lhs, hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &  rhs  )

inline

swap() [13/29]

template<class VALUE , class ALLOCATOR >

void bsl::swap	(	list< VALUE, ALLOCATOR > &	a,
		list< VALUE, ALLOCATOR > &	b
	)

swap() [14/29]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

void bsl::swap	(	map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	a,
		map< KEY, VALUE, COMPARATOR, ALLOCATOR > &	b
	)

Exchange the value and comparator of the specified a object with those of the specified b object; also exchange the allocator of a with that of b if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This function provides the no-throw exception-safety guarantee if and only if the (template parameter) type COMPARATOR provides a no-throw swap operation, and provides the basic exception-safety guarantee otherwise; if an exception is thrown, both objects are left in valid but unspecified states. This operation has O[1] complexity if either a was created with the same allocator as b or ALLOCATOR has the propagate_on_container_swap trait; otherwise, it has O[n + m] complexity, where n and m are the number of elements in a and b, respectively. Note that this function's support for swapping objects created with different allocators when ALLOCATOR does not have the propagate_on_container_swap trait is a departure from the C++ Standard.

swap() [15/29]

template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >

void bsl::swap	(	multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	a,
		multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &	b
	)

Exchange the value and comparator of the specified a object with those of the specified b object; also exchange the allocator of a with that of b if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This function provides the no-throw exception-safety guarantee if and only if the (template parameter) type COMPARATOR provides a no-throw swap operation, and provides the basic exception-safety guarantee otherwise; if an exception is thrown, both objects are left in valid but unspecified states. This operation has O[1] complexity if either a was created with the same allocator as b or ALLOCATOR has the propagate_on_container_swap trait; otherwise, it has O[n + m] complexity, where n and m are the number of elements in a and b, respectively. Note that this function's support for swapping objects created with different allocators when ALLOCATOR does not have the propagate_on_container_swap trait is a departure from the C++ Standard.

swap() [16/29]

template<class KEY , class COMPARATOR , class ALLOCATOR >

void bsl::swap	(	multiset< KEY, COMPARATOR, ALLOCATOR > &	a,
		multiset< KEY, COMPARATOR, ALLOCATOR > &	b
	)

swap() [17/29]

template<class T1 , class T2 >

void bsl::swap ( pair< T1, T2 > &  a, pair< T1, T2 > &  b  )

inlinenoexcept

Swap the values of the specified a and b pairs by applying swap to each of the first and second pair fields. Note that this method is no-throw only if swap on each field is no-throw.

swap() [18/29]

template<class VALUE , class CONTAINER , class COMPARATOR >

void bsl::swap	(	priority_queue< VALUE, CONTAINER, COMPARATOR > &	a,
		priority_queue< VALUE, CONTAINER, COMPARATOR > &	b
	)

Exchange the container and comparator of the specified a object with the container and comparator of the specified b object.

swap() [19/29]

template<class VALUE , class CONTAINER >

void bsl::swap ( queue< VALUE, CONTAINER > &  lhs, queue< VALUE, CONTAINER > &  rhs  )

inline

Swap the value of the specified lhs queue with the value of the specified rhs queue.

swap() [20/29]

template<class KEY , class COMPARATOR , class ALLOCATOR >

void bsl::swap	(	set< KEY, COMPARATOR, ALLOCATOR > &	a,
		set< KEY, COMPARATOR, ALLOCATOR > &	b
	)

Exchange the value and comparator of the specified a object with those of the specified b object; also exchange the allocator of a with that of b if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This function provides the no-throw exception-safety guarantee if and only if the (template parameter) type COMPARATOR provides a no-throw swap operation, and provides the basic exception-safety guarantee otherwise; if an exception is thrown, both objects are left in valid but unspecified states. This operation has O[1] complexity if either a was created with the same allocator as b or ALLOCATOR has the propagate_on_container_swap trait; otherwise, it has O[n + m] complexity, where n and m are the number of elements in a and b, respectively. Note that this functions support for swapping objects created with different allocators whenALLOCATORdoes not have the propagate_on_container_swap` trait is a departure from the C++ Standard.

swap() [21/29]

template<class ELEMENT_TYPE >

void bsl::swap	(	shared_ptr< ELEMENT_TYPE > &	a,
		shared_ptr< ELEMENT_TYPE > &	b
	)

Efficiently exchange the states of the specified a and b shared pointers such that each will refer to the object formerly referred to by the other, and each will manage the object formerly managed by the other.

swap() [22/29]

template<class TYPE , size_t EXTENT>

BSLS_KEYWORD_CONSTEXPR_CPP14 void bsl::swap	(	span< TYPE, EXTENT > &	a,
		span< TYPE, EXTENT > &	b
	)

Exchange the value of the specified a object with the value of the specified b object.

swap() [23/29]

template<class VALUE , class CONTAINER >

void bsl::swap ( stack< VALUE, CONTAINER > &  lhs, stack< VALUE, CONTAINER > &  rhs  )

inline

Swap the value of the specified lhs stack with the value of the specified rhs stack.

swap() [24/29]

template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >

void bsl::swap	(	unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	a,
		unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	b
	)

Exchange the value, hasher, key-equality functor, and max_load_factor of the specified a object with those of the specified b object; also exchange the allocator of a with that of b if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This function provides the no-throw exception-safety guarantee if and only if both the (template parameter) types HASH and EQUAL provide no-throw swap operations; if an exception is thrown, both objects are left in valid but unspecified states. This operation guarantees O[1] complexity. The behavior is undefined unless either a was created with the same allocator as b or ALLOCATOR has the propagate_on_container_swap trait.

swap() [25/29]

template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >

void bsl::swap	(	unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	a,
		unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &	b
	)

Exchange the value, hasher, key-equality functor, and max_load_factor of the specified a object with those of the specified b object; also exchange the allocator of a with that of b if the (template parameter) type ALLOCATOR has the propagate_on_container_swap trait, and do not modify either allocator otherwise. This function provides the no-throw exception-safety guarantee if and only if both the (template parameter) types HASH and EQUAL provide no-throw swap operations; if an exception is thrown, both objects are left in valid but unspecified states. This operation guarantees O[1] complexity. The behavior is undefined unless either a was created with the same allocator as b or ALLOCATOR has the propagate_on_container_swap trait.

swap() [26/29]

template<class KEY , class HASH , class EQUAL , class ALLOCATOR >

void bsl::swap	(	unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &	a,
		unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &	b
	)

swap() [27/29]

template<class KEY , class HASH , class EQUAL , class ALLOCATOR >

void bsl::swap	(	unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &	a,
		unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &	b
	)

swap() [28/29]

template<class VALUE_TYPE , class ALLOCATOR >

void bsl::swap ( vector< VALUE_TYPE, ALLOCATOR > &  a, vector< VALUE_TYPE, ALLOCATOR > &  b  )

inline

swap() [29/29]

template<class ELEMENT_TYPE >

void bsl::swap	(	weak_ptr< ELEMENT_TYPE > &	a,
		weak_ptr< ELEMENT_TYPE > &	b
	)

Efficiently exchange the states of the specified a and b weak pointers such that each will refer to the object (if any) and representation formerly referred to by the other.

to_array()

template<class TYPE , std::size_t SIZE>

BSLS_KEYWORD_CONSTEXPR_CPP14 array< typename remove_cv< TYPE >::type, SIZE > bsl::to_array

(

TYPE(&)

src[SIZE]

)

Creates an array from the specified src one-dimensional built-in array by copying the corresponding elements. The template parameter TYPE shall not itself be a built-in array. Note that TYPE must be CopyConstructible and, in C++ versions prior to C++14, must also be DefaultConstructible.

to_string() [1/9]

string bsl::to_string

(

double

value

)

converts a floating point value to a string with the same contents as what std::sprintf(buf, "%f", value) would produce for a sufficiently large buffer.

to_string() [2/9]

string bsl::to_string

(

float

value

)

to_string() [3/9]

string bsl::to_string

(

int

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::sprintf(buf, "%d", value) would produce with a sufficiently large buffer.

to_string() [4/9]

string bsl::to_string

(

long double

value

)

converts a floating point value to a string with the same contents as what std::sprintf(buf, "%Lf", value) would produce for a sufficiently large buffer.

to_string() [5/9]

string bsl::to_string

(

long long

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::sprintf(buf, "%lld", value) would produce with a sufficiently large buffer.

to_string() [6/9]

string bsl::to_string

(

long

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::sprintf(buf, "%ld", value) would produce with a sufficiently large buffer.

to_string() [7/9]

string bsl::to_string

(

unsigned long long

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::sprintf(buf, "%llu", value) would produce with a sufficiently large buffer.

to_string() [8/9]

string bsl::to_string

(

unsigned long

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::sprintf(buf, "%lu", value) would produce with a sufficiently large buffer.

to_string() [9/9]

string bsl::to_string

(

unsigned

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::sprintf(buf, "%u", value) would produce with a sufficiently large buffer.

to_wstring() [1/9]

wstring bsl::to_wstring

(

double

value

)

converts a floating point value to a string with the same contents as what std::sprintf(buf, sz, L"%f", value) would produce for a sufficiently large buffer.

to_wstring() [2/9]

wstring bsl::to_wstring

(

float

value

)

to_wstring() [3/9]

wstring bsl::to_wstring

(

int

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::swprintf(buf, L"%d", value) would produce with a sufficiently large buffer.

to_wstring() [4/9]

wstring bsl::to_wstring

(

long double

value

)

converts a floating point value to a string with the same contents as what std::sprintf(buf, sz, L"%Lf", value) would produce for a sufficiently large buffer.

to_wstring() [5/9]

wstring bsl::to_wstring

(

long long

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::swprintf(buf, L"%lld", value) would produce with a sufficiently large buffer.

to_wstring() [6/9]

wstring bsl::to_wstring

(

long

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::swprintf(buf, L"%ld", value) would produce with a sufficiently large buffer.

to_wstring() [7/9]

wstring bsl::to_wstring

(

unsigned long long

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::swprintf(buf, L"%llu", value) would produce with a sufficiently large buffer.

to_wstring() [8/9]

wstring bsl::to_wstring

(

unsigned long

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::swprintf(buf, L"%lu", value) would produce with a sufficiently large buffer.

to_wstring() [9/9]

wstring bsl::to_wstring

(

unsigned

value

)

Constructs a string with contents equal to the specified value. The contents of the string will be the same as what std::swprintf(buf, L"%u", value) would produce with a sufficiently large buffer.

uncaught_exceptions()

int bsl::uncaught_exceptions	(		)
throw	(
	)

Return the number of exceptions that have been thrown or rethrown in the current thread that have not been caught. If the C++17 baseline library is not available, this function may return 1 even if more than 1 uncaught exception exists, but if guaranteed to return 0 if there are no uncaught exceptions.

visit() [1/2]

template<class t_VISITOR , class t_VARIANT >

bsl::invoke_result< t_VISITOR &, BloombergLP::bslmf::MovableRef< typenamebsl::variant_alternative< 0, t_VARIANT >::type > >::type bsl::visit	(	t_VISITOR &	visitor,
		BloombergLP::bslmf::MovableRef< t_VARIANT >	variant
	)

visit() [2/2]

template<class t_VISITOR , class t_VARIANT >

bsl::invoke_result< t_VISITOR &, typenamebsl::variant_alternative< 0, t_VARIANT >::type & >::type bsl::visit	(	t_VISITOR &	visitor,
		t_VARIANT &	variant
	)

visitR() [1/2]

template<class t_RET , class t_VISITOR , class t_VARIANT >

t_RET bsl::visitR	(	t_VISITOR &	visitor,
		BloombergLP::bslmf::MovableRef< t_VARIANT >	variant
	)

visitR() [2/2]

template<class t_RET , class t_VISITOR , class t_VARIANT >

t_RET bsl::visitR	(	t_VISITOR &	visitor,
		t_VARIANT &	variant
	)

Variable Documentation

in_place

const in_place_t bsl::in_place

extern

Value of type in_place_t used as an argument to functions that take an in_place_t argument.

make_optional

template<class t_TYPE >

bool operator==(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator==(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator!=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator!=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator<(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator<(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator>(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator>(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator<=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator<=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator>=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP bool operator>=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLS_KEYWORD_CONSTEXPR bsl::optional< typename bsl::decay< t_TYPE >::type > bsl::make_optional(bsl::allocator_arg_t, const typename bsl::optional< typename bsl::decay< t_TYPE >::type >::allocator_type &alloc, BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) rhs)	(	bsl::allocator_arg_t	,
		const typename bsl::optional< typename bsl::decay< t_TYPE >::type >::allocator_type &	alloc,
		BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE)	rhs
	)

Return an optional object containing a t_TYPE object created by invoking a bsl::optional allocator-extended in_place_t constructor with the specified alloc as the allocator argument, and specified rhs as the constructor argument. Note that this function will fail to compile if t_TYPE doesn't use allocators.

nostopstate

const nostopstate_t bsl::nostopstate

extern

Value of type nostopstate_t used as an argument to functions that take a nostopstate_t argument.

nullopt

const nullopt_t bsl::nullopt

extern

variant_npos

BSLS_KEYWORD_INLINE_CONSTEXPR size_t bsl::variant_npos = -1

This value is returned by bsl::variant::index() if valueless_by_exception() is true.