bslstl Namespace Reference

Classes
struct	AlgorithmUtil
class	BadWeakPtr
class	BidirectionalIterator
class	BidirectionalNodePool
class	BoyerMooreHorspoolSearcher
class	BoyerMooreHorspoolSearcher_CharImp
class	BoyerMooreHorspoolSearcher_GeneralImp
struct	CallableVariable
class	DefaultSearcher
struct	DefaultSearcher_CanOptimize
struct	DefaultSearcher_ImpUtil
class	ForwardIterator
struct	Function_ArgTypes
struct	Function_ArgTypes< RET(ARG)>
struct	Function_ArgTypes< RET(ARG1, ARG2)>
struct	Function_InvokerUtil
struct	Function_InvokerUtil_Dispatch
struct	Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_FunctionPtr, RET(ARGS...), FUNC >
	Specialization of dispatcher for pointer-to-function objects. More...
struct	Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_InplaceFunctor, RET(ARGS...), FUNC >
struct	Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_MemDataPtr, RET(ARG0), MEMBER_TYPE CLASS_TYPE::* >
	Specialization of dispatcher for pointer to data member objects. More...
struct	Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_MemFunctionPtr, RET(ARG0, ARGS...), FUNC >
	Specialization of dispatcher for pointer to member function objects. More...
struct	Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_OutofplaceFunctor, RET(ARGS...), FUNC >
struct	Function_InvokerUtilNullCheck
struct	Function_InvokerUtilNullCheck< bsl::function< PROTO > >
struct	Function_InvokerUtilNullCheck< FUNC * >
	Specialization of dispatcher for pointer objects. More...
struct	Function_InvokerUtilNullCheck< MEMTYPE CLASS::* >
	Specialization of dispatcher for pointer-to-member objects. More...
struct	Function_IsInvocableWithPrototype
struct	Function_IsInvocableWithPrototype< RET(ARGS...), FUNC >
struct	Function_IsReferenceCompatible
struct	Function_IsReferenceCompatible< FROM_TYPE, const TO_TYPE >
class	Function_Rep
class	Function_SmallObjectOptimization
class	Function_Variadic
class	Function_Variadic< RET(ARGS...)>
class	HashTable
class	HashTable_ArrayProctor
struct	HashTable_BaseHasher
struct	HashTable_Comparator
class	HashTable_ComparatorWrapper
class	HashTable_ComparatorWrapper< const FUNCTOR >
class	HashTable_ComparatorWrapper< FUNCTOR & >
class	HashTable_HashWrapper
class	HashTable_HashWrapper< const FUNCTOR >
class	HashTable_HashWrapper< FUNCTOR & >
struct	HashTable_ImpDetails
class	HashTable_ImplParameters
class	HashTable_NodeProctor
struct	HashTable_Util
class	HashTableBucketIterator
class	HashTableIterator
struct	IteratorUtil
class	MapComparator
class	Optional_Base
class	Optional_Base< t_TYPE, false >
struct	Optional_ConstructFromForwardRef
struct	Optional_ConstructsFromType
struct	Optional_CopyConstructFromOtherOptional
struct	Optional_CopyConstructFromStdOptional
struct	Optional_Data
struct	Optional_Data< t_TYPE, true >
struct	Optional_DataImp
struct	Optional_IsTriviallyDestructible
struct	Optional_MoveConstructFromOtherOptional
struct	Optional_MoveConstructFromStdOptional
struct	Optional_NulloptConstructToken
struct	Optional_OptNoSuchType
struct	Optional_PropagatesAllocator
class	RandomAccessIterator
class	SetComparator
struct	SharedPtr_DefaultDeleter
struct	SharedPtr_ImpUtil
struct	SharedPtr_RepFromExistingSharedPtr
class	SharedPtr_RepProctor
class	SharedPtrAllocateInplaceRep
class	SharedPtrAllocateOutofplaceRep
class	SharedPtrAllocateOutofplaceRep_InitProctor
class	SharedPtrArrayAllocateInplaceRep
struct	SharedPtrNilDeleter
struct	SharedPtrUtil
	This struct provides a namespace for operations on shared pointers. More...
class	SimplePool
struct	SimplePool_Type
struct	StdExceptUtil
class	StopCallback_CallbackStorage
class	StopCallback_CallbackStorage< t_CALLBACK, true >
	This partial specialization stores a reference to a callback. More...
