Quick Links:

bal | bbl | bdl | bsl

Classes | Typedefs | Functions | Variables

bslstl Namespace Reference
[Component bslstl_algorithm, Component bslstl_badweakptr, Component bslstl_bidirectionaliterator, Component bslstl_bidirectionalnodepool, Component bslstl_boyermoorehorspoolsearcher, Component bslstl_charconv, Component bslstl_defaultsearcher, Component bslstl_forwarditerator, Component bslstl_function_invokerutil, Component bslstl_function_isreferencecompatible, Component bslstl_function_rep, Component bslstl_function_smallobjectoptimization, Component bslstl_hashtable, Component bslstl_hashtablebucketiterator, Component bslstl_hashtableiterator, Component bslstl_iomanip, Component bslstl_iteratorutil, Component bslstl_mapcomparator, Component bslstl_randomaccessiterator, Component bslstl_setcomparator, Component bslstl_sharedptr, Component bslstl_sharedptrallocateinplacerep, Component bslstl_sharedptrallocateoutofplacerep, Component bslstl_simplepool, Component bslstl_stdexceptutil, Component bslstl_stringref, Component bslstl_stringrefdata, Component bslstl_treeiterator, Component bslstl_treenode, Component bslstl_treenodepool, Component bslstl_unorderedmapkeyconfiguration, Component bslstl_unorderedsetkeyconfiguration]

Classes

struct  AlgorithmUtil
class  BadWeakPtr
class  BidirectionalIterator
class  BidirectionalNodePool
class  BoyerMooreHorspoolSearcher_CharImp
class  BoyerMooreHorspoolSearcher_GeneralImp
class  BoyerMooreHorspoolSearcher
struct  to_chars_result
class  DefaultSearcher
struct  DefaultSearcher_CanOptimize
struct  DefaultSearcher_ImpUtil
class  ForwardIterator
struct  Function_ArgTypes
struct  Function_ArgTypes< RET(ARG)>
struct  Function_ArgTypes< RET(ARG1, ARG2)>
class  Function_Variadic< RET(ARGS...)>
struct  Function_InvokerUtil
struct  Function_InvokerUtilNullCheck
struct  Function_InvokerUtilNullCheck< FUNC * >
struct  Function_InvokerUtilNullCheck< MEMTYPE CLASS::* >
struct  Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_FunctionPtr, RET(ARGS...), FUNC >
struct  Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_MemFunctionPtr, RET(ARG0, ARGS...), FUNC >
struct  Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_MemDataPtr, RET(ARG0), MEMBER_TYPE CLASS_TYPE::* >
struct  Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_InplaceFunctor, RET(ARGS...), FUNC >
struct  Function_InvokerUtil_Dispatch< Function_InvokerUtil::e_OutofplaceFunctor, RET(ARGS...), FUNC >
struct  Function_IsReferenceCompatible
struct  Function_IsReferenceCompatible< FROM_TYPE, const TO_TYPE >
class  Function_Rep
class  Function_SmallObjectOptimization
struct  CallableVariable
class  HashTable_HashWrapper
class  HashTable_HashWrapper< const FUNCTOR >
class  HashTable_HashWrapper< FUNCTOR & >
class  HashTable_ComparatorWrapper
class  HashTable_ComparatorWrapper< const FUNCTOR >
class  HashTable_ComparatorWrapper< FUNCTOR & >
class  HashTable
class  HashTable_ArrayProctor
class  HashTable_NodeProctor
struct  HashTable_ImpDetails
struct  HashTable_Util
struct  HashTable_BaseHasher
struct  HashTable_Comparator
class  HashTable_ImplParameters
class  HashTableBucketIterator
class  HashTableIterator
struct  IteratorUtil
class  MapComparator
struct  Optional_IsTriviallyDestructible
struct  Optional_OptNoSuchType
struct  Optional_PropagatesAllocator
struct  Optional_ConstructsFromType
struct  Optional_DataImp
struct  Optional_Data
struct  Optional_Data< TYPE, true >
class  RandomAccessIterator
class  SetComparator
struct  SharedPtr_RepFromExistingSharedPtr
struct  SharedPtrUtil
struct  SharedPtrNilDeleter
struct  SharedPtr_DefaultDeleter
struct  SharedPtr_ImpUtil
class  SharedPtr_RepProctor
class  SharedPtrAllocateInplaceRep
class  SharedPtrAllocateOutofplaceRep
class  SharedPtrAllocateOutofplaceRep_InitProctor
struct  SimplePool_Type
class  SimplePool
struct  StdExceptUtil
class  StringRefImp
struct  StringRefImp_CompareUtil
class  StringRefData
class  TreeIterator
class  TreeNode
class  TreeNodePool
struct  UnorderedMapKeyConfiguration
struct  UnorderedSetKeyConfiguration

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

