Quick Links:

bal | bbl | bdl | bsl

Namespaces | Classes | Typedefs | Enumerations | Functions | Variables

bsl Namespace Reference
[Component bdlde_base64decoderoptions, Component bdlde_base64encoderoptions, Component bslalg_nothrowmovablewrapper, Component bslma_allocatortraits, Component bslmf_addconst, Component bslmf_addpointer, Component bslmf_addvolatile, Component bslmf_integralconstant, Component bslmf_invokeresult, Component bslmf_isclass, Component bslmf_isfundamental, Component bslmf_ispolymorphic, Component bslmf_removepointer, Component bslmf_usesallocator, Component bsls_nullptr, Component bslstl_algorithm, Component bslstl_badweakptr, Component bslstl_boyermoorehorspoolsearcher, Component bslstl_defaultsearcher, Component bslstl_iomanip, Component bslstl_sharedptr, Component bslstl_stringbuf]

Namespaces

namespace  bsl_deprecated
namespace  chrono

Classes

struct  is_trivially_copyable< BloombergLP::bdlde::Base64DecoderOptions >
struct  is_trivially_copyable< BloombergLP::bdlde::Base64EncoderOptions >
struct  allocator_traits
struct  allocator_traits< ALLOCATOR_TYPE * >
struct  IsStdAllocator
struct  IsStdAllocator< std::allocator< TYPE > >
struct  IsStdAllocator< ::bsl::allocator< TYPE > >
class  allocator
class  allocator< void >
struct  allocator_traits< allocator< TYPE > >
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 volatile >
struct  add_lvalue_reference< void const volatile >
struct  add_pointer
struct  add_pointer< t_TYPE & >
struct  add_volatile
struct  allocator_arg_t
struct  conditional
struct  conditional< false, t_TRUE_TYPE, t_FALSE_TYPE >
class  decay
struct  decay_imp
struct  decay_imp< t_TYPE, true, false >
struct  decay_imp< t_TYPE, false, true >
struct  enable_if
struct  enable_if< false, t_TYPE >
struct  integral_constant
struct  integral_constant< bool, t_VAL >
class  invoke_result
struct  is_arithmetic
struct  is_array
struct  is_array< t_TYPE[t_NUM_ELEMENTS]>
struct  is_array< t_TYPE[]>
struct  is_class
struct  is_const
struct  is_const< const t_TYPE >
struct  is_convertible_dispatch
struct  is_convertible_dispatch< t_TYPE, t_TYPE & >
struct  is_convertible_dispatch< t_TYPE, const t_TYPE & >
struct  is_convertible_dispatch< t_TYPE, volatile t_TYPE & >
struct  is_convertible_dispatch< t_TYPE, const volatile t_TYPE & >
struct  is_convertible_dispatch< const t_TYPE, t_TYPE & >
struct  is_convertible_dispatch< const t_TYPE, const t_TYPE & >
struct  is_convertible_dispatch< const t_TYPE, volatile t_TYPE & >
struct  is_convertible_dispatch< const t_TYPE, const volatile t_TYPE & >
struct  is_convertible_dispatch< volatile t_TYPE, t_TYPE & >
struct  is_convertible_dispatch< volatile t_TYPE, const t_TYPE & >
struct  is_convertible_dispatch< volatile t_TYPE, volatile t_TYPE & >
struct  is_convertible_dispatch< 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, const t_TYPE & >
struct  is_convertible_dispatch< const volatile t_TYPE, volatile t_TYPE & >
struct  is_convertible_dispatch< const volatile t_TYPE, const volatile t_TYPE & >
struct  is_convertible_dispatch< t_TYPE &, t_TYPE & >
struct  is_convertible_dispatch< t_TYPE &, const t_TYPE & >
struct  is_convertible_dispatch< t_TYPE &, volatile t_TYPE & >
struct  is_convertible_dispatch< t_TYPE &, const volatile t_TYPE & >
struct  is_convertible_dispatch< const t_TYPE &, t_TYPE & >
struct  is_convertible_dispatch< const t_TYPE &, const t_TYPE & >
struct  is_convertible_dispatch< const t_TYPE &, volatile t_TYPE & >
struct  is_convertible_dispatch< const t_TYPE &, const volatile t_TYPE & >
struct  is_convertible_dispatch< volatile t_TYPE &, t_TYPE & >
struct  is_convertible_dispatch< volatile t_TYPE &, const t_TYPE & >
struct  is_convertible_dispatch< volatile t_TYPE &, volatile t_TYPE & >
struct  is_convertible_dispatch< 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 &, const t_TYPE & >
struct  is_convertible_dispatch< const volatile t_TYPE &, volatile t_TYPE & >
struct  is_convertible_dispatch< const volatile t_TYPE &, const volatile t_TYPE & >
struct  is_convertible_dispatch< volatile t_TYPE, t_TYPE >
struct  is_convertible_dispatch< t_FROM_TYPE, volatile t_TO_TYPE & >
struct  is_convertible_dispatch< t_FROM_TYPE, const volatile t_TO_TYPE & >
struct  is_convertible_dispatch< volatile t_FROM_TYPE &, volatile t_TO_TYPE & >
struct  is_convertible_dispatch< volatile t_FROM_TYPE &, const volatile t_TO_TYPE & >
struct  EffectiveFromType
struct  is_convertible_dispatch< volatile t_FROM_TYPE &, t_TO_TYPE >
struct  is_convertible
struct  is_copy_constructible
struct  is_copy_constructible< const t_TYPE >
struct  is_copy_constructible< t_TYPE[t_LEN]>
struct  is_copy_constructible< const t_TYPE[t_LEN]>
struct  is_copy_constructible< volatile t_TYPE[t_LEN]>
struct  is_copy_constructible< const volatile t_TYPE[t_LEN]>
struct  is_copy_constructible< t_TYPE[]>
struct  is_copy_constructible< const t_TYPE[]>
struct  is_copy_constructible< volatile t_TYPE[]>
struct  is_copy_constructible< const volatile t_TYPE[]>
struct  Is_Empty_Size
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
struct  is_empty< const t_TYPE >
struct  is_empty< volatile t_TYPE >
struct  is_empty< const volatile t_TYPE >
struct  is_enum
struct  is_enum< t_TYPE * >
struct  is_enum< void >
struct  is_enum< const t_TYPE >
struct  is_enum< volatile t_TYPE >
struct  is_enum< const volatile t_TYPE >
struct  is_floating_point
struct  is_floating_point< float >
struct  is_floating_point< double >
struct  is_floating_point< long double >
struct  is_floating_point< const t_TYPE >
struct  is_floating_point< volatile t_TYPE >
struct  is_floating_point< const volatile t_TYPE >
struct  is_function
struct  is_function< t_TYPE & >
struct  is_fundamental
struct  is_integral
struct  is_integral< const t_TYPE >
struct  is_integral< volatile t_TYPE >
struct  is_integral< const volatile t_TYPE >
struct  is_integral< bool >
struct  is_integral< char >
struct  is_integral< wchar_t >
struct  is_integral< signed char >
struct  is_integral< unsigned char >
struct  is_integral< short int >
struct  is_integral< unsigned short int >
struct  is_integral< int >
struct  is_integral< unsigned int >
struct  is_integral< long int >
struct  is_integral< unsigned long int >
struct  is_integral< long long int >
struct  is_integral< unsigned long long int >
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::*volatile >
struct  is_member_function_pointer< t_TYPE t_CLASS::*const 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::*volatile >
struct  is_member_object_pointer< t_TYPE t_CLASS::*const 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::*volatile >
struct  is_member_pointer< t_TARGET_TYPE t_HOST_TYPE::*const volatile >
struct  is_nothrow_move_constructible
struct  is_pointer
struct  is_pointer< t_TYPE * >
struct  is_pointer< t_TYPE *const >
struct  is_pointer< t_TYPE *volatile >
struct  is_pointer< t_TYPE *const 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< t_TYPE & >
struct  is_trivially_copyable< const t_TYPE >
struct  is_trivially_copyable< volatile t_TYPE >
struct  is_trivially_copyable< const volatile t_TYPE >
struct  is_trivially_copyable< t_TYPE[t_LEN]>
struct  is_trivially_copyable< const t_TYPE[t_LEN]>
struct  is_trivially_copyable< volatile t_TYPE[t_LEN]>
struct  is_trivially_copyable< const volatile t_TYPE[t_LEN]>
struct  is_trivially_copyable< t_TYPE[]>
struct  is_trivially_copyable< const t_TYPE[]>
struct  is_trivially_copyable< volatile t_TYPE[]>
struct  is_trivially_copyable< const volatile t_TYPE[]>
struct  is_trivially_copyable< BloombergLP::bsls::TimeInterval >
struct  is_trivially_copyable< BloombergLP::bslmf::Nil >
struct  is_trivially_default_constructible
struct  is_trivially_default_constructible< const t_TYPE >
struct  is_trivially_default_constructible< volatile t_TYPE >
struct  is_trivially_default_constructible< const volatile t_TYPE >
struct  is_trivially_default_constructible< t_TYPE[t_LEN]>
struct  is_trivially_default_constructible< const t_TYPE[t_LEN]>
struct  is_trivially_default_constructible< volatile t_TYPE[t_LEN]>
struct  is_trivially_default_constructible< const volatile t_TYPE[t_LEN]>
struct  is_trivially_default_constructible< t_TYPE[]>
struct  is_trivially_default_constructible< const t_TYPE[]>
struct  is_trivially_default_constructible< volatile t_TYPE[]>
struct  is_trivially_default_constructible< const volatile t_TYPE[]>
struct  is_void
struct  is_void< void >
struct  is_void< const void >
struct  is_void< volatile void >
struct  is_void< const volatile void >
struct  is_volatile
struct  is_volatile< volatile t_TYPE >
struct  remove_const
struct  remove_const< t_TYPE const >
struct  remove_cv
struct  remove_cvref
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  type_identity
struct  uses_allocator
struct  Bitset_ImpUtil
class  Bitset_ImpBase< BITSETSIZE, 1 >
class  Bitset_ImpBase< BITSETSIZE, 2 >
class  bitset
class  boyer_moore_horspool_searcher
class  default_searcher
struct  Deque_BlockLengthCalcUtil
struct  Deque_Util
class  Deque_Base
class  deque
class  Deque_BlockCreator
class  Deque_BlockProctor
class  Deque_ClearGuard
class  Deque_Guard
struct  equal_to
 C++11-compliant binary functor applying operator== More...