class	StopCallback_NoAlloc
class	StopCallback_Node
class	StopState
class	StopState_ListNode
class	StopStateCallbackNode
struct	StopToken_RefCountedState
class	StringRefData
class	StringRefImp
struct	StringRefImp_CompareUtil
struct	StringView_Identity
class	SyncBufBase
struct	SyncBufBaseUtil
	Internal utils. More...
struct	to_chars_result
class	TreeIterator
class	TreeNode
class	TreeNodePool
struct	UnorderedMapKeyConfiguration
struct	UnorderedSetKeyConfiguration
struct	Variant_AllocatorBase
struct	Variant_AllocatorBase< true >
	This specialization is used when the variant is allocator-aware. More...
struct	Variant_AssignsFromType
struct	Variant_Base
struct	Variant_ConstructFromStdTag
struct	Variant_ConstructsFromType
struct	Variant_ConvertIndex
struct	Variant_ConvertIndex< t_TYPE, bsl::variant< t_HEAD, t_TAIL... > >
struct	Variant_ConvertToIndexImpl
struct	Variant_ConvertToIndexImpl< t_INDEX, t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE >
struct	Variant_ConvertToIndexImpl< t_INDEX, t_TYPE, t_HEAD, t_TAIL... >
class	Variant_CopyAssignVisitor
class	Variant_CopyConstructVisitor
struct	Variant_CorrespondingStdVariant
struct	Variant_CountCVType
struct	Variant_CountCVType< t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE >
	Specialization for purposes of the sim_cpp11_features.pl script. More...
struct	Variant_CountType
struct	Variant_CountType< t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE >
	Specialization for purposes of the sim_cpp11_features.pl script. More...
struct	Variant_CVQualAlt
class	Variant_DataImp
struct	Variant_DestructorVisitor
struct	Variant_Function
struct	Variant_Function< void, t_VISITOR, t_VARIANT, t_ALT_TYPE >
struct	Variant_FunctionId
class	Variant_HashVisitor
struct	Variant_HasUniqueCVType
struct	Variant_HasUniqueCVType< t_TYPE, bsl::variant< t_HEAD, t_TAIL... > >
struct	Variant_HasUniqueType
struct	Variant_HasUniqueType< t_TYPE, bsl::variant< t_HEAD, t_TAIL... > >
struct	Variant_ImpUtil
struct	Variant_isAlternativeAssignableFrom
struct	Variant_isAlternativeAssignableFrom< t_VARIANT, t_TYPE, bsl::variant_npos >
struct	Variant_IsAlternativeConstructibleFrom
struct	Variant_IsAlternativeConstructibleFrom< t_VARIANT, t_TYPE, bsl::variant_npos >
struct	Variant_IsAssignable
struct	Variant_IsBitwiseMoveableAll
struct	Variant_IsBitwiseMoveableAll< BSLSTL_VARIANT_NOT_A_TYPE >
struct	Variant_IsConstructible
struct	Variant_IsSameReturnType
struct	Variant_IsSameReturnType< t_RET, t_VISITOR, t_VARIANT, 0 >
struct	Variant_IsTag
struct	Variant_IsTag< bsl::allocator_arg_t >
struct	Variant_IsTag< bsl::in_place_index_t< t_INDEX > >
struct	Variant_IsTag< bsl::in_place_type_t< t_TYPE > >
class	Variant_MoveAssignVisitor
class	Variant_MoveConstructVisitor
struct	Variant_MoveFunction
struct	Variant_MoveFunction< void, t_VISITOR, t_VARIANT, t_ALT_TYPE >
struct	Variant_NoSuchType
class	Variant_SwapVisitor
struct	Variant_TypeToIndex
struct	Variant_TypeToIndex< t_TYPE, bsl::variant< t_HEAD, t_TAIL... > >
struct	Variant_TypeToIndexImpl
struct	Variant_TypeToIndexImpl< t_INDEX, t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE >
union	Variant_Union
union	Variant_Union< BloombergLP::bsls::CompilerFeaturesNilT >
union	Variant_Union< t_HEAD, t_TAIL0, t_TAIL... >
union	Variant_Union< void, void >
struct	Variant_UsesBslmaAllocatorAny
struct	Variant_UsesBslmaAllocatorAny< BSLSTL_VARIANT_NOT_A_TYPE >
struct	Variant_VTable
struct	Variant_VTable< t_RET, t_VISITOR, bsl::variant< t_HEAD, t_TAIL... > >
struct	Variant_VTable< t_RET, t_VISITOR, const bsl::variant< t_HEAD, t_TAIL... > >