Variables

const Optional_OptNoSuchType optNoSuchType

Typedef Documentation

typedef StringRefImp<char> bslstl::StringRef
typedef StringRefImp<wchar_t> bslstl::StringRefWide

Function Documentation

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.

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.

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.

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.

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

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

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

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.

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.

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.

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.

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.

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.

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

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

template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool bslstl::operator== ( const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs,
const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs 
)
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 
)
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 
)
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 
)

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.

template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool bslstl::operator!= ( const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs,
const HashTableBucketIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs 
)
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 
)
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 
)
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 
)

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.

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

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.

template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool bslstl::operator== ( const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs,
const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs 
)
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 
)
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 
)
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 
)

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.

template<class VALUE_TYPE , class DIFFERENCE_TYPE >
bool bslstl::operator!= ( const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  lhs,
const HashTableIterator< VALUE_TYPE, DIFFERENCE_TYPE > &  rhs 
)
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 
)
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 
)
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 
)

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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

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

template<class CHAR_TYPE >
bsl::basic_string<CHAR_TYPE> bslstl::operator+ ( const StringRefImp< CHAR_TYPE > &  lhs,
const StringRefImp< CHAR_TYPE > &  rhs 
)
template<class CHAR_TYPE >
bsl::basic_string<CHAR_TYPE> bslstl::operator+ ( const bsl::basic_string< CHAR_TYPE > &  lhs,
const StringRefImp< CHAR_TYPE > &  rhs 
)
template<class CHAR_TYPE >
bsl::basic_string<CHAR_TYPE> bslstl::operator+ ( const StringRefImp< CHAR_TYPE > &  lhs,
const bsl::basic_string< CHAR_TYPE > &  rhs 
)
template<class CHAR_TYPE >
bsl::basic_string<CHAR_TYPE> bslstl::operator+ ( const StringRefImp< CHAR_TYPE > &  lhs,
const std::basic_string< CHAR_TYPE > &  rhs 
)
template<class CHAR_TYPE >
bsl::basic_string<CHAR_TYPE> bslstl::operator+ ( const std::basic_string< CHAR_TYPE > &  lhs,
const StringRefImp< CHAR_TYPE > &  rhs 
)
template<class CHAR_TYPE >
bsl::basic_string<CHAR_TYPE> bslstl::operator+ ( const CHAR_TYPE *  lhs,
const StringRefImp< CHAR_TYPE > &  rhs 
)
template<class CHAR_TYPE >
bsl::basic_string<CHAR_TYPE> bslstl::operator+ ( const StringRefImp< CHAR_TYPE > &  lhs,
const 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.

template<class CHAR_TYPE , class HASHALG >
void bslstl::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 bslstl::operator== ( const TreeIterator< VALUE1, NODEPTR, DIFF > &  lhs,
const TreeIterator< VALUE2, NODEPTR, DIFF > &  rhs 
)

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

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

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.

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

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.

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

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.

Variable Documentation

const Optional_OptNoSuchType bslstl::optNoSuchType

Value of type Optional_OptNoSuchType used as the default argument in functions that are constrained using a function argument.

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