Namespaces
namespace	ranges

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_arg_t

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

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 >

struct	errc

class	error_category

class	error_code

class	error_condition

struct	formatter

struct	formatter< BloombergLP::bdlb::Guid, t_CHAR >

struct	formatter< BloombergLP::bdldfp::Decimal128, t_CHAR >

struct	formatter< BloombergLP::bdldfp::Decimal32, t_CHAR >

struct	formatter< BloombergLP::bdldfp::Decimal64, t_CHAR >

class	formatter< BloombergLP::bdlt::Date, t_CHAR >

class	formatter< BloombergLP::bdlt::Datetime, t_CHAR >

class	formatter< BloombergLP::bdlt::DatetimeTz, t_CHAR >

class	formatter< BloombergLP::bdlt::DateTz, t_CHAR >

class	formatter< BloombergLP::bdlt::Time, t_CHAR >

class	formatter< BloombergLP::bdlt::TimeTz, t_CHAR >

struct	formatter< BloombergLP::bslfmt::Streamed< t_STREAMABLE >, char >

struct	formatter< BloombergLP::bslstl::StringRefImp< t_CHAR >, t_CHAR >

struct	formatter< bool, t_CHAR >

struct	formatter< bsl::basic_string< t_CHAR, t_CHAR_TRAITS, t_ALLOCATOR >, t_CHAR >

struct	formatter< bsl::basic_string_view< t_CHAR, t_CHAR_TRAITS >, t_CHAR >

struct	formatter< bsl::nullptr_t, t_CHAR >

struct	formatter< char, char >

struct	formatter< char, wchar_t >

struct	formatter< const t_CHAR *, t_CHAR >

struct	formatter< const void *, t_CHAR >

struct	formatter< double, t_CHAR >

struct	formatter< float, t_CHAR >

struct	formatter< int, t_CHAR >

struct	formatter< long double, t_CHAR >

struct	formatter< long long, t_CHAR >

struct	formatter< long, t_CHAR >

struct	formatter< short, t_CHAR >

struct	formatter< signed char, t_CHAR >

struct	formatter< std::basic_string< t_CHAR, t_CHAR_TRAITS, t_ALLOCATOR >, t_CHAR >

struct	formatter< t_CHAR *, t_CHAR >

struct	formatter< t_CHAR[t_SIZE], t_CHAR >

struct	formatter< t_STREAMABLE, typename bsl::enable_if< BloombergLP::bslfmt::EnableStreamedFormatter< t_STREAMABLE >::value, char >::type >

struct	formatter< unsigned char, t_CHAR >

struct	formatter< unsigned long long, t_CHAR >

struct	formatter< unsigned long, t_CHAR >

struct	formatter< unsigned short, t_CHAR >

struct	formatter< unsigned, t_CHAR >

struct	formatter< void *, t_CHAR >

struct	formatter< wchar_t, wchar_t >

struct	from_range_t

class	function

struct	hash

struct	hash< basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > >

struct	hash< basic_string_view< CHAR_TYPE, CHAR_TRAITS > >

struct	hash< bool >

struct	hash< bsl::error_code >

struct	hash< bsl::error_condition >

struct	hash< char >

struct	hash< const BSLSTL_KEY >

struct	hash< int >

struct	hash< long >

struct	hash< long long >

struct	hash< short >

struct	hash< signed char >

struct	hash< unsigned char >

struct	hash< unsigned int >

struct	hash< unsigned long >

struct	hash< unsigned long long >

struct	hash< unsigned short >

struct	hash< wchar_t >

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

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_error_code_enum

struct	is_error_condition_enum

struct	is_error_condition_enum< errc::Enum >

struct	is_floating_point

struct	is_floating_point< const t_TYPE >

struct	is_floating_point< const volatile t_TYPE >

struct	is_floating_point< double >

struct	is_floating_point< float >

struct	is_floating_point< long double >

struct	is_floating_point< volatile t_TYPE >

struct	is_function

struct	is_function< t_TYPE & >

struct	is_fundamental

struct	is_integral

struct	is_integral< bool >

struct	is_integral< char >

struct	is_integral< const t_TYPE >

struct	is_integral< const volatile t_TYPE >

struct	is_integral< int >

struct	is_integral< long int >

struct	is_integral< long long int >

struct	is_integral< short int >

struct	is_integral< signed char >

struct	is_integral< unsigned char >

struct	is_integral< unsigned int >

struct	is_integral< unsigned long int >

struct	is_integral< unsigned long long int >

struct	is_integral< unsigned short int >

struct	is_integral< volatile t_TYPE >

struct	is_integral< wchar_t >

struct	is_lvalue_reference

struct	is_lvalue_reference< t_TYPE & >

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

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

class	reference_wrapper

struct	remove_const

struct	remove_const< t_TYPE const >

struct	remove_cv

struct	remove_extent

struct	remove_extent< t_TYPE[]>

struct	remove_extent< t_TYPE[t_SZ]>

struct	remove_pointer

struct	remove_reference

struct	remove_reference< t_TYPE & >

struct	remove_volatile

struct	remove_volatile< t_TYPE volatile >

struct	select1st

struct	select2nd

class	set

class	shared_ptr

class	slist

class	stack

class	stop_callback

class	stop_source

class	stop_token

class	String_ClearProctor

class	String_Imp

class	StringBufContainer

struct	StringComparator

struct	SyncBuf_MutexUtil

class	system_error

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

struct	Vector_RangeIteratorCategory

struct	Vector_RangeIteratorCategory< t_ITERATOR, t_SENTINEL, true >

class	vector_UintPtrConversionIterator

struct	vector_UintPtrRangeAdapter

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 errc::Enum	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	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 = 4942 , e_MAX_SCALAR_STRLEN10 = e_MAX_INT64_STRLEN10 , e_STARTING_LONGDOUBLE_STRLEN10 = 318 }