struct  equal_to< void >
 C++11-compliant binary functor applying operator== More...
struct  hash< error_code >
struct  hash< error_condition >
class  function
struct  hash
struct  hash< const BSLSTL_KEY >
struct  hash< bool >
struct  hash< char >
struct  hash< signed char >
struct  hash< unsigned char >
struct  hash< wchar_t >
struct  hash< short >
struct  hash< unsigned short >
struct  hash< int >
struct  hash< unsigned int >
struct  hash< long >
struct  hash< unsigned long >
struct  hash< long long >
struct  hash< unsigned long long >
class  basic_istringstream
class  List_Node
class  List_Iterator
struct  List_DefaultLessThan
class  List_AllocAndSizeWrapper
class  List_NodeProctor
class  list
class  map
class  multimap
class  multiset
class  optional
class  optional< TYPE, false >
class  basic_ostringstream
struct  owner_less< shared_ptr< ELEMENT_TYPE > >
struct  owner_less< weak_ptr< ELEMENT_TYPE > >
struct  owner_less< void >
struct  Pair_BslmaIdiom
struct  Pair_ImpUtil
struct  Pair_First
struct  Pair_First< TYPE & >
struct  Pair_Second
struct  Pair_Second< TYPE & >
class  pair
class  priority_queue
class  queue
class  set
class  shared_ptr
class  weak_ptr
class  enable_shared_from_this
struct  Span_Utility
class  span
class  span< TYPE, dynamic_extent >
class  stack
struct  String_IsConvertibleToStringView
struct  String_IsConvertibleToStringView< CHAR_TYPE, CHAR_TRAITS, const CHAR_TYPE(&)[]>
struct  String_IsConvertibleToCString
struct  String_IsConvertibleToCString< CHAR_TYPE, const CHAR_TYPE(&)[]>
class  String_Imp
class  String_ClearProctor
class  basic_string
struct  hash< basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > >
class  basic_stringbuf
class  StringBufContainer
class  basic_stringstream
class  type_index
class  unordered_map
class  unordered_multimap
class  unordered_multiset
class  unordered_set
struct  Vector_Util
struct  Vector_DeduceIteratorCategory
struct  Vector_DeduceIteratorCategory< BSLSTL_ITERATOR, true >
struct  vector_ForwardIteratorForPtrs
struct  vector_ForwardIteratorForPtrs< TARGET, ITERATOR, false >
class  vectorBase
class  vector
class  vector< VALUE_TYPE *, ALLOCATOR >