Typedefs
typedef StringRefImp< char >	StringRef
typedef StringRefImp< wchar_t >	StringRefWide

Functions
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator== (const BidirectionalIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const BidirectionalIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator!= (const BidirectionalIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const BidirectionalIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T , class ITER_IMP , class TAG_TYPE >
BidirectionalIterator< T, ITER_IMP, TAG_TYPE >	operator++ (BidirectionalIterator< T, ITER_IMP, TAG_TYPE > &iter, int)
template<class T , class ITER_IMP , class TAG_TYPE >
BidirectionalIterator< T, ITER_IMP, TAG_TYPE >	operator-- (BidirectionalIterator< T, ITER_IMP, TAG_TYPE > &iter, int)
template<class VALUE , class ALLOCATOR >
void	swap (BidirectionalNodePool< VALUE, ALLOCATOR > &a, BidirectionalNodePool< VALUE, ALLOCATOR > &b)
template<class INTEGRAL_TYPE >
to_chars_result	to_chars (char *first, char *last, INTEGRAL_TYPE value, int base=10)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator== (const ForwardIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const ForwardIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator!= (const ForwardIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const ForwardIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T , class ITER_IMP , class TAG_TYPE >
ForwardIterator< T, ITER_IMP, TAG_TYPE >	operator++ (ForwardIterator< T, ITER_IMP, TAG_TYPE > &iter, int)
template<class FUNCTOR >
void	swap (HashTable_HashWrapper< FUNCTOR > &a, HashTable_HashWrapper< FUNCTOR > &b)
template<class FUNCTOR >
void	swap (HashTable_ComparatorWrapper< FUNCTOR > &lhs, HashTable_ComparatorWrapper< FUNCTOR > &rhs)
template<class KEY_CONFIG , class HASHER , class COMPARATOR , class ALLOCATOR >
void	swap (HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &x, HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &y)
template<class KEY_CONFIG , class HASHER , class COMPARATOR , class ALLOCATOR >
bool	operator== (const HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &lhs, const HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &rhs)
template<class KEY_CONFIG , class HASHER , class COMPARATOR , class ALLOCATOR >
bool	operator!= (const HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &lhs, const HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator== (const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator== (const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator== (const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator== (const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator!= (const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator!= (const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator!= (const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator!= (const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE >	operator++ (HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &iterator, int)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator== (const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator== (const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator== (const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator== (const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator!= (const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator!= (const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator!= (const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool	operator!= (const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &lhs, const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &rhs)
template<class VALUE_TYPE , class DIFFERENCE_TYPE >
HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE >	operator++ (HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &iter, int)
template<class KEY , class VALUE , class COMPARATOR >
void	swap (MapComparator< KEY, VALUE, COMPARATOR > &a, MapComparator< KEY, VALUE, COMPARATOR > &b)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator== (const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator!= (const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T , class ITER_IMP , class TAG_TYPE >
RandomAccessIterator< T, ITER_IMP, TAG_TYPE >	operator++ (RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &iter, int)
template<class T , class ITER_IMP , class TAG_TYPE >
RandomAccessIterator< T, ITER_IMP, TAG_TYPE >	operator-- (RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &iter, int)
template<class T , class ITER_IMP , class TAG_TYPE >
RandomAccessIterator< T, ITER_IMP, TAG_TYPE >	operator+ (const RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &lhs, std::ptrdiff_t rhs)
template<class T , class ITER_IMP , class TAG_TYPE >
RandomAccessIterator< T, ITER_IMP, TAG_TYPE >	operator+ (std::ptrdiff_t lhs, const RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &rhs)
template<class T , class ITER_IMP , class TAG_TYPE >
RandomAccessIterator< T, ITER_IMP, TAG_TYPE >	operator- (const RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &lhs, std::ptrdiff_t rhs)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
std::ptrdiff_t	operator- (const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator< (const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator> (const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator<= (const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >
bool	operator>= (const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &lhs, const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &rhs)
template<class KEY , class COMPARATOR >
void	swap (SetComparator< KEY, COMPARATOR > &a, SetComparator< KEY, COMPARATOR > &b)
template<class CHAR_TYPE >
bsl::basic_string< CHAR_TYPE >	operator+ (const StringRefImp< CHAR_TYPE > &lhs, const StringRefImp< CHAR_TYPE > &rhs)
template<class CHAR_TYPE >
bsl::basic_string< CHAR_TYPE >	operator+ (const bsl::basic_string< CHAR_TYPE > &lhs, const StringRefImp< CHAR_TYPE > &rhs)
template<class CHAR_TYPE >
bsl::basic_string< CHAR_TYPE >	operator+ (const StringRefImp< CHAR_TYPE > &lhs, const bsl::basic_string< CHAR_TYPE > &rhs)
template<class CHAR_TYPE >
bsl::basic_string< CHAR_TYPE >	operator+ (const StringRefImp< CHAR_TYPE > &lhs, const std::basic_string< CHAR_TYPE > &rhs)
template<class CHAR_TYPE >
bsl::basic_string< CHAR_TYPE >	operator+ (const std::basic_string< CHAR_TYPE > &lhs, const StringRefImp< CHAR_TYPE > &rhs)
template<class CHAR_TYPE >
bsl::basic_string< CHAR_TYPE >	operator+ (const CHAR_TYPE *lhs, const StringRefImp< CHAR_TYPE > &rhs)
template<class CHAR_TYPE >
bsl::basic_string< CHAR_TYPE >	operator+ (const StringRefImp< CHAR_TYPE > &lhs, const CHAR_TYPE *rhs)
template<class CHAR_TYPE , class HASHALG >
void	hashAppend (HASHALG &hashAlg, const StringRefImp< CHAR_TYPE > &input)
	Pass the specified input to the specified hashAlg
template<class VALUE1 , class VALUE2 , class NODEPTR , class DIFF >
bool	operator== (const TreeIterator< VALUE1, NODEPTR, DIFF > &lhs, const TreeIterator< VALUE2, NODEPTR, DIFF > &rhs)
template<class VALUE1 , class VALUE2 , class NODEPTR , class DIFF >
bool	operator!= (const TreeIterator< VALUE1, NODEPTR, DIFF > &lhs, const TreeIterator< VALUE2, NODEPTR, DIFF > &rhs)
template<class VALUE , class NODE , class DIFFERENCE_TYPE >
TreeIterator< VALUE, NODE, DIFFERENCE_TYPE >	operator++ (TreeIterator< VALUE, NODE, DIFFERENCE_TYPE > &iter, int)
template<class VALUE , class NODE , class DIFFERENCE_TYPE >
TreeIterator< VALUE, NODE, DIFFERENCE_TYPE >	operator-- (TreeIterator< VALUE, NODE, DIFFERENCE_TYPE > &iter, int)
template<class t_VARIANT >
void	variant_swapImpl (bsl::true_type, t_VARIANT &lhs, t_VARIANT &rhs)
template<class t_VARIANT >
void	variant_swapImpl (bsl::false_type, t_VARIANT &lhs, t_VARIANT &rhs)

Typedef Documentation

StringRef

typedef StringRefImp<char> bslstl::StringRef

StringRefWide

typedef StringRefImp<wchar_t> bslstl::StringRefWide

Function Documentation

hashAppend()

template<class CHAR_TYPE , class HASHALG >

void bslstl::hashAppend	(	HASHALG &	hashAlg,
		const StringRefImp< CHAR_TYPE > &	input
	)

operator!=() [1/13]

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator!=	(	const BidirectionalIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const BidirectionalIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if the specified lhs iterator does not have the same value as the specified rhs iterator, and false otherwise. Two iterators do not have the same value if (1) they do not refer to the same element and (2) both do not have the past-the-end iterator value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.

operator!=() [2/13]

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator!=	(	const ForwardIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const ForwardIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if the specified lhs iterator does not have the same value as the specified rhs iterator, and false otherwise. Two iterators do not have the same value if (1) they do not refer to the same element and (2) both do not have the past-the-end iterator value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.

operator!=() [3/13]

template<class KEY_CONFIG , class HASHER , class COMPARATOR , class ALLOCATOR >

bool bslstl::operator!=	(	const HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &	lhs,
		const HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two HashTable objects do not have the same value if they do not have the same number of elements, or if, for any key found in lhs, the subset of elements having that key (according to the hash-table's comparator) in lhs either (1) does not have the same number of elements as the subset of elements having that key in rhs, or (2) there exists no permutation of the lhs subset where each element compares equal (using operator==) to the corresponding element in the rhs subset. The behavior is undefined unless both the hasher and comparator of lhs and rhs return the same value for every valid input. Note that this method requires that the ValueType of the parameterized KEY_CONFIG be "equality-comparable" (see {Requirements on KEY_CONFIG}).

operator!=() [4/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator!= ( const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator!=() [5/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator!= ( const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator!=() [6/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator!= ( const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator!=() [7/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator!= ( const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

Return true if the specified lhs and the specified rhs iterators do not have the same value and false otherwise. Two iterators do not have the same value if they refer to the different elements in the same hash table, or if either (but not both) of the iterators are positioned after the end of a hash table bucket.

operator!=() [8/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator!= ( const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator!=() [9/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator!= ( const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator!=() [10/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator!= ( const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator!=() [11/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator!= ( const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

Return true if the specified lhs and the specified rhs iterators do not have the same value and false otherwise. Two iterators do not have the same value if they refer to the different nodes in the same list, or if either (but not both) of the iterators are at the past-the-end position of the tree.

operator!=() [12/13]

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator!=	(	const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if the specified lhs iterator does not have the same value as the specified rhs iterator, and false otherwise. Two iterators do not have the same value if (1) they do not refer to the same element and (2) both do not have the past-the-end iterator value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.

operator!=() [13/13]

template<class VALUE1 , class VALUE2 , class NODEPTR , class DIFF >

bool bslstl::operator!= ( const TreeIterator< VALUE1, NODEPTR, DIFF > &  lhs, const TreeIterator< VALUE2, NODEPTR, DIFF > &  rhs  )

inline

Return true if the specified lhs and the specified rhs iterators do not have the same value and false otherwise. Two iterators do not have the same value if they differ in either the tree to which they refer or the position in that tree.

operator+() [1/9]

template<class CHAR_TYPE >

bsl::basic_string< CHAR_TYPE > bslstl::operator+	(	const bsl::basic_string< CHAR_TYPE > &	lhs,
		const StringRefImp< CHAR_TYPE > &	rhs
	)

operator+() [2/9]

template<class CHAR_TYPE >

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

operator+() [3/9]

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > bslstl::operator+	(	const RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &	lhs,
		std::ptrdiff_t	rhs
	)

Return an iterator to the element at the specified rhs positions past the specified lhs. The behavior is undefined unless lhs, after incrementing by rhs, is within the bounds of the underlying sequence.

operator+() [4/9]

template<class CHAR_TYPE >

bsl::basic_string< CHAR_TYPE > bslstl::operator+	(	const std::basic_string< CHAR_TYPE > &	lhs,
		const StringRefImp< CHAR_TYPE > &	rhs
	)

operator+() [5/9]

template<class CHAR_TYPE >

bsl::basic_string< CHAR_TYPE > bslstl::operator+	(	const StringRefImp< CHAR_TYPE > &	lhs,
		const bsl::basic_string< CHAR_TYPE > &	rhs
	)

operator+() [6/9]

template<class CHAR_TYPE >

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

operator+() [7/9]

template<class CHAR_TYPE >

bsl::basic_string< CHAR_TYPE > bslstl::operator+	(	const StringRefImp< CHAR_TYPE > &	lhs,
		const std::basic_string< CHAR_TYPE > &	rhs
	)

operator+() [8/9]

template<class CHAR_TYPE >

bsl::basic_string< CHAR_TYPE > bslstl::operator+	(	const StringRefImp< CHAR_TYPE > &	lhs,
		const StringRefImp< CHAR_TYPE > &	rhs
	)

Return a bsl::string having the value of the concatenation of the strings referred to by the specified lhs and rhs values.

operator+() [9/9]

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > bslstl::operator+	(	std::ptrdiff_t	lhs,
		const RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &	rhs
	)

Return an iterator to the element at the specified lhs positions past the specified rhs. The behavior is undefined unless rhs, after incrementing by lhs, is within the bounds of the underlying sequence.

operator++() [1/6]

template<class T , class ITER_IMP , class TAG_TYPE >

BidirectionalIterator< T, ITER_IMP, TAG_TYPE > bslstl::operator++	(	BidirectionalIterator< T, ITER_IMP, TAG_TYPE > &	iter,
		int
	)

Increment the specified iter to the next element. Return the previous value of iter. The behavior is undefined if, on entry, iter has the past-the-end value for an iterator of the underlying sequence.

operator++() [2/6]

template<class T , class ITER_IMP , class TAG_TYPE >

ForwardIterator< T, ITER_IMP, TAG_TYPE > bslstl::operator++	(	ForwardIterator< T, ITER_IMP, TAG_TYPE > &	iter,
		int
	)

Increment the specified iter to the next element. Return the previous value of iter. The behavior is undefined if, on entry, iter has the past-the-end value for an iterator of the underlying sequence.

operator++() [3/6]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > bslstl::operator++ ( HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  iterator, int    )

inline

Move the specified iter to the next element in the hash table bucket and return the value of iter prior to this call. The behavior is undefined unless iter refers to a valid (not yet erased) element in a bucket. Note that iter is invalidated when the underlying hash table is rehashed.

operator++() [4/6]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > bslstl::operator++ ( HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  iter, int    )

inline

Move the specified iter to the next node in the list and return value of iter prior to this call. The behavior is undefined unless iter refers to a valid (not yet erased) node a the list.

operator++() [5/6]

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > bslstl::operator++	(	RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &	iter,
		int
	)

Increment the specified iter to next element. Return the previous value of iter. The behavior is undefined if, on entry, iter has the past-the-end value for an iterator of the underlying sequence.

operator++() [6/6]

template<class VALUE , class NODE , class DIFFERENCE_TYPE >

TreeIterator< VALUE, NODE, DIFFERENCE_TYPE > bslstl::operator++ ( TreeIterator< VALUE, NODE, DIFFERENCE_TYPE > &  iter, int    )

inline

Move the specified iter to the next element in the tree and return the value of iter prior to this call. The behavior is undefined unless the iterator refers to an element in the tree.

operator-() [1/2]

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > bslstl::operator-	(	const RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &	lhs,
		std::ptrdiff_t	rhs
	)

Return an iterator to the element at the specified rhs positions before the specified lhs. The behavior is undefined unless lhs, after decrementing by rhs, is within the bounds of the underlying sequence. Note that this function is logically equivalent to:

iter + (-rhs)

operator-() [2/2]

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

std::ptrdiff_t bslstl::operator-	(	const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return the distance from the specified rhs iterator to the specified lhs iterator. The behavior is undefined unless lhs and rhs are iterators into the same underlying sequence. Note that the result might be negative.

operator--() [1/3]

template<class T , class ITER_IMP , class TAG_TYPE >

BidirectionalIterator< T, ITER_IMP, TAG_TYPE > bslstl::operator--	(	BidirectionalIterator< T, ITER_IMP, TAG_TYPE > &	iter,
		int
	)

Decrement the specified iter to the previous element. Return the previous value of iter. The behavior is undefined if, on entry, iter has the same value as an iterator to the start of the underlying sequence.

operator--() [2/3]

template<class T , class ITER_IMP , class TAG_TYPE >

RandomAccessIterator< T, ITER_IMP, TAG_TYPE > bslstl::operator--	(	RandomAccessIterator< T, ITER_IMP, TAG_TYPE > &	iter,
		int
	)

Decrement the specified iter to previous element. Return the previous value of iter. The behavior is undefined if, on entry, iter has the same value as an iterator to the start of the underlying sequence.

operator--() [3/3]

template<class VALUE , class NODE , class DIFFERENCE_TYPE >

TreeIterator< VALUE, NODE, DIFFERENCE_TYPE > bslstl::operator-- ( TreeIterator< VALUE, NODE, DIFFERENCE_TYPE > &  iter, int    )

inline

Move the specified iter to the previous element in the tree and return the value of iter prior to this call. The behavior is undefined unless the iterator refers to the past-the-end or the non-leftmost element in the tree.

operator<()

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator<	(	const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if (1) the specified lhs iterator refers to an element before the specified rhs iterator in the iteration sequence, or (2) rhs (and not lhs) has the past-the-end value for an iterator over this sequence, and false otherwise. The behavior is undefined unless lhs and rhs are iterators into the same underlying sequence.

operator<=()

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator<=	(	const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if (1) the specified lhs iterator has the same value as the specified rhs iterator, or (2) lhs refers to an element before rhs in the iteration sequence, or (3) rhs has the past-the-end value for an iterator over this sequence, and false otherwise. The behavior is undefined unless lhs and rhs are iterators into the same underlying sequence.

operator==() [1/13]

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator==	(	const BidirectionalIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const BidirectionalIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if the specified lhs iterator has the same value as the specified rhs iterator, and false otherwise. Two iterators have the same value if they refer to the same element, or both have the past-the- end value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.

operator==() [2/13]

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator==	(	const ForwardIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const ForwardIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if the specified lhs iterator has the same value as the specified rhs iterator, and false otherwise. Two iterators have the same value if they refer to the same element, or both have the past-the- end value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.

operator==() [3/13]

template<class KEY_CONFIG , class HASHER , class COMPARATOR , class ALLOCATOR >

bool bslstl::operator==	(	const HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &	lhs,
		const HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two HashTable objects have the same value if they have the same number of elements, and for every subset of elements in lhs having keys that compare equal (according to that hash table's comparator), a corresponding subset of elements exists in rhs, having the same number of elements, where, for some permutation of the lhs subset, every element in that subset compares equal (using operator==) to the corresponding element in the rhs subset. The behavior is undefined unless both the hasher and comparator of lhs and rhs return the same value for every valid input. Note that this method requires that the ValueType of the parameterized KEY_CONFIG be "equality-comparable" (see {Requirements on KEY_CONFIG}).

operator==() [4/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator== ( const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator==() [5/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator== ( const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator==() [6/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator== ( const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableBucketIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator==() [7/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator== ( const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

Return true if the specified lhs and the specified rhs iterators have the same value and false otherwise. Two iterators have the same value if they refer to the same element in the same hash table, or if both iterators are positioned after the end of a hash table bucket.

operator==() [8/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator== ( const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator==() [9/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator== ( const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator==() [10/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator== ( const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableIterator< const VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

operator==() [11/13]

template<class VALUE_TYPE , class DIFFERENCE_TYPE >

bool bslstl::operator== ( const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs, const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs  )

inline

Return true if the specified lhs and the specified rhs iterators have the same value and false otherwise. Two iterators have the same value if they refer to the same node in the same list, or if both iterators are at the past-the-end position of the tree.

operator==() [12/13]

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator==	(	const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if the specified lhs iterator has the same value as the specified rhs iterator, and false otherwise. Two iterators have the same value if they refer to the same element, or both have the past-the- end value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.

operator==() [13/13]

template<class VALUE1 , class VALUE2 , class NODEPTR , class DIFF >

bool bslstl::operator== ( const TreeIterator< VALUE1, NODEPTR, DIFF > &  lhs, const TreeIterator< VALUE2, NODEPTR, DIFF > &  rhs  )

inline

Return true if the specified lhs and the specified rhs iterators have the same value and false otherwise. Two iterators have the same value if they refer to the same position in the same tree, or if both iterators are at an invalid position in the tree (i.e., the end of the tree, or the default constructed value).

operator>()

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator>	(	const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if (1) the specified lhs iterator refers to an element after the specified rhs iterator in the iteration sequence, or (2) lhs (and not rhs) has the past-the-end value for an iterator over this sequence, and false otherwise. The behavior is undefined unless lhs and rhs are iterators into the same underlying sequence.

operator>=()

template<class T1 , class T2 , class ITER_IMP , class TAG_TYPE >

bool bslstl::operator>=	(	const RandomAccessIterator< T1, ITER_IMP, TAG_TYPE > &	lhs,
		const RandomAccessIterator< T2, ITER_IMP, TAG_TYPE > &	rhs
	)

Return true if (1) the specified lhs iterator has the same value as the specified rhs iterator, or (2) lhs has the past-the-end value for an iterator over this sequence, or (3) lhs refers to an element after rhs in the iteration sequence, and false otherwise. The behavior is undefined unless lhs and rhs are iterators into the same underlying sequence.

swap() [1/6]

template<class VALUE , class ALLOCATOR >

void bslstl::swap	(	BidirectionalNodePool< VALUE, ALLOCATOR > &	a,
		BidirectionalNodePool< VALUE, ALLOCATOR > &	b
	)

Efficiently exchange the nodes of the specified a object with those of the specified b object. This method provides the no-throw exception-safety guarantee. The behavior is undefined unless a.allocator() == b.allocator().

swap() [2/6]

template<class KEY_CONFIG , class HASHER , class COMPARATOR , class ALLOCATOR >

void bslstl::swap	(	HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &	x,
		HashTable< KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR > &	y
	)

Swap both the value, the hasher, the comparator, and the maxLoadFactor of the specified x object with the value, the hasher, the comparator, and the maxLoadFactor of the specified y object. Additionally, if bslstl::AllocatorTraits<ALLOCATOR>::propagate_on_container_swap is true, then exchange the allocator of x with that of y, and do not modify either allocator otherwise. This method guarantees O[1] complexity if x and y have the same allocator or if the allocators propagate on swap, otherwise this operation will typically pay the cost of two copy constructors, which may in turn throw. If the allocators are the same or propagate, then this method provides the no-throw exception-safety guarantee unless the swap function of the hasher or comparator throw. Otherwise this method offers only the basic exception safety guarantee.

swap() [3/6]

template<class FUNCTOR >

void bslstl::swap	(	HashTable_ComparatorWrapper< FUNCTOR > &	lhs,
		HashTable_ComparatorWrapper< FUNCTOR > &	rhs
	)

Swap the functor wrapped by the specified lhs object with the functor wrapped by the specified rhs object.

swap() [4/6]

template<class FUNCTOR >

void bslstl::swap	(	HashTable_HashWrapper< FUNCTOR > &	a,
		HashTable_HashWrapper< FUNCTOR > &	b
	)

Swap the functor wrapped by the specified a object with the functor wrapped by the specified b object.

swap() [5/6]

template<class KEY , class VALUE , class COMPARATOR >

void bslstl::swap	(	MapComparator< KEY, VALUE, COMPARATOR > &	a,
		MapComparator< KEY, VALUE, COMPARATOR > &	b
	)

Efficiently exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee.

swap() [6/6]

template<class KEY , class COMPARATOR >

void bslstl::swap ( SetComparator< KEY, COMPARATOR > &  a, SetComparator< KEY, COMPARATOR > &  b  )

inline

Efficiently exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee.

to_chars()

template<class INTEGRAL_TYPE >

to_chars_result bslstl::to_chars ( char *  first, char *  last, INTEGRAL_TYPE  value, int  base = 10  )

inline

Write the specified value into the character buffer starting a the specified first and ending at the specified last. Optionally specify base, the base in which the number is to be written. If base is not specified, decimal is used. Return a to_chars_result struct indicating success or failure, and the end of the written result. On success, the output string is to begin at first, the ptr field in the return value is to point at the end of the representation, and the ec field will be 0. If the buffer specified by [ first .. last ) is not large enough for the result, return a struct with ptr set to last and ec set to errc::value_too_large. Insufficient room in the output buffer is the only failure mode. The behavior is undefined unless first < last and base is in the range [ 2 .. 36 ].

variant_swapImpl() [1/2]

template<class t_VARIANT >

void bslstl::variant_swapImpl	(	bsl::false_type	,
		t_VARIANT &	lhs,
		t_VARIANT &	rhs
	)

This component-private function swaps the values of the specified lhs and rhs when the type (template parameter) t_VARIANT is a non-allocator-aware variant.

variant_swapImpl() [2/2]

template<class t_VARIANT >

void bslstl::variant_swapImpl	(	bsl::true_type	,
		t_VARIANT &	lhs,
		t_VARIANT &	rhs
	)

This component-private function swaps the values of the specified lhs and rhs when the type (template parameter) t_VARIANT is an allocator-aware variant.