enum	{ _ALIGN = 8 , _ALIGN_SHIFT =3 , _MAX_BYTES = 128 }

Functions
template<class t_TYPE >
int	bdlat_valueTypeAssign (vector< t_TYPE > *lhs, const vector< t_TYPE > &rhs)

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 T >
reference_wrapper< const T >	cref (const T &object)

template<class T >
reference_wrapper< const T >	cref (reference_wrapper< T > original)

template<class T >
reference_wrapper< T >	ref (T &object)

template<class T >
reference_wrapper< T >	ref (reference_wrapper< T > original)

template<class INPUT_ITERATOR , class PREDICATE >
bool	all_of (INPUT_ITERATOR first, INPUT_ITERATOR last, PREDICATE pred)

template<class INPUT_ITERATOR , class PREDICATE >
bool	any_of (INPUT_ITERATOR first, INPUT_ITERATOR last, PREDICATE pred)

template<class INPUT_ITERATOR , class PREDICATE >
bool	none_of (INPUT_ITERATOR first, INPUT_ITERATOR last, PREDICATE pred)

template<class INPUT_ITERATOR , class OUTPUT_ITERATOR , class PREDICATE >
OUTPUT_ITERATOR	copy_if (INPUT_ITERATOR first, INPUT_ITERATOR last, OUTPUT_ITERATOR result, PREDICATE pred)

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 t_INPUT_ITERATOR , class t_SIZE , class t_OUTPUT_ITERATOR >
t_OUTPUT_ITERATOR	copy_n (t_INPUT_ITERATOR first, t_SIZE count, t_OUTPUT_ITERATOR result)

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)

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

const error_category &	generic_category ()

const error_category &	system_category ()

error_code	make_error_code (errc::Enum value)

error_condition	make_error_condition (errc::Enum value)

template<class HASHALG >
void	hashAppend (HASHALG &hashAlgorithm, const error_code &object)

template<class HASHALG >
void	hashAppend (HASHALG &hashAlgorithm, const error_condition &object)

bool	operator== (const error_code &lhs, const error_code &rhs)

bool	operator== (const error_code &lhs, const error_condition &rhs)

bool	operator== (const error_condition &lhs, const error_code &rhs)

bool	operator== (const error_condition &lhs, const error_condition &rhs)

bool	operator!= (const error_code &, const error_code &)

bool	operator!= (const error_code &, const error_condition &)

bool	operator!= (const error_condition &, const error_code &)

bool	operator!= (const error_condition &, const error_condition &)

bool	operator< (const error_code &lhs, const error_code &rhs)

bool	operator< (const error_condition &lhs, const error_condition &rhs)

template<class CHAR_TYPE , class CHAR_TRAITS >
std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &	operator<< (std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &stream, const error_code &code)

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

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

template<class PROTOTYPE >
void	swap (function< PROTOTYPE > &a, function< PROTOTYPE > &b) BSLS_KEYWORD_NOEXCEPT

ios_base &	defaultfloat (ios_base &ios)

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 T , size_t N>
BSLS_KEYWORD_CONSTEXPR T *	data (T(&array)[N])

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