Typedefs

typedef integral_constant
< bool, false > 		false_type
typedef integral_constant
< bool, true > 		true_type
typedef
BloombergLP::bsls::Nullptr_Impl::Type 		nullptr_t
typedef
::BloombergLP::bslstl::BadWeakPtr 		bad_weak_ptr
typedef std::errc ErrcEnum
typedef basic_stringbuf< char,
char_traits< char >, allocator
< char > > 		stringbuf
typedef basic_istringstream
< char, char_traits< char >
, allocator< char > > 		istringstream
typedef basic_ostringstream
< char, char_traits< char >
, allocator< char > > 		ostringstream
typedef basic_stringstream
< char, char_traits< char >
, allocator< char > > 		stringstream
typedef basic_stringbuf
< wchar_t, char_traits
< wchar_t >, allocator
< wchar_t > > 		wstringbuf
typedef basic_istringstream
< wchar_t, char_traits
< wchar_t >, allocator
< wchar_t > > 		wistringstream
typedef basic_ostringstream
< wchar_t, char_traits
< wchar_t >, allocator
< wchar_t > > 		wostringstream
typedef basic_stringstream
< wchar_t, char_traits
< wchar_t >, allocator
< wchar_t > > 		wstringstream
typedef 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

Enumerations

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

Functions