template<class TYPE , size_t DIMENSION>
BSLS_KEYWORD_CONSTEXPR size_t	size (const TYPE(&)[DIMENSION]) BSLS_KEYWORD_NOEXCEPT

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

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 , class PREDICATE >
multimap< KEY, VALUE, COMPARATOR, ALLOCATOR >::size_type	erase_if (multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &m, PREDICATE predicate)

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 >
BSLSTL_OPTIONAL_CONSTEXPR20 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator>= (const bsl::optional< t_LHS_TYPE > &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator== (const bsl::optional< t_TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator== (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &value) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator!= (const bsl::optional< t_TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator!= (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &value) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator< (const bsl::optional< t_TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator< (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &value) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator> (const bsl::optional< t_TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator> (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator<= (const bsl::optional< t_TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator<= (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator>= (const bsl::optional< t_TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator>= (const bsl::nullopt_t &, const bsl::optional< t_TYPE > &value) BSLS_KEYWORD_NOEXCEPT

template<class t_TYPE , class... t_ARGS>
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 >
BSLSTL_OPTIONAL_CONSTEXPR17 bsl::optional< typename bsl::decay< t_TYPE >::type >	make_optional (BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) rhs)

template<class t_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR17 bsl::optional< t_TYPE >	make_optional ()

template<class t_TYPE , class t_ARG , class... t_ARGS>
BSLSTL_OPTIONAL_CONSTEXPR17	BSLSTL_OPTIONAL_ENABLE_IF_NOT_ALLOCATOR_TAG (t_ARG) make_optional(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARG) arg

BSLSTL_OPTIONAL_CONSTEXPR17	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_CONSTEXPR20	BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_BSL_OPTIONAL (t_TYPE, const t_ANY_TYPE &) &optional< t_TYPE >

template<class t_ANY_TYPE >
BSLSTL_OPTIONAL_CONSTEXPR20	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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 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 >
BSLSTL_OPTIONAL_CONSTEXPR17 bool	operator>= (const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP

template<class t_TYPE >
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(noexcept(a.swap(b)))

template<class HASHALG , class T1 , class T2 >
void	hashAppend (HASHALG &hashAlg, const pair< T1, T2 > &input)

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 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 , class STRING_VIEW_LIKE_TYPE >
	BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T (bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >) operator+(const basic_string< CHAR_TYPE

template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR , class STRING_VIEW_LIKE_TYPE >
	BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T (bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >) operator+(const STRING_VIEW_LIKE_TYPE &lhs

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)

std::size_t	hashBasicString (const string &str)

std::size_t	hashBasicString (const wstring &str)

template<class STRING_VIEW_LIKE_TYPE >
	BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &) basic_string< CHAR_TYPE

template<class STRING_VIEW_LIKE_TYPE >
BSLS_PLATFORM_AGGRESSIVE_INLINE	BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &) basic_string< CHAR_TYPE

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 , class PREDICATE >
unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR >::size_type	erase_if (unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &m, PREDICATE predicate)

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

template<class t_TYPE , class t_OTHER_TYPE >
t_TYPE	exchange (t_TYPE &obj, const t_OTHER_TYPE &newValue)

template<class t_TYPE , class t_OTHER_TYPE >
t_TYPE	exchange (t_TYPE &obj, t_OTHER_TYPE &newValue)

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 t_VALUE_TYPE , class t_ITERATOR , class t_SENTINEL >
vector_UintPtrRangeAdapter< t_VALUE_TYPE, t_ITERATOR, t_SENTINEL >	vector_makeUintPtrRangeAdapter (t_ITERATOR begin, t_SENTINEL end)

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 >
BSLSTL_OPTIONAL_CONSTEXPR17 bool operator==(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator==(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator!=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator!=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator<(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator<(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator>(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator>(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator<=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator<=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator>=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator>=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP 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 from_range_t	from_range

const nostopstate_t	nostopstate

	CHAR_TRAITS

ALLOCATOR &	lhs

ALLOCATOR const STRING_VIEW_LIKE_TYPE &	rhs

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 errc::Enum 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
_ALIGN
_ALIGN_SHIFT
_MAX_BYTES

◆ MaxDecimalStringLengths

enum bsl::MaxDecimalStringLengths

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

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
e_STARTING_LONGDOUBLE_STRLEN10

Function Documentation

◆ __slist_make_link()

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

inline

◆ all_of()

template<class INPUT_ITERATOR , class PREDICATE >

bool bsl::all_of	(	INPUT_ITERATOR	first,
		INPUT_ITERATOR	last,
		PREDICATE	pred
	)

Return true if, for the specified [first, last) range and the specified predicate pred, the range is either empty or pred(*i) is true for every iterator i in the range, and false otherwise.

Note: Note that at most last - first applications of the predicate are performed.

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

◆ any_of()

template<class INPUT_ITERATOR , class PREDICATE >

bool bsl::any_of	(	INPUT_ITERATOR	first,
		INPUT_ITERATOR	last,
		PREDICATE	pred
	)

Return false if, for the specified [first, last) range and the specified predicate pred, the range is either empty or pred(*i) is false for every iterator i in the range, and true otherwise.

Note: Note that at most last - first applications of the predicate are performed.

◆ as_const()

template<class TYPE >

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

inline

Return a reference offering non-modifiable access to the specified t.

◆ bdlat_valueTypeAssign()

template<class t_TYPE >

int bsl::bdlat_valueTypeAssign	(	vector< t_TYPE > *	lhs,
		const vector< t_TYPE > &	rhs
	)

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

BSLSTL_OPTIONAL_CONSTEXPR17 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 >

BSLSTL_OPTIONAL_CONSTEXPR20 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 >

BSLSTL_OPTIONAL_CONSTEXPR20 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>

BSLSTL_OPTIONAL_CONSTEXPR17 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. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T() [1/4]

template<class STRING_VIEW_LIKE_TYPE >

bsl::BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T ( basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > & )

inline

◆ BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T() [2/4]

template<class STRING_VIEW_LIKE_TYPE >

BSLS_PLATFORM_AGGRESSIVE_INLINE bsl::BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T ( basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > & )

◆ BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T() [3/4]

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

bsl::BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T ( bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > ) const

◆ BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T() [4/4]

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

bsl::BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T ( bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > ) const &

◆ 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: Note that if source cannot be const-cast to TO_TYPE *, then a compiler diagnostic will be emitted indicating the error.

◆ copy_if()

template<class INPUT_ITERATOR , class OUTPUT_ITERATOR , class PREDICATE >

OUTPUT_ITERATOR bsl::copy_if	(	INPUT_ITERATOR	first,
		INPUT_ITERATOR	last,
		OUTPUT_ITERATOR	result,
		PREDICATE	pred
	)

Copy all elements in the half-open range of the specified first, and last ([first, last)) input iterators for which the specified pred unary predicate is true to the specified result output iterator, incrementing result after each copied element, keeping the element order stable.

Precondition: The behavior is undefined if the ranges [first, last) and [result, advance(result, distance(first, last))) overlap. The behavior is also undefined if pred attempts to invoke any non-constant functions of its argument. See also [alg.copy] in the C++11 standard.

◆ copy_n()

template<class t_INPUT_ITERATOR , class t_SIZE , class t_OUTPUT_ITERATOR >

t_OUTPUT_ITERATOR bsl::copy_n	(	t_INPUT_ITERATOR	first,
		t_SIZE	count,
		t_OUTPUT_ITERATOR	result
	)

inline

Copy the specified count elements from the specified first to the specified result. Return an iterator pointing past the last copied element in the output range.

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

◆ cref() [1/2]

template<class T >

reference_wrapper< const T > bsl::cref ( const T & object )

Return a reference wrapper representing a const view of the specified object.

◆ cref() [2/2]

template<class T >

reference_wrapper< const T > bsl::cref ( reference_wrapper< T > original )

Return a reference wrapper representing a const view of the same object as the specified original.

◆ 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/3]

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/3]

template<class CONTAINER >

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

inline

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

◆ data() [3/3]

template<class T , size_t N>

BSLS_KEYWORD_CONSTEXPR T * bsl::data ( T(&) array[N] )

inline

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

◆ defaultfloat()

ios_base & bsl::defaultfloat ( ios_base & ios )

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

Return false (Zero-length arrays are not allowed).

◆ 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/12]

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/12]

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/12]

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/12]

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/12]

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

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

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

◆ erase_if() [6/12]

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

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() [8/12]

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() [9/12]

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

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

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

◆ erase_if() [10/12]

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() [11/12]

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

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.

◆ exchange() [1/2]

template<class t_TYPE , class t_OTHER_TYPE >

t_TYPE bsl::exchange	(	t_TYPE &	obj,
		const t_OTHER_TYPE &	newValue
	)

Assign to the specified obj the specified newValue, and return the value held by obj prior to that assignment.

Note

Note that these functions support move semantics, simulated using bslmf::MovableRef:

The return value is move-constructed from obj.
If t_OTHER_TYPE is a specialization of bslmf::MovableRef, then move assignment to obj will occur.

◆ exchange() [2/2]

template<class t_TYPE , class t_OTHER_TYPE >

t_TYPE bsl::exchange	(	t_TYPE &	obj,
		t_OTHER_TYPE &	newValue
	)

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

◆ generic_category()

const error_category & bsl::generic_category ( )

Return a const reference to the unique generic category object.

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

Return a reference to the alternative object at index (template parameter) t_INDEX in the specified obj. If t_INDEX is not the index of the currently active alternative, throw an exception of type bad_variant_access . t_INDEX shall be a valid index for the variant type of obj.

Note: Note that t_VARIANT may be const-qualified.

◆ get() [7/7]

template<class t_TYPE , class t_VARIANT >

Variant_GetTypeReturnType< t_TYPE &, t_VARIANT >::type bsl::get ( t_VARIANT & obj )

Return a reference to the alternative object with type (template parameter) t_TYPE in the specified obj. If t_TYPE is not the type of the currently active alternative, throw an exception of type bad_variant_access . t_TYPE shall appear exactly once in the variant`s list of alternatives.

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

Return a pointer to the alternative object with type (template parameter) t_TYPE in the specified obj, or a null pointer if obj itself is a null pointer or if t_TYPE is not the type of the currently active alternative. t_TYPE shall appear exactly once in the variant`s list of alternatives.

◆ 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 returnis. The newline character is removed from the input stream but is not appended tostr. If aneof is detected before the newline, then the characters up to theeofare put intostrandis.eof()becomes true. Ifis.good()is false on entry, then do nothing, otherwise if no characters are extracted (e.g., because because the stream is at eof),strwill 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/12]

template<class HASH_ALGORITHM , class TYPE , size_t SIZE>

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

Pass the specified input to the specified hashAlgorithm

◆ hashAppend() [2/12]

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/12]

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/12]

template<class HASHALG , class T1 , class T2 >

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

Pass the specified input to the specified hashAlg

◆ hashAppend() [5/12]

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/12]

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/12]

template<class HASHALG , class VALUE_TYPE , class ALLOCATOR >

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

inline

◆ hashAppend() [8/12]

template<class HASHALG >

void bsl::hashAppend	(	HASHALG &	hashAlgorithm,
		const error_code &	object
	)

Hash the specified object using the specified hashAlgorithm.

◆ hashAppend() [9/12]

template<class HASHALG >

void bsl::hashAppend	(	HASHALG &	hashAlgorithm,
		const error_condition &	object
	)

Hash the specified object using the specified hashAlgorithm.

◆ hashAppend() [10/12]

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() [11/12]

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

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 )

Return a hash value for the specified str.

◆ hashBasicString() [2/3]

std::size_t bsl::hashBasicString ( const string & str )

Return a hash value for the specified str.

◆ hashBasicString() [3/3]

std::size_t bsl::hashBasicString ( const wstring & str )

Return a hash value for the specified 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_error_code()

error_code bsl::make_error_code ( errc::Enum value )

inline

Return an error_code object holding the specified value and generic category.

Note: Note that the category is generic rather than system because that is what the standard specifies.

◆ make_error_condition()

error_condition bsl::make_error_condition ( errc::Enum value )

inline

Return an error_condition object holding the specified value and generic category.

◆ make_optional() [1/4]

template<class t_TYPE >

BSLSTL_OPTIONAL_CONSTEXPR17 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. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ make_optional() [2/4]

template<class t_TYPE >

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>

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: Note that this function will fail to compile if t_TYPE doesn't use allocators.

◆ make_optional() [4/4]

template<class t_TYPE >

BSLSTL_OPTIONAL_CONSTEXPR17 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. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

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

◆ none_of()

template<class INPUT_ITERATOR , class PREDICATE >

bool bsl::none_of	(	INPUT_ITERATOR	first,
		INPUT_ITERATOR	last,
		PREDICATE	pred
	)

Return true if, for the specified [first, last) range and the specified predicate pred, the range is either empty or pred(*i) is false for every iterator i in the range, and false otherwise.

Note: Note that at most last - first applications of the predicate are performed.

◆ operator!=() [1/46]

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/46]

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/46]

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/46]

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/46]

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/46]

template<class t_TYPE >

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

inline

◆ operator!=() [7/46]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

Return true if the specified lhs and rhs optional objects do not have the same value, and false otherwise. Two optional objects do not have the same value if one is disengaged and the other is engaged, or if both are engaged and the values of their underlying objects do not compare equal. This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator-aware.

◆ operator!=() [8/46]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

◆ operator!=() [9/46]

template<class t_TYPE >

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

inline

Return true if the specified value is engaged, and false otherwise. These functions can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ operator!=() [10/46]

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/46]

template<class VALUE_TYPE , class ALLOCATOR >

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

inline

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two deque 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_TYPE be equality-comparable (see {Requirements on VALUE_TYPE}).

◆ operator!=() [12/46]

bool bsl::operator!=	(	const error_code &	lhs,
		const error_code &	rhs
	)

inline

Return whether the specified lhs and rhs are not equal or equivalent.

◆ operator!=() [13/46]

bool bsl::operator!=	(	const error_code &	lhs,
		const error_condition &	rhs
	)

inline

◆ operator!=() [14/46]

bool bsl::operator!=	(	const error_condition &	lhs,
		const error_code &	rhs
	)

inline

◆ operator!=() [15/46]

bool bsl::operator!=	(	const error_condition &	lhs,
		const error_condition &	rhs
	)

inline

◆ operator!=() [16/46]

template<class PROTOTYPE >

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

◆ operator!=() [17/46]

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!=() [18/46]

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!=() [19/46]

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!=() [20/46]

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!=() [21/46]

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!=() [22/46]

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 do not have the same value, and false otherwise. Two list 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!=() [23/46]

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!=() [24/46]

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!=() [25/46]

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!=() [26/46]

template<class KEY , class COMPARATOR , class ALLOCATOR >

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

◆ operator!=() [27/46]

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!=() [28/46]

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: 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!=() [29/46]

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!=() [30/46]

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!=() [31/46]

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: Note that two shared pointers that do not compare equal may manage the same object due to aliasing.

◆ operator!=() [32/46]

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!=() [33/46]

template<class _Tp , class _Alloc >

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

inline

◆ operator!=() [34/46]

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!=() [35/46]

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!=() [36/46]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

◆ operator!=() [37/46]

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!=() [38/46]

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!=() [39/46]

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!=() [40/46]

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!=() [41/46]

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

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 do not have the same value, and false otherwise. Two vector 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_TYPE be equality-comparable (see {Requirements on VALUE_TYPE}).

◆ operator!=() [43/46]

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 do not have the same value, and false otherwise. Two iterators do not have the same value unless both refer to the same element of the same list or unless both are the end() iterator of the same list.

Precondition: The behavior is undefined unless both lhs and rhs refer to the same list.

Note: 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!=() [44/46]

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

inline

◆ operator!=() [45/46]

template<class PROTOTYPE >

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

Return false if the function argument is empty, otherwise return true.

◆ operator!=() [46/46]

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: 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/29]

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/29]

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/29]

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/29]

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/29]

template<class t_TYPE >

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

inline

Return true if the specified value is engaged, and false otherwise.

Note: Note that bsl::nullopt_t is ordered before any bsl::optional that is engaged. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ operator<() [6/29]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

Return true if the specified lhs optional object is ordered before the specified rhs optional object, and false otherwise. lhs is ordered before rhs if lhs is disengaged and rhs is engaged or if both are engaged and lhs.value() is ordered before rhs.value(). This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator-aware.

◆ operator<() [7/29]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

◆ operator<() [8/29]

template<class t_TYPE >

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

inline

Return false.

Note: Note that bsl::nullopt_t never orders after a bsl::optional. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ operator<() [9/29]

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/29]

template<class VALUE_TYPE , class ALLOCATOR >

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

inline

Return true if the value of the specified lhs deque is lexicographically less than that of the specified rhs deque, and false otherwise. Given iterators i and j over the respective sequences [lhs.begin() .. lhs.end()) and [rhs.begin() .. rhs.end()), the value of deque lhs is lexicographically less than that of deque 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<() [11/29]

bool bsl::operator<	(	const error_code &	lhs,
		const error_code &	rhs
	)

inline

Return whether the specified lhs is lexicographically less than the specified rhs, ordered by category then value.

◆ operator<() [12/29]

bool bsl::operator<	(	const error_condition &	lhs,
		const error_condition &	rhs
	)

inline

◆ operator<() [13/29]

template<class VALUE , class ALLOCATOR >

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

Return true if the value of the specified lhs list is lexicographically less than that of the specified rhs list, and false otherwise. Given iterators i and j over the respective sequences [lhs.begin() .. lhs.end()) and [rhs.begin() .. rhs.end()), the value of list lhs is lexicographically less than that of list 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<() [14/29]

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<() [15/29]

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<() [16/29]

template<class KEY , class COMPARATOR , class ALLOCATOR >

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

◆ operator<() [17/29]

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<() [18/29]

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<() [19/29]

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<() [20/29]

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<() [21/29]

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<() [22/29]

template<class _Tp , class _Alloc >

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

inline

◆ operator<() [23/29]

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<() [24/29]

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<() [25/29]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

◆ operator<() [26/29]

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<() [27/29]

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 value of the specified lhs vector is lexicographically less than that of the specified rhs vector, and false otherwise. Given iterators i and j over the respective sequences [lhs.begin() .. lhs.end()) and [rhs.begin() .. rhs.end()), the value of vector lhs is lexicographically less than that of vector 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<() [28/29]

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

inline

◆ operator<() [29/29]

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/5]

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/5]

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/5]

template<class CHAR_TYPE , class CHAR_TRAITS >

std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > & bsl::operator<<	(	std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &	stream,
		const error_code &	code
	)

inline

Write the specified code to stream.

◆ operator<<() [4/5]

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

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

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

inline

Return true.

Note: Note that bsl::nullopt_t is ordered before any bsl::optional that is engaged. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ operator<=() [6/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

BSLSTL_OPTIONAL_CONSTEXPR17 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

Return true if the specified lhs optional object is ordered before the specified rhs optional object or if lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator-aware.

◆ operator<=() [7/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

◆ operator<=() [8/27]

template<class t_TYPE >

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

inline

Return true if the specified value is disengaged, and false otherwise. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ 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

Return true if the value of the specified lhs deque is lexicographically less than or equal to that of the specified rhs deque, and false otherwise. The value of deque lhs is lexicographically less than or equal to that of deque 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: Note that this operator returns !(rhs < lhs).

◆ operator<=() [11/27]

template<class VALUE , class ALLOCATOR >

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

Return true if the value of the specified lhs list is lexicographically less than or equal to that of the specified rhs list, and false otherwise. The value of list lhs is lexicographically less than or equal to that of list 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: Note that this operator returns !(rhs < lhs).

◆ 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: 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: 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: 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 >

BSLSTL_OPTIONAL_CONSTEXPR17 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

Return true if the value of the specified lhs vector is lexicographically less than or equal to that of the specified rhs vector, and false otherwise. The value of vector lhs is lexicographically less than or equal to that of vector 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: Note that this operator returns !(rhs < lhs).

◆ 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/46]

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/46]

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/46]

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/46]

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/46]

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/46]

template<class t_TYPE >

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

inline

◆ operator==() [7/46]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

Return true if the specified lhs and rhs optional objects have the same value, and false otherwise. Two optional objects have the same value if both are disengaged, or if both are engaged and the values of their underlying objects compare equal. This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator-aware.

◆ operator==() [8/46]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

◆ operator==() [9/46]

template<class t_TYPE >

BSLSTL_OPTIONAL_CONSTEXPR17 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

Return true if the specified value is disengaged, and false otherwise. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ operator==() [10/46]

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/46]

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/46]

bool bsl::operator==	(	const error_code &	lhs,
		const error_code &	rhs
	)

inline

Return whether the specified lhs and rhs are equal or equivalent.

◆ operator==() [13/46]

bool bsl::operator==	(	const error_code &	lhs,
		const error_condition &	rhs
	)

inline

◆ operator==() [14/46]

bool bsl::operator==	(	const error_condition &	lhs,
		const error_code &	rhs
	)

inline

◆ operator==() [15/46]

bool bsl::operator==	(	const error_condition &	lhs,
		const error_condition &	rhs
	)

inline

◆ operator==() [16/46]

template<class PROTOTYPE >

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

◆ operator==() [17/46]

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==() [18/46]

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==() [19/46]

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==() [20/46]

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==() [21/46]

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==() [22/46]

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==() [23/46]

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==() [24/46]

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==() [25/46]

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==() [26/46]

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==() [27/46]

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==() [28/46]

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: 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==() [29/46]

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==() [30/46]

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==() [31/46]

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: Note that two shared pointers that compare equal do not necessarily manage the same object due to aliasing.

◆ operator==() [32/46]

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==() [33/46]

template<class _Tp , class _Alloc >

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

inline

◆ operator==() [34/46]

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==() [35/46]

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==() [36/46]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

◆ operator==() [37/46]

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: Note that this method requires that the (template parameter) types KEY and VALUE both be equality-comparable (see {Requirements on value_type}).

◆ operator==() [38/46]

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==() [39/46]

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: Note that this method requires that the (template parameter) type KEY be equality-comparable (see {Requirements on KEY}).

◆ operator==() [40/46]

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: Note that this method requires that the (template parameter) type KEY be equality-comparable (see {Requirements on KEY}).

◆ operator==() [41/46]

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

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==() [43/46]

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.

Precondition: The behavior is undefined unless both lhs and rhs refer to the same list.

Note: 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==() [44/46]

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==() [45/46]

template<class PROTOTYPE >

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

Return true if the function argument is empty, otherwise return false.

◆ operator==() [46/46]

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 >

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

inline

Return false.

Note: Note that bsl::nullopt_t never orders after a bsl::optional. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ operator>() [6/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

BSLSTL_OPTIONAL_CONSTEXPR17 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

Return true if the specified lhs optional object is ordered after the specified rhs optional object, and false otherwise. lhs is ordered after rhs if lhs is engaged and rhs is disengaged or if both are engaged and lhs.value() is ordered after rhs.value(). This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator-aware.

◆ operator>() [7/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

◆ operator>() [8/27]

template<class t_TYPE >

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

inline

Return true if the specified value is engaged, and false otherwise. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ 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

Return true if the value of the specified lhs deque is lexicographically greater than that of the specified rhs deque, and false otherwise. The value of deque lhs is lexicographically greater than that of deque 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: Note that this operator returns rhs < lhs.

◆ operator>() [11/27]

template<class VALUE , class ALLOCATOR >

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

Return true if the value of the specified lhs list is lexicographically greater than that of the specified rhs list, and false otherwise. The value of list lhs is lexicographically greater than that of list 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: Note that this operator returns rhs < lhs.

◆ 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: 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: 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: 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 >

BSLSTL_OPTIONAL_CONSTEXPR17 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

Return true if the value of the specified lhs vector is lexicographically greater than that of the specified rhs vector, and false otherwise. The value of vector lhs is lexicographically greater than that of vector 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: Note that this operator returns rhs < lhs.

◆ 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 >

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

inline

Return true if the specified value is disengaged, and false otherwise. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ operator>=() [6/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

BSLSTL_OPTIONAL_CONSTEXPR17 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

Return true if the specified lhs optional object is ordered after the specified rhs optional object or if lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator-aware.

◆ operator>=() [7/27]

template<class t_LHS_TYPE , class t_RHS_TYPE >

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

◆ operator>=() [8/27]

template<class t_TYPE >

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

inline

Return true.

Note: Note that bsl::nullopt_t is ordered before any bsl::optional that is engaged. This function can be called in constant expressions only if t_TYPE is not allocator-aware.

◆ 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

Return true if the value of the specified lhs deque is lexicographically greater than or equal to that of the specified rhs deque, and false otherwise. The value of deque lhs is lexicographically greater than or equal to that of deque 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: Note that this operator returns !(lhs < rhs).

◆ operator>=() [11/27]

template<class VALUE , class ALLOCATOR >

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

Return true if the value of the specified lhs list is lexicographically greater than or equal to that of the specified rhs list, and false otherwise. The value of list lhs is lexicographically greater than or equal to that of list 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: Note that this operator returns !(lhs < 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: 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: 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: 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 >

BSLSTL_OPTIONAL_CONSTEXPR17 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

Return true if the value of the specified lhs vector is lexicographically greater than or equal to that of the specified rhs vector, and false otherwise. The value of vector lhs is lexicographically greater than or equal to that of vector 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: Note that this operator returns !(lhs < rhs).

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

◆ ref() [1/2]

template<class T >

reference_wrapper< T > bsl::ref ( reference_wrapper< T > original )

Return a reference wrapper that represents the same object as the specified original.

◆ ref() [2/2]

template<class T >

reference_wrapper< T > bsl::ref ( T & object )

Return a reference wrapper that represents the specified object.

◆ 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: 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

Return the dimension of the specified array argument.

◆ 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

Return the dimension of the specified array argument.

◆ 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: 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`
	)

◆ 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`
	)

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.

◆ stold() [2/2]

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

◆ 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`
	)

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.

Precondition: The behavior is undefined unless base is valid.

Note: 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.

◆ stoull() [2/2]

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

◆ swap() [1/28]

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/28]

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: Note that this functions support for swapping objects created with different allocators whenALLOCATOR` does not have the propagate_on_container_swap trait is a departure from the C++ Standard.

◆ swap() [3/28]

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/28]

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/28]

template<class t_TYPE >

BSLSTL_OPTIONAL_CONSTEXPR20 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/28]

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/28]