void PrintTo (const string &value, ostream *stream)
void PrintTo (const BloombergLP::bslstl::StringRef &value, ostream *stream)
template<class TYPE >
void PrintTo (const optional< TYPE > &value, ostream *stream)
template<class T1 , class T2 >
bool operator== (const allocator< T1 > &lhs, const allocator< T2 > &rhs)
template<class T1 , class T2 >
bool operator!= (const allocator< T1 > &lhs, const allocator< T2 > &rhs)
template<class TYPE >
bool operator== (const allocator< TYPE > &lhs, const BloombergLP::bslma::Allocator *rhs)
template<class TYPE >
bool operator!= (const allocator< TYPE > &lhs, const BloombergLP::bslma::Allocator *rhs)
template<class TYPE >
bool operator== (const BloombergLP::bslma::Allocator *lhs, const allocator< TYPE > &rhs)
template<class TYPE >
bool operator!= (const BloombergLP::bslma::Allocator *lhs, const allocator< TYPE > &rhs)
template<class FORWARD_ITERATOR , class SEARCHER >
BSLS_KEYWORD_CONSTEXPR_CPP14
FORWARD_ITERATOR 		search (FORWARD_ITERATOR first, FORWARD_ITERATOR last, const SEARCHER &searcher)
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)))
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
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 >
reverse_iterator< const T * > rbegin (std::initializer_list< T > initializerList)
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 >
reverse_iterator< const T * > rend (std::initializer_list< T > initializerList)
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 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)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool operator== (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool operator!= (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool operator< (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool operator> (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool operator<= (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
bool operator>= (const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &lhs, const multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class COMPARATOR , class ALLOCATOR >
void swap (multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &a, multimap< KEY, VALUE, COMPARATOR, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool operator== (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool operator!= (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool operator< (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool operator> (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool operator<= (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR >
bool operator>= (const multiset< KEY, COMPARATOR, ALLOCATOR > &lhs, const multiset< KEY, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY , class COMPARATOR , class ALLOCATOR , class PREDICATE >
multiset< KEY, COMPARATOR,
ALLOCATOR >::size_type 		erase_if (multiset< KEY, COMPARATOR, ALLOCATOR > &ms, PREDICATE predicate)
template<class KEY , class COMPARATOR , class ALLOCATOR >
void swap (multiset< KEY, COMPARATOR, ALLOCATOR > &a, multiset< KEY, COMPARATOR, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class TYPE >
bsl::enable_if
< BloombergLP::bslma::UsesBslmaAllocator
< TYPE >::value, void >::type 		swap (bsl::optional< TYPE > &lhs, bsl::optional< TYPE > &rhs)
template<class HASHALG , class TYPE >
void hashAppend (HASHALG &hashAlg, const optional< TYPE > &input)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const bsl::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const bsl::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const bsl::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const bsl::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const bsl::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const bsl::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator== (const bsl::optional< TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator== (const bsl::nullopt_t &, const bsl::optional< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator!= (const bsl::optional< TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator!= (const bsl::nullopt_t &, const bsl::optional< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator< (const bsl::optional< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator< (const bsl::nullopt_t &, const bsl::optional< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator> (const bsl::optional< TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator> (const bsl::nullopt_t &, const bsl::optional< TYPE > &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator<= (const bsl::optional< TYPE > &value, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator<= (const bsl::nullopt_t &, const bsl::optional< TYPE > &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator>= (const bsl::optional< TYPE > &, const bsl::nullopt_t &) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool operator>= (const bsl::nullopt_t &, const bsl::optional< TYPE > &value) BSLS_KEYWORD_NOEXCEPT
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const bsl::optional< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const LHS_TYPE &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const bsl::optional< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const LHS_TYPE &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const bsl::optional< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const LHS_TYPE &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const bsl::optional< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const LHS_TYPE &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const bsl::optional< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const LHS_TYPE &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const bsl::optional< LHS_TYPE > &lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const LHS_TYPE &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class TYPE >
bsl::enable_if
<!BloombergLP::bslma::UsesBslmaAllocator
< TYPE >::value, void >::type 		swap (bsl::optional< TYPE > &lhs, std::optional< TYPE > &rhs)
template<class TYPE >
bsl::enable_if
<!BloombergLP::bslma::UsesBslmaAllocator
< TYPE >::value, void >::type 		swap (std::optional< TYPE > &lhs, bsl::optional< TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const std::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator== (const bsl::optional< LHS_TYPE > &lhs, const std::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const bsl::optional< LHS_TYPE > &lhs, const std::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator!= (const std::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const bsl::optional< LHS_TYPE > &lhs, const std::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator< (const std::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const bsl::optional< LHS_TYPE > &lhs, const std::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator> (const std::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const bsl::optional< LHS_TYPE > &lhs, const std::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator<= (const std::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const bsl::optional< LHS_TYPE > &lhs, const std::optional< RHS_TYPE > &rhs)
template<class LHS_TYPE , class RHS_TYPE >
bool operator>= (const std::optional< LHS_TYPE > &lhs, const bsl::optional< RHS_TYPE > &rhs)
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR
bsl::optional< typename
bsl::decay< TYPE >::type > 		make_optional (bsl::allocator_arg_t, typename bsl::optional< typename bsl::decay< TYPE >::type >::allocator_type const &, BSLS_COMPILERFEATURES_FORWARD_REF(TYPE) rhs)
template<class TYPE , class... ARGS>
BSLS_KEYWORD_CONSTEXPR
bsl::optional< TYPE > 		make_optional (bsl::allocator_arg_t, typename bsl::optional< TYPE >::allocator_type const &alloc, BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)...args)
template<class TYPE , class INIT_LIST_TYPE , class... ARGS>
BSLS_KEYWORD_CONSTEXPR
bsl::optional< TYPE > 		make_optional (bsl::allocator_arg_t, typename bsl::optional< TYPE >::allocator_type const &alloc, std::initializer_list< INIT_LIST_TYPE > il, BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)...args)
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR
bsl::optional< typename
bsl::decay< TYPE >::type > 		make_optional (BSLS_COMPILERFEATURES_FORWARD_REF(TYPE) rhs)
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR
bsl::optional< TYPE > 		make_optional ()
template<class TYPE , class ARG , class... ARGS>
BSLS_KEYWORD_CONSTEXPR
bsl::enable_if< !bsl::is_same
< typename bsl::remove_cvref
< ARG >::type,
bsl::allocator_arg_t >::value,
optional< TYPE > >::type 		make_optional (BSLS_COMPILERFEATURES_FORWARD_REF(ARG), BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)...)
template<class TYPE , class INIT_LIST_TYPE , class... ARGS>
BSLS_KEYWORD_CONSTEXPR
bsl::optional< TYPE > 		make_optional (std::initializer_list< INIT_LIST_TYPE > il, BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)...args)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool operator== (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool operator!= (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool operator< (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool operator> (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool operator<= (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
BSLS_KEYWORD_CONSTEXPR bool operator>= (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
template<class T1 , class T2 >
void swap (pair< T1, T2 > &a, pair< T1, T2 > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class HASHALG , class T1 , class T2 >
void hashAppend (HASHALG &hashAlg, const pair< T1, T2 > &input)
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,
shared_ptr< ELEMENT_TYPE >
>::type 		allocate_shared (ALLOC basicAllocator, ARGS &&...args)
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 ELEMENT_TYPE , class... ARGS>
enable_if<!is_array
< ELEMENT_TYPE >::value,
shared_ptr< ELEMENT_TYPE >
>::type 		make_shared (ARGS &&...args)
template<class ELEMENT_TYPE >
void swap (weak_ptr< ELEMENT_TYPE > &a, weak_ptr< ELEMENT_TYPE > &b) BSLS_KEYWORD_NOEXCEPT
template<class TYPE , size_t EXTENT>
BSLS_KEYWORD_CONSTEXPR_CPP14
span< const std::byte, EXTENT
*sizeof(TYPE)> 		as_bytes (span< TYPE, EXTENT > s) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR_CPP14
span< const std::byte,
dynamic_extent > 		as_bytes (span< TYPE, dynamic_extent > s) BSLS_KEYWORD_NOEXCEPT
template<class TYPE , size_t EXTENT>
BSLS_KEYWORD_CONSTEXPR_CPP14
span< std::byte, EXTENT
*sizeof(TYPE)> 		as_writable_bytes (span< TYPE, EXTENT > s) BSLS_KEYWORD_NOEXCEPT
template<class TYPE >
BSLS_KEYWORD_CONSTEXPR_CPP14
span< std::byte,
dynamic_extent > 		as_writable_bytes (span< TYPE, dynamic_extent > s) BSLS_KEYWORD_NOEXCEPT
template<class TYPE , size_t EXTENT>
BSLS_KEYWORD_CONSTEXPR_CPP14 void swap (span< TYPE, EXTENT > &a, span< TYPE, EXTENT > &b) BSLS_KEYWORD_NOEXCEPT
template<class VALUE , class CONTAINER >
bool operator== (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool operator!= (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool operator< (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool operator> (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool operator<= (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
bool operator>= (const stack< VALUE, CONTAINER > &lhs, const stack< VALUE, CONTAINER > &rhs)
template<class VALUE , class CONTAINER >
void swap (stack< VALUE, CONTAINER > &lhs, stack< VALUE, CONTAINER > &rhs) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool operator== (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool operator== (const 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 ALLOC >
bool operator>= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool operator>= (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
bool operator>= (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs) BSLS_KEYWORD_NOEXCEPT
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool operator>= (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC >
bool operator>= (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE,
CHAR_TRAITS, ALLOCATOR > 		operator+ (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
basic_string< CHAR_TYPE,
CHAR_TRAITS, ALLOC2 > 		operator+ (const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOC1 , class ALLOC2 >
basic_string< CHAR_TYPE,
CHAR_TRAITS, ALLOC1 > 		operator+ (const bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC1 > &lhs, const std::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOC2 > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE,
CHAR_TRAITS, ALLOCATOR > 		operator+ (const CHAR_TYPE *lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE,
CHAR_TRAITS, ALLOCATOR > 		operator+ (CHAR_TYPE lhs, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE,
CHAR_TRAITS, ALLOCATOR > 		operator+ (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
basic_string< CHAR_TYPE,
CHAR_TRAITS, ALLOCATOR > 		operator+ (const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &lhs, CHAR_TYPE rhs)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_ostream< CHAR_TYPE,
CHAR_TRAITS > & 		operator<< (std::basic_ostream< CHAR_TYPE, CHAR_TRAITS > &os, const basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_istream< CHAR_TYPE,
CHAR_TRAITS > & 		operator>> (std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &is, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
void swap (basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &a, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_istream< CHAR_TYPE,
CHAR_TRAITS > & 		getline (std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &is, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str, CHAR_TYPE delim)
template<class CHAR_TYPE , class CHAR_TRAITS , class ALLOCATOR >
std::basic_istream< CHAR_TYPE,
CHAR_TRAITS > & 		getline (std::basic_istream< CHAR_TYPE, CHAR_TRAITS > &is, basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > &str)
int stoi (const string &str, std::size_t *pos=0, int base=10)
long stol (const string &str, std::size_t *pos=0, int base=10)
unsigned long stoul (const string &str, std::size_t *pos=0, int base=10)
long long stoll (const string &str, std::size_t *pos=0, int base=10)
unsigned long long stoull (const string &str, std::size_t *pos=0, int base=10)
float stof (const string &str, std::size_t *pos=0)
double stod (const string &str, std::size_t *pos=0)
long double stold (const string &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 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)
template<class HASHALG >
void hashAppend (HASHALG &hashAlg, const type_index &object)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
bool operator== (const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
bool operator!= (const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR , class PREDICATE >
unordered_map< KEY, VALUE,
HASH, EQUAL, ALLOCATOR >
::size_type 		erase_if (unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &m, PREDICATE predicate)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
void swap (unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &a, unordered_map< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
bool operator== (const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
bool operator!= (const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL , class ALLOCATOR >
void swap (unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &a, unordered_multimap< KEY, VALUE, HASH, EQUAL, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
bool operator== (const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
bool operator!= (const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR , class PREDICATE >
unordered_multiset< KEY, HASH,
EQUAL, ALLOCATOR >::size_type 		erase_if (unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &ms, PREDICATE predicate)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
void swap (unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &a, unordered_multiset< KEY, HASH, EQUAL, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
bool operator== (const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
bool operator!= (const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &lhs, const unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &rhs)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR , class PREDICATE >
unordered_set< KEY, HASH,
EQUAL, ALLOCATOR >::size_type 		erase_if (unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &s, PREDICATE predicate)
template<class KEY , class HASH , class EQUAL , class ALLOCATOR >
void swap (unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &a, unordered_set< KEY, HASH, EQUAL, ALLOCATOR > &b) BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(BSLS_KEYWORD_NOEXCEPT_OPERATOR(a.swap(b)))
template<class 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)))

Variables

static const allocator_arg_t allocator_arg = { }

Typedef Documentation

typedef integral_constant<bool, false> bsl::false_type
typedef integral_constant<bool, true> bsl::true_type
typedef BloombergLP::bsls::Nullptr_Impl::Type bsl::nullptr_t
typedef ::BloombergLP::bslstl::BadWeakPtr bsl::bad_weak_ptr
typedef std::errc bsl::ErrcEnum

Portable typedef for errc

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

Enumeration Type Documentation

anonymous enum
Enumerator:
dynamic_extent 

Function Documentation

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

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

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

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

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

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

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

template<class T >
T::iterator bsl::begin ( T &  container  ) 

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

Referenced by bsl::list< KEY >::assign(), and bsl::basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >::basic_string().

template<class T >
T::const_iterator bsl::begin ( const T &  container  ) 

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

template<class T , size_t N>
T* bsl::begin ( T(&)  array[N]  ) 

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

template<class T , size_t N>
const T* bsl::begin ( const T(&)  array[N]  ) 

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

template<class T >
T::iterator bsl::end ( T &  container  ) 

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

Referenced by bsl::list< KEY >::assign(), and bsl::basic_stringbuf< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR >::seekoff().

template<class T >
T::const_iterator bsl::end ( const T &  container  ) 

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

template<class T , size_t N>
T* bsl::end ( T(&)  array[N]  ) 

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

template<class T , size_t N>
const T* bsl::end ( const T(&)  array[N]  ) 

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

template<class T >
T::const_iterator bsl::cbegin ( const T &  container  ) 

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

template<class T , size_t N>
const T* bsl::cbegin ( const T(&)  array[N]  ) 

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

template<class T >
T::reverse_iterator bsl::rbegin ( T &  container  ) 

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

template<class T >
T::const_reverse_iterator bsl::rbegin ( const T &  container  ) 

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

template<class T , size_t N>
reverse_iterator<T *> bsl::rbegin ( T(&)  array[N]  ) 

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

template<class T >
reverse_iterator<const T *> bsl::rbegin ( std::initializer_list< T >  initializerList  ) 

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

template<class T >
T::const_reverse_iterator bsl::crbegin ( const T &  container  ) 

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

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

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

template<class T >
T::const_iterator bsl::cend ( const T &  container  ) 

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

template<class T , size_t N>
const T* bsl::cend ( const T(&)  array[N]  ) 

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

template<class T >
T::reverse_iterator bsl::rend ( T &  container  ) 

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

template<class T >
T::const_reverse_iterator bsl::rend ( const T &  container  ) 

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

template<class T , size_t N>
reverse_iterator<T *> bsl::rend ( T(&)  array[N]  ) 

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

template<class T >
reverse_iterator<const T *> bsl::rend ( std::initializer_list< T >  initializerList  ) 

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

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.

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

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

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

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

template<class HASHALG , class TYPE >
void bsl::hashAppend ( HASHALG &  hashAlg,
const optional< TYPE > &  input 
)

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

Referenced by hashAppend(), and bsl::hash< basic_string< CHAR_TYPE, CHAR_TRAITS, ALLOCATOR > >::operator()().

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator== ( const bsl::optional< LHS_TYPE > &  lhs,
const bsl::optional< 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. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

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

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. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator< ( const bsl::optional< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

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(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator> ( const bsl::optional< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  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(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

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

Return true if the specified lhs optional object is ordered before the specified rhs optional object or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

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

Return true if the specified lhs optional object is ordered after the specified rhs optional object or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

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

Return true if specified value is disengaged, and false otherwise.

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

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

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bsl::operator< ( const bsl::optional< TYPE > &  ,
const bsl::nullopt_t &   
)

Return false. Note that bsl::nullopt_t never orders after a bsl::optional.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bsl::operator< ( const bsl::nullopt_t &  ,
const bsl::optional< TYPE > &  value 
)

Return true if specified value is engaged, and false otherwise. Note that bsl::nullopt_t is ordered before any bsl::optional that is engaged.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bsl::operator> ( const bsl::optional< TYPE > &  value,
const bsl::nullopt_t &   
)

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

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bsl::operator> ( const bsl::nullopt_t &  ,
const bsl::optional< TYPE > &   
)

Return false. Note that bsl::nullopt_t never orders after a bsl::optional.

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

Return true if specified value is disengaged, and false otherwise.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bsl::operator<= ( const bsl::nullopt_t &  ,
const bsl::optional< TYPE > &   
)

Return true.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bool bsl::operator>= ( const bsl::optional< TYPE > &  ,
const bsl::nullopt_t &   
)

Return true.

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

Return true if specified value is disengaged, and false otherwise.

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

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 null, or its underlying value does not compare equal to the other value. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

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

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 non-null and its underlying value compares equal to the other value. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator< ( const bsl::optional< LHS_TYPE > &  lhs,
const RHS_TYPE &  rhs 
)

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.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator< ( const LHS_TYPE &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

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

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator> ( const bsl::optional< LHS_TYPE > &  lhs,
const RHS_TYPE &  rhs 
)

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.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator> ( const LHS_TYPE &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

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

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

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

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

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

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

Return true if the specified lhs optional object is ordered after the specified rhs or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.)

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

Return true if the specified lhs is ordered after the specified rhs optional object or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.)

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

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

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator== ( const std::optional< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator== ( const bsl::optional< LHS_TYPE > &  lhs,
const std::optional< 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. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator!= ( const bsl::optional< LHS_TYPE > &  lhs,
const std::optional< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator!= ( const std::optional< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

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. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator< ( const bsl::optional< LHS_TYPE > &  lhs,
const std::optional< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator< ( const std::optional< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

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(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator> ( const bsl::optional< LHS_TYPE > &  lhs,
const std::optional< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator> ( const std::optional< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  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(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator<= ( const bsl::optional< LHS_TYPE > &  lhs,
const std::optional< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator<= ( const std::optional< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

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==.) Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator>= ( const bsl::optional< LHS_TYPE > &  lhs,
const std::optional< RHS_TYPE > &  rhs 
)
template<class LHS_TYPE , class RHS_TYPE >
bool bsl::operator>= ( const std::optional< LHS_TYPE > &  lhs,
const bsl::optional< RHS_TYPE > &  rhs 
)

Return true if the specified lhs optional object is ordered after the specified rhs optional object or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bsl::optional<typename bsl::decay<TYPE>::type> bsl::make_optional ( bsl::allocator_arg_t  ,
typename bsl::optional< typename bsl::decay< TYPE >::type >::allocator_type const &  ,
BSLS_COMPILERFEATURES_FORWARD_REF(TYPE)  rhs 
)

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

template<class TYPE , class... ARGS>
BSLS_KEYWORD_CONSTEXPR bsl::optional<TYPE> bsl::make_optional ( bsl::allocator_arg_t  ,
typename bsl::optional< TYPE >::allocator_type const &  alloc,
BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)...  args 
)

Return an optional object containing a TYPE object created by invoking a bsl::optional allocator-extended in_place_t constructor with the specified alloc as the allocator argument, and specified args as constructor arguments. Note that this function will fail to compile if TYPE doesn't use allocators. MSVC2013 has a bug that causes deduction issues in free template functions that have an std::initializer_list argument where the std::initializer_list element type is deduced.

template<class TYPE , class INIT_LIST_TYPE , class... ARGS>
BSLS_KEYWORD_CONSTEXPR bsl::optional<TYPE> bsl::make_optional ( bsl::allocator_arg_t  ,
typename bsl::optional< TYPE >::allocator_type const &  alloc,
std::initializer_list< INIT_LIST_TYPE >  il,
BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)...  args 
)

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

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bsl::optional<typename bsl::decay<TYPE>::type> bsl::make_optional ( BSLS_COMPILERFEATURES_FORWARD_REF(TYPE)  rhs  ) 

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

template<class TYPE >
BSLS_KEYWORD_CONSTEXPR bsl::optional<TYPE> bsl::make_optional (  ) 

Return an optional object containing a default constructed TYPE object. If TYPE uses an allocator, the default allocator will be used for the optional object.

template<class TYPE , class ARG , class... ARGS>
BSLS_KEYWORD_CONSTEXPR bsl::enable_if< !bsl::is_same< typename bsl::remove_cvref< ARG >::type, bsl::allocator_arg_t>::value, optional<TYPE> >::type bsl::make_optional ( BSLS_COMPILERFEATURES_FORWARD_REF(ARG)  ,
BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)  ... 
)

Return an optional object containing a TYPE object created by invoking a bsl::optional in_place_t constructor with the specified arguments as the constructor arguments. If TYPE uses an allocator, the default allocator will be used for the optional object. MSVC2013 has a bug that causes deduction issues in free template functions that have an std::initializer_list argument where the std::initializer_list element type is deduced.

template<class TYPE , class INIT_LIST_TYPE , class... ARGS>
BSLS_KEYWORD_CONSTEXPR bsl::optional<TYPE> bsl::make_optional ( std::initializer_list< INIT_LIST_TYPE >  il,
BSLS_COMPILERFEATURES_FORWARD_REF(ARGS)...  args 
)

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

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

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

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

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

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.

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.

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 of LHS_TYPE * and RHS_TYPE *, and false otherwise.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

template<class TO_TYPE , class FROM_TYPE >
shared_ptr<TO_TYPE> bsl::const_pointer_cast ( const shared_ptr< FROM_TYPE > &  source  ) 

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

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.

template<class TO_TYPE , class FROM_TYPE >
shared_ptr<TO_TYPE> bsl::static_pointer_cast ( const shared_ptr< FROM_TYPE > &  source  ) 

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

template<class TO_TYPE , class FROM_TYPE >
shared_ptr<TO_TYPE> bsl::reinterpret_pointer_cast ( const shared_ptr< FROM_TYPE > &  source  ) 

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

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 
)

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

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.

template<class ELEMENT_TYPE , class... ARGS>
enable_if<!is_array<ELEMENT_TYPE>::value, 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.

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.

Generated on Fri Mar 31 2023 13:28:17 for BDE Release 3.115.0.0 Production Release by  doxygen 1.7.1