template<class VALUE_TYPE , class ALLOCATOR >

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

inline

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 number of elements in a and b, respectively.

Note: Note that this functions support for swapping objects created with different allocators whenALLOCATOR` does not have the propagate_on_container_swap trait is a departure from the C++ Standard.

◆ swap() [8/28]

template<class PROTOTYPE >

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

Exchange the targets held by the specified a and specified b objects.

Precondition: The behavior is undefined unless 'a.get_allocator() == b.get_allocator()'.

◆ swap() [9/28]

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/28]

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/28]

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/28]

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/28]

template<class VALUE , class ALLOCATOR >

void bsl::swap	(	list< VALUE, ALLOCATOR > &	a,
		list< VALUE, 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 number of elements in a and b, respectively.

Note: Note that this functions support for swapping objects created with different allocators whenALLOCATOR` does not have the propagate_on_container_swap trait is a departure from the C++ Standard.

◆ swap() [14/28]

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: 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/28]

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: 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/28]

template<class KEY , class COMPARATOR , class ALLOCATOR >

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

◆ swap() [17/28]

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: Note that this method is no-throw only if swap on each field is no-throw.

◆ swap() [18/28]

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/28]

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/28]

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: Note that this functions support for swapping objects created with different allocators whenALLOCATOR` does not have the propagate_on_container_swap trait is a departure from the C++ Standard.

◆ swap() [21/28]

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/28]

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() [23/28]

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.

Precondition: 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() [24/28]

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.

Precondition: 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/28]

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() [26/28]

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() [27/28]

template<class VALUE_TYPE , class ALLOCATOR >

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

inline

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 number of elements in a and b, respectively.

Note: Note that this functions support for swapping objects created with different allocators whenALLOCATOR` does not have the propagate_on_container_swap trait is a departure from the C++ Standard.

◆ swap() [28/28]

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.

◆ system_category()

const error_category & bsl::system_category ( )

Return a const reference to the unique system category object.

◆ 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: 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 )

◆ to_string() [2/9]

string bsl::to_string ( float 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() [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 )

◆ to_wstring() [2/9]

wstring bsl::to_wstring ( float 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() [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 is guaranteed to return 0 if there are no uncaught exceptions.

◆ vector_makeUintPtrRangeAdapter()

template<class t_VALUE_TYPE , class t_ITERATOR , class t_SENTINEL >

vector_UintPtrRangeAdapter< t_VALUE_TYPE, t_ITERATOR, t_SENTINEL > bsl::vector_makeUintPtrRangeAdapter	(	t_ITERATOR	begin,
		t_SENTINEL	end
	)

inline

Factory function for vector_UintPtrRangeAdapter.

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

Return the result of invoking the specified visitor with a bslmf::MovableRef referring to the currently active alternative of the specified variant. If variant does not hold a value, throw an exception of type bsl::bad_variant_access. For each alternative, invocation of the visitor with that alternative shall be of the same type and value category.

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

Return the result of invoking the specified visitor with the currently active alternative of the specified variant. If variant does not hold a value, throw an exception of type bsl::bad_variant_access. For each alternative, invocation of the visitor with that alternative shall be of the same type and value category.

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

Return the result of invoking the specified visitor with a bslmf::MovableRef referring to the currently active alternative of the specified variant, implicitly converting the result to the explicitly specified (template parameter) t_RET. If variant does not hold a value, throw an exception of type bsl::bad_variant_access. Unlike visit, which deduces its return type, this function does not require the visitor to yield the exact same type for each alternative, but only requires each such type to be implicitly convertible to t_RET. Implementation note: Due to limitations of the type deduction facility in C++03, this function can not share the same name as the deduced type visit because it is not possible to discern between invocation of non deduced return type visit where the return type parameter is explicitly specified and invocation of deduced return type visit where the visitor type parameter is explicitly specified.

◆ visitR() [2/2]

template<class t_RET , class t_VISITOR , class t_VARIANT >

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

Return the result of invoking the specified visitor with the currently active alternative of the specified variant, implicitly converting the result to the explicitly specified (template parameter) t_RET. If variant does not hold a value, throw an exception of type bsl::bad_variant_access. Unlike visit, which deduces its return type, this function does not require the visitor to yield the exact same type for each alternative, but only requires each such type to be implicitly convertible to t_RET. Implementation note: Due to limitations of the type deduction facility in C++03, this function can not share the same name as the deduced type visit because it is not possible to discern between invocation of non deduced return type visit where the return type parameter is explicitly specified and invocation of deduced return type visit where the visitor type parameter is explicitly specified.

Variable Documentation

◆ CHAR_TRAITS

BSLS_PLATFORM_AGGRESSIVE_INLINE bsl::CHAR_TRAITS

◆ from_range

const from_range_t bsl::from_range

extern

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

◆ lhs

ALLOCATOR& bsl::lhs

◆ make_optional

template<class t_TYPE >

BSLSTL_OPTIONAL_CONSTEXPR17 bool operator==(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator==(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator!=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator!=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator<(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator<(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator>(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator>(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator<=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator<=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator>=(const bsl::optional< t_LHS_TYPE > &lhs, const t_RHS_TYPE &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP BSLSTL_OPTIONAL_CONSTEXPR17 bool operator>=(const t_LHS_TYPE &lhs, const bsl::optional< t_RHS_TYPE > &rhs) BSLSTL_OPTIONAL_REQUIRES(!BloombergLP 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
	)

called in constant expressions only if t_LHS_TYPE is not allocator-aware.

Return true if the specified lhs and rhs objects have the same value, and false otherwise. An optional object and a value of some type have the same value if the optional object is engaged and its underlying value compares equal to the other value. These functions can be called in constant expressions only if the optional's value type is not allocator-aware. Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. An optional object and a value of some type do not have the same value if either the optional object is disengaged, or its underlying value does not compare equal to the other value. These function can be called in constant expressions only if the optional's value type is not allocator-aware. Return true if the specified lhs optional object is ordered before the specified rhs, and false otherwise. lhs is ordered before rhs if lhs is disengaged or lhs.value() is ordered before rhs. This function can be called in constant expressions only if t_LHS_TYPE is not allocator-aware. Return true if the specified lhs is ordered before the specified rhs optional object, and false otherwise. lhs is ordered before rhs if rhs is engaged and lhs is ordered before rhs.value(). This function can be called in constant expressions only if t_RHS_TYPE is not allocator-aware. Return true if the specified lhs optional object is ordered after the specified rhs, and false otherwise. lhs is ordered after rhs if lhs is engaged and lhs.value() is ordered after rhs. This function can be called in constant expressions only if t_LHS_TYPE is not allocator-aware. Return true if the specified lhs is ordered after the specified rhs optional object, and false otherwise. lhs is ordered after rhs if rhs is disengaged or lhs is ordered after rhs.value(). This function can be called in constant expressions only if t_RHS_TYPE is not allocator-aware. Return true if the specified lhs optional object is ordered before the specified rhs or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) This function can be called in constant expressions only if t_LHS_TYPE is not allocator-aware. Return true if the specified lhs is ordered before the specified rhs optional object or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) This function can be called in constant expressions only if t_RHS_TYPE is not allocator-aware. Return true if the specified lhs optional object is ordered after the specified rhs or if lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) This function can be called in constant expressions only if t_LHS_TYPE is not allocator-aware. 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: 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

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

◆ rhs

const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > & bsl::rhs

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ __oom_handler_type

◆ _Sl_global_inst

◆ _Stl_prime_type

◆ bad_weak_ptr

◆ ErrcEnum

◆ false_type

◆ istringstream

◆ nullptr_t

◆ ostringstream

◆ osyncstream

◆ Pair_BslmaIdiomAllocatorArgT

◆ Pair_BslmaIdiomAtEnd

◆ Pair_BslmaIdiomNone

◆ string

◆ string_view

◆ stringbuf

◆ stringstream

◆ syncbuf

◆ SyncBuf_Mutex

◆ true_type

◆ wistringstream

◆ wostringstream

◆ wosyncstream

◆ wstring

◆ wstring_view

◆ wstringbuf

◆ wstringstream

◆ wsyncbuf

Enumeration Type Documentation

◆ anonymous enum

◆ MaxDecimalStringLengths

Function Documentation

◆ __slist_make_link()

◆ all_of()

◆ allocate_shared() [1/10]

◆ allocate_shared() [2/10]

◆ allocate_shared() [3/10]

◆ allocate_shared() [4/10]

◆ allocate_shared() [5/10]

◆ allocate_shared() [6/10]

◆ allocate_shared() [7/10]

◆ allocate_shared() [8/10]

◆ allocate_shared() [9/10]

◆ allocate_shared() [10/10]

◆ allocate_shared_for_overwrite() [1/6]

◆ allocate_shared_for_overwrite() [2/6]

◆ allocate_shared_for_overwrite() [3/6]

◆ allocate_shared_for_overwrite() [4/6]

◆ allocate_shared_for_overwrite() [5/6]

◆ allocate_shared_for_overwrite() [6/6]

◆ any_of()

◆ as_const()

◆ bdlat_valueTypeAssign()

◆ begin() [1/4]

◆ begin() [2/4]

◆ begin() [3/4]

◆ begin() [4/4]

◆ BSLS_COMPILERFEATURES_FORWARD_REF()

◆ BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_ANY_TYPE()

◆ BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_BSL_OPTIONAL() [1/2]

◆ BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_BSL_OPTIONAL() [2/2]

◆ BSLSTL_OPTIONAL_ENABLE_ASSIGN_FROM_DERIVED()

◆ BSLSTL_OPTIONAL_ENABLE_IF_NOT_ALLOCATOR_TAG()

◆ BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T() [1/4]

◆ BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T() [2/4]

◆ BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T() [3/4]

◆ BSLSTL_STRING_ONLY_STRINGVIEW_ENABLE_IF_T() [4/4]

◆ cbegin() [1/2]

◆ cbegin() [2/2]

◆ cend() [1/2]

◆ cend() [2/2]

◆ clamp() [1/2]

◆ clamp() [2/2]