Classes
class	BitArray
class	CompactedArray_RemoveAllProctor
struct	CompactedArray_CountedValue
class	CompactedArray_ConstIterator
class	CompactedArray
struct	FlatHashMap_EntryUtil
class	FlatHashMap
struct	FlatHashSet_EntryUtil
class	FlatHashSet
class	FlatHashTable_IteratorImp
class	FlatHashTable
struct	FlatHashTable_ImplUtil
class	FlatHashTable_GroupControl
class	HashTable
struct	HashTableDefaultTraits
struct	HashTableDefaultHash1
struct	HashTableDefaultHash2
struct	HashTable_ImpUtil
class	IndexClerkIter
class	IndexClerk
struct	PackedIntArrayImp_Signed
struct	PackedIntArrayImp_Unsigned
class	PackedIntArrayImp
struct	PackedIntArrayImpType
class	PackedIntArrayConstIterator
class	PackedIntArray
struct	PackedIntArrayUtil
class	Queue
Functions
bool	operator== (const BitArray &lhs, const BitArray &rhs)
bool	operator!= (const BitArray &lhs, const BitArray &rhs)
BitArray	operator~ (const BitArray &array)
BitArray	operator& (const BitArray &lhs, const BitArray &rhs)
BitArray	operator- (const BitArray &lhs, const BitArray &rhs)
BitArray	operator\| (const BitArray &lhs, const BitArray &rhs)
BitArray	operator^ (const BitArray &lhs, const BitArray &rhs)
BitArray	operator<< (const BitArray &array, bsl::size_t numBits)
BitArray	operator>> (const BitArray &array, bsl::size_t numBits)
bsl::ostream &	operator<< (bsl::ostream &stream, const BitArray &rhs)
void	swap (BitArray &a, BitArray &b)
template<class TYPE >
CompactedArray_ConstIterator < TYPE >	operator++ (CompactedArray_ConstIterator< TYPE > &, int)
template<class TYPE >
CompactedArray_ConstIterator < TYPE >	operator-- (CompactedArray_ConstIterator< TYPE > &, int)
template<class TYPE >
CompactedArray_ConstIterator < TYPE >	operator+ (const CompactedArray_ConstIterator< TYPE > &, bsl::ptrdiff_t)
template<class TYPE >
CompactedArray_ConstIterator < TYPE >	operator- (const CompactedArray_ConstIterator< TYPE > &, bsl::ptrdiff_t)
template<class TYPE >
bsl::ptrdiff_t	operator- (const CompactedArray_ConstIterator< TYPE > &, const CompactedArray_ConstIterator< TYPE > &)
template<class TYPE >
bool	operator== (const CompactedArray_ConstIterator< TYPE > &, const CompactedArray_ConstIterator< TYPE > &)
template<class TYPE >
bool	operator!= (const CompactedArray_ConstIterator< TYPE > &, const CompactedArray_ConstIterator< TYPE > &)
template<class TYPE >
bool	operator< (const CompactedArray_ConstIterator< TYPE > &, const CompactedArray_ConstIterator< TYPE > &)
template<class TYPE >
bool	operator<= (const CompactedArray_ConstIterator< TYPE > &, const CompactedArray_ConstIterator< TYPE > &)
template<class TYPE >
bool	operator> (const CompactedArray_ConstIterator< TYPE > &, const CompactedArray_ConstIterator< TYPE > &)
template<class TYPE >
bool	operator>= (const CompactedArray_ConstIterator< TYPE > &, const CompactedArray_ConstIterator< TYPE > &)
template<class TYPE >
bool	operator== (const CompactedArray_CountedValue< TYPE > &lhs, const CompactedArray_CountedValue< TYPE > &rhs)
template<class TYPE >
bool	operator!= (const CompactedArray_CountedValue< TYPE > &lhs, const CompactedArray_CountedValue< TYPE > &rhs)
template<class TYPE >
bool	operator< (const CompactedArray_CountedValue< TYPE > &lhs, const TYPE &rhs)
template<class TYPE >
bool	operator< (const TYPE &lhs, const CompactedArray_CountedValue< TYPE > &rhs)
template<class TYPE >
CompactedArray_ConstIterator < TYPE >	operator+ (bsl::ptrdiff_t offset, const CompactedArray_ConstIterator< TYPE > &iterator)
template<class TYPE >
bsl::ostream &	operator<< (bsl::ostream &stream, const CompactedArray< TYPE > &array)
template<class TYPE >
bool	operator== (const CompactedArray< TYPE > &lhs, const CompactedArray< TYPE > &rhs)
template<class TYPE >
bool	operator!= (const CompactedArray< TYPE > &lhs, const CompactedArray< TYPE > &rhs)
template<class TYPE >
void	swap (CompactedArray< TYPE > &a, CompactedArray< TYPE > &b)
template<class HASHALG , class TYPE >
void	hashAppend (HASHALG &hashAlg, const CompactedArray< TYPE > &input)
template<class KEY , class VALUE , class HASH , class EQUAL >
bool	operator== (const FlatHashMap< KEY, VALUE, HASH, EQUAL > &lhs, const FlatHashMap< KEY, VALUE, HASH, EQUAL > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL >
bool	operator!= (const FlatHashMap< KEY, VALUE, HASH, EQUAL > &lhs, const FlatHashMap< KEY, VALUE, HASH, EQUAL > &rhs)
template<class KEY , class VALUE , class HASH , class EQUAL >
void	swap (FlatHashMap< KEY, VALUE, HASH, EQUAL > &a, FlatHashMap< KEY, VALUE, HASH, EQUAL > &b)
template<class KEY , class VALUE , class HASH , class EQUAL >
bsl::ostream &	operator<< (bsl::ostream &stream, const FlatHashMap< KEY, VALUE, HASH, EQUAL > &map)
template<class KEY , class HASH , class EQUAL >
bool	operator== (const FlatHashSet< KEY, HASH, EQUAL > &a, const FlatHashSet< KEY, HASH, EQUAL > &b)
template<class KEY , class HASH , class EQUAL >
bool	operator!= (const FlatHashSet< KEY, HASH, EQUAL > &a, const FlatHashSet< KEY, HASH, EQUAL > &b)
template<class KEY , class HASH , class EQUAL >
void	swap (FlatHashSet< KEY, HASH, EQUAL > &a, FlatHashSet< KEY, HASH, EQUAL > &b)
template<class KEY , class HASH , class EQUAL >
bsl::ostream &	operator<< (bsl::ostream &stream, const FlatHashSet< KEY, HASH, EQUAL > &set)
template<class ENTRY >
bool	operator== (const class FlatHashTable_IteratorImp< ENTRY > &, const class FlatHashTable_IteratorImp< ENTRY > &)
template<class ENTRY >
bool	operator== (const FlatHashTable_IteratorImp< ENTRY > &a, const FlatHashTable_IteratorImp< ENTRY > &b)
template<class KEY , class ENTRY , class ENTRY_UTIL , class HASH , class EQUAL >
bool	operator== (const FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &lhs, const FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &rhs)
template<class KEY , class ENTRY , class ENTRY_UTIL , class HASH , class EQUAL >
bool	operator!= (const FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &lhs, const FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &rhs)
template<class KEY , class ENTRY , class ENTRY_UTIL , class HASH , class EQUAL >
void	swap (FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &a, FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &b)
bool	operator== (const IndexClerkIter &lhs, const IndexClerkIter &rhs)
bool	operator!= (const IndexClerkIter &lhs, const IndexClerkIter &rhs)
bool	operator== (const IndexClerk &lhs, const IndexClerk &rhs)
bool	operator!= (const IndexClerk &lhs, const IndexClerk &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const IndexClerk &rhs)
template<class TYPE >
PackedIntArrayConstIterator< TYPE >	operator++ (PackedIntArrayConstIterator< TYPE > &, int)
template<class TYPE >
PackedIntArrayConstIterator< TYPE >	operator-- (PackedIntArrayConstIterator< TYPE > &, int)
template<class TYPE >
bool	operator== (const PackedIntArrayConstIterator< TYPE > &, const PackedIntArrayConstIterator< TYPE > &)
template<class TYPE >
bool	operator!= (const PackedIntArrayConstIterator< TYPE > &, const PackedIntArrayConstIterator< TYPE > &)
template<class TYPE >
bsl::ptrdiff_t	operator- (const PackedIntArrayConstIterator< TYPE > &, const PackedIntArrayConstIterator< TYPE > &)
template<class TYPE >
bool	operator< (const PackedIntArrayConstIterator< TYPE > &, const PackedIntArrayConstIterator< TYPE > &)
template<class TYPE >
bool	operator<= (const PackedIntArrayConstIterator< TYPE > &, const PackedIntArrayConstIterator< TYPE > &)
template<class TYPE >
bool	operator> (const PackedIntArrayConstIterator< TYPE > &, const PackedIntArrayConstIterator< TYPE > &)
template<class TYPE >
bool	operator>= (const PackedIntArrayConstIterator< TYPE > &, const PackedIntArrayConstIterator< TYPE > &)
template<class TYPE >
bsl::ostream &	operator<< (bsl::ostream &stream, const PackedIntArray< TYPE > &array)
template<class TYPE >
bool	operator== (const PackedIntArray< TYPE > &lhs, const PackedIntArray< TYPE > &rhs)
template<class TYPE >
bool	operator!= (const PackedIntArray< TYPE > &lhs, const PackedIntArray< TYPE > &rhs)
template<class TYPE >
void	swap (PackedIntArray< TYPE > &a, PackedIntArray< TYPE > &b)
template<class HASHALG , class TYPE >
void	hashAppend (HASHALG &hashAlg, const PackedIntArray< TYPE > &input)
template<class T >
bool	operator== (const Queue< T > &lhs, const Queue< T > &rhs)
template<class T >
bool	operator!= (const Queue< T > &lhs, const Queue< T > &rhs)
template<class T >
bsl::ostream &	operator<< (bsl::ostream &stream, const Queue< T > &queue)

Function Documentation

bool bdlc::operator==	(	const BitArray &	lhs,
		const BitArray &	rhs
	)

Return true if the specified lhs and rhs arrays have the same value, and false otherwise. Two arrays have the same value if they have the same length, and corresponding bits at each bit position have the same value.

bool bdlc::operator!=	(	const BitArray &	lhs,
		const BitArray &	rhs
	)

Return true if the specified lhs and rhs arrays do not have the same value, and false otherwise. Two arrays do not have the same value if they do not have the same length, or there is at least one valid index position at which corresponding bits do not have the same value.

BitArray bdlc::operator~ ( const BitArray & array )

Return the bitwise complement ("toggle") of the specified array.

BitArray bdlc::operator&	(	const BitArray &	lhs,
		const BitArray &	rhs
	)

Return the value that is the bitwise AND of the specified lhs and rhs arrays. The length of the resulting bit array will be the maximum of that of lhs and rhs, with any unmatched high-order bits set to 0. Note that this behavior is consistent with zero-extending a copy of the shorter array.

BitArray bdlc::operator-	(	const BitArray &	lhs,
		const BitArray &	rhs
	)

Return the value that is the bitwise MINUS of the specified lhs and rhs arrays. The length of the resulting bit array will be the maximum of that of lhs and rhs, with any unmatched high-order lhs bits copied unchanged, and any unmatched high-order rhs bits set to 0. Note that this behavior is consistent with zero-extending a copy of the shorter array.

BitArray bdlc::operator\|	(	const BitArray &	lhs,
		const BitArray &	rhs
	)

Return the value that is the bitwise OR of the specified lhs and rhs arrays. The length of the resulting bit array will be the maximum of that of lhs and rhs, with any unmatched high-order bits copied unchanged. Note that this behavior is consistent with zero-extending a copy of the shorter array.

BitArray bdlc::operator^	(	const BitArray &	lhs,
		const BitArray &	rhs
	)

Return the value that is the bitwise XOR of the specified lhs and rhs arrays. The length of the resulting bit array will be the maximum of that of lhs and rhs, with any unmatched high-order bits copied unchanged. Note that this behavior is consistent with zero-extending a copy of the shorter array.

BitArray bdlc::operator<<	(	const BitArray &	array,
		bsl::size_t	numBits
	)

Return the value of the specified array left-shifted by the specified numBits positions, having filled the lower-index positions with zeros. The behavior is undefined unless numBits <= array.length(). Note that the length of the result equals the length of the original array, and that the highest-order numBits are discarded in the result.

BitArray bdlc::operator>>	(	const BitArray &	array,
		bsl::size_t	numBits
	)

Return the value of the specified array right-shifted by the specified numBits positions, having filled the higher-index positions with zeros. The behavior is undefined unless numBits <= array.length(). Note that the length of the result equals the length of the original array, and that the lowest-order numBits are discarded in the result.

bsl::ostream& bdlc::operator<<	(	bsl::ostream &	stream,
		const BitArray &	rhs
	)

Format the bits in the specified rhs bit array to the specified output stream in a single-line format, and return a reference to stream.

void bdlc::swap	(	BitArray &	a,
		BitArray &	b
	)

Exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.

template<class TYPE >

CompactedArray_ConstIterator< TYPE > bdlc::operator++	(	CompactedArray_ConstIterator< TYPE > &	iterator,
		int
	)

Advance the specified iterator to refer to the next location in the referenced array, and return an iterator referring to the original location (before the advancement). The returned iterator, it, referencing a CompactedArray array, remains valid as long as 0 <= it - array.begin() <= array.length(). The behavior is undefined unless, on entry, CompactedArray_ConstIterator() != iterator and iterator - array.begin() < array.length().

template<class TYPE >

CompactedArray_ConstIterator< TYPE > bdlc::operator--	(	CompactedArray_ConstIterator< TYPE > &	iterator,
		int
	)

Decrement the specified iterator to refer to the previous location in the referenced array, and return an iterator referring to the original location (before the decrementation). The returned iterator, it, referencing a CompactedArray array, remains valid as long as 0 <= it - array.begin() <= array.length(). The behavior is undefined unless, on entry, CompactedArray_ConstIterator() != iterator and 0 < iterator - array.begin().

template<class TYPE >

CompactedArray_ConstIterator< TYPE > bdlc::operator+	(	const CompactedArray_ConstIterator< TYPE > &	,
		bsl::ptrdiff_t
	)

template<class TYPE >

CompactedArray_ConstIterator< TYPE > bdlc::operator-	(	const CompactedArray_ConstIterator< TYPE > &	iterator,
		bsl::ptrdiff_t	offset
	)

Return an iterator referencing the location at the specified offset from the location referenced by the specified iterator. The returned iterator, it, referencing a CompactedArray array, remains valid as long as 0 <= it - array.begin() <= array.length(). The behavior is undefined unless CompactedArray_ConstIterator() != iterator and 0 <= iterator - array.begin() - offset <= array.length().

template<class TYPE >

bsl::ptrdiff_t bdlc::operator-	(	const CompactedArray_ConstIterator< TYPE > &	lhs,
		const CompactedArray_ConstIterator< TYPE > &	rhs
	)

Return the number of elements between the specified lhs and rhs as a signed value. The behavior is undefined unless lhs and rhs reference the same array. Note that the return value is positive when a positive number of rhs++ invocations would result in lhs == rhs, and negative when a positive number of rhs-- invocations would result in lhs == rhs.

template<class TYPE >

bool bdlc::operator==	(	const CompactedArray_ConstIterator< TYPE > &	lhs,
		const CompactedArray_ConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs and rhs iterators have the same value, and false otherwise. Two CompactedArray_ConstIterator iterators have the same value if they both have the default value, or neither has the default value and they reference the same location in the same array.

template<class TYPE >

bool bdlc::operator!=	(	const CompactedArray_ConstIterator< TYPE > &	lhs,
		const CompactedArray_ConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs and rhs iterators do not have the same value, and false otherwise. Two CompactedArray_ConstIterator iterators do not have the same value if one has the default value and the other does not, or neither has the default value and they do not reference the same location in the same array.

template<class TYPE >

bool bdlc::operator<	(	const CompactedArray_ConstIterator< TYPE > &	lhs,
		const CompactedArray_ConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs has a value less than the specified rhs, and false otherwise. Iterator lhs has a value less than iterator rhs if 0 < rhs - lhs (see operator-). The behavior is undefined unless lhs and rhs refer to the same array.

template<class TYPE >

bool bdlc::operator<=	(	const CompactedArray_ConstIterator< TYPE > &	lhs,
		const CompactedArray_ConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs has a value less than or equal to the specified rhs, and 'false otherwise. Iterator lhs has a value less than or equal to iterator rhs if 0 <= rhs - lhs (see operator-). The behavior is undefined unless lhs and rhs refer to the same array.

template<class TYPE >

bool bdlc::operator>	(	const CompactedArray_ConstIterator< TYPE > &	lhs,
		const CompactedArray_ConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs has a value greater than the specified rhs, and false otherwise. Iterator lhs has a value greater than iterator rhs if 0 > rhs - lhs (see operator-). The behavior is undefined unless lhs and rhs refer to the same array.

template<class TYPE >

bool bdlc::operator>=	(	const CompactedArray_ConstIterator< TYPE > &	lhs,
		const CompactedArray_ConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs has a value greater or equal than the specified rhs, and false otherwise. Iterator lhs has a value greater than or equal to iterator rhs if 0 >= rhs - lhs (see operator-). The behavior is undefined unless lhs and rhs refer to the same array.

template<class TYPE >

bool bdlc::operator==	(	const CompactedArray_CountedValue< TYPE > &	lhs,
		const CompactedArray_CountedValue< TYPE > &	rhs
	)

Return true if the underlying object value of the specified lhs is the same as the underlying object value of the specified rhs, and false otherwise. Note that the reference counts are intentionally ignored.

template<class TYPE >

bool bdlc::operator!=	(	const CompactedArray_CountedValue< TYPE > &	lhs,
		const CompactedArray_CountedValue< TYPE > &	rhs
	)

Return true if the underlying object value of the specified lhs is not the same as the underlying object value of the specified rhs, and false otherwise. Note that the reference counts are intentionally ignored.

template<class TYPE >

bool bdlc::operator<	(	const CompactedArray_CountedValue< TYPE > &	lhs,
		const TYPE &	rhs
	)

Return true if the underlying object value of the specified lhs is less than the value of the specified rhs, and false otherwise. Note that the reference count is intentionally ignored.

template<class TYPE >

bool bdlc::operator<	(	const TYPE &	lhs,
		const CompactedArray_CountedValue< TYPE > &	rhs
	)

Return true if the value of the specified lhs is less than the underlying object value of the specified rhs, and false otherwise. Note that the reference count is intentionally ignored.

template<class TYPE >

CompactedArray_ConstIterator<TYPE> bdlc::operator+	(	bsl::ptrdiff_t	offset,
		const CompactedArray_ConstIterator< TYPE > &	iterator
	)

Return an iterator referencing the location at the specified offset from the location referenced by the specified iterator. The returned iterator, it, referencing a CompactedArray array, remains valid as long as 0 <= it - array.begin() <= array.length(). The behavior is undefined unless CompactedArray_ConstIterator() != iterator and 0 <= iterator - array.begin() + offset <= array.length().

template<class TYPE >

bsl::ostream& bdlc::operator<<	(	bsl::ostream &	stream,
		const CompactedArray< TYPE > &	array
	)

Write the value of the specified array to the specified output stream in a single-line format, and return a reference providing modifiable access to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice.

template<class TYPE >

bool bdlc::operator==	(	const CompactedArray< TYPE > &	lhs,
		const CompactedArray< TYPE > &	rhs
	)

Return true if the specified lhs and rhs arrays have the same value, and false otherwise. Two CompactedArray arrays have the same value if they have the same length, and all corresponding elements (those at the same indices) have the same value.

template<class TYPE >

bool bdlc::operator!=	(	const CompactedArray< TYPE > &	lhs,
		const CompactedArray< TYPE > &	rhs
	)

Return true if the specified lhs and rhs arrays do not have the same value, and false otherwise. Two CompactedArray arrays do not have the same value if they do not have the same length, or if any corresponding elements (those at the same indices) do not have the same value.

template<class TYPE >

void bdlc::swap	(	CompactedArray< TYPE > &	a,
		CompactedArray< TYPE > &	b
	)

Exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.

template<class HASHALG , class TYPE >

void bdlc::hashAppend	(	HASHALG &	hashAlg,
		const CompactedArray< TYPE > &	input
	)

Pass the specified input to the specified hashAlg.

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

bool bdlc::operator==	(	const FlatHashMap< KEY, VALUE, HASH, EQUAL > &	lhs,
		const FlatHashMap< KEY, VALUE, HASH, EQUAL > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two FlatHashMap objects have the same value if their sizes are the same and each element contained in one is equal to an element of the other. The hash and equality functors are not involved in the comparison.

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

bool bdlc::operator!=	(	const FlatHashMap< KEY, VALUE, HASH, EQUAL > &	lhs,
		const FlatHashMap< KEY, VALUE, HASH, EQUAL > &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two FlatHashMap objects do not have the same value if their sizes are different or one contains an element equal to no element of the other. The hash and equality functors are not involved in the comparison.

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

void bdlc::swap	(	FlatHashMap< KEY, VALUE, HASH, EQUAL > &	a,
		FlatHashMap< KEY, VALUE, HASH, EQUAL > &	b
	)

Exchange the value, the hasher, and the key-equality functor of the specified a and b objects. This function provides the no-throw exception-safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.

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

bsl::ostream& bdlc::operator<<	(	bsl::ostream &	stream,
		const FlatHashMap< KEY, VALUE, HASH, EQUAL > &	map
	)

Write the value of the specified map to the specified output stream in a single-line format, and return a reference providing modifiable access to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice.

template<class KEY , class HASH , class EQUAL >

bool bdlc::operator==	(	const FlatHashSet< KEY, HASH, EQUAL > &	lhs,
		const FlatHashSet< KEY, HASH, EQUAL > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two FlatHashSet objects have the same value if their sizes are the same and each element contained in one is equal to an element of the other. The hash and equality functors are not involved in the comparison.

template<class KEY , class HASH , class EQUAL >

bool bdlc::operator!=	(	const FlatHashSet< KEY, HASH, EQUAL > &	lhs,
		const FlatHashSet< KEY, HASH, EQUAL > &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two FlatHashSet objects do not have the same value if their sizes are different or one contains an element equal to no element of the other. The hash and equality functors are not involved in the comparison.

template<class KEY , class HASH , class EQUAL >

void bdlc::swap	(	FlatHashSet< KEY, HASH, EQUAL > &	a,
		FlatHashSet< KEY, HASH, EQUAL > &	b
	)

Exchange the value, the hasher, and the key-equality functor of the specified a and b objects. This function provides the no-throw exception-safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.

template<class KEY , class HASH , class EQUAL >

bsl::ostream& bdlc::operator<<	(	bsl::ostream &	stream,
		const FlatHashSet< KEY, HASH, EQUAL > &	set
	)

Write the value of the specified set to the specified output stream in a single-line format, and return a reference providing modifiable access to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice.

template<class ENTRY >

bool bdlc::operator==	(	const class FlatHashTable_IteratorImp< ENTRY > &	,
		const class FlatHashTable_IteratorImp< ENTRY > &
	)

template<class ENTRY >

bool bdlc::operator==	(	const FlatHashTable_IteratorImp< ENTRY > &	a,
		const FlatHashTable_IteratorImp< ENTRY > &	b
	)

Return true if the specified a and b are equal. Two FlatHashTable_IteratorImp objects are equal if they both refer to the same element of the underlying flat hash table, or are both not dereferenceable. The behavior is undefined unless a and b refer to the same FlatHashTable.

template<class KEY , class ENTRY , class ENTRY_UTIL , class HASH , class EQUAL >

bool bdlc::operator==	(	const FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &	lhs,
		const FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two FlatHashTable objects have the same value if they have the same number of entries, and for each entry that is contained in lhs there is a entry contained in rhs having the same value. Note that this method requires the (template parameter) type ENTRY to be equality-comparable.

template<class KEY , class ENTRY , class ENTRY_UTIL , class HASH , class EQUAL >

bool bdlc::operator!=	(	const FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &	lhs,
		const FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two FlatHashTable objects do not have the same value if they do not have the same number of entries, or that for some entry contained in lhs there is not a entry in rhs having the same value. Note that this method requires the (template parameter) type ENTRY to be equality-comparable.

template<class KEY , class ENTRY , class ENTRY_UTIL , class HASH , class EQUAL >

void bdlc::swap	(	FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &	a,
		FlatHashTable< KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL > &	b
	)

Exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.

bool bdlc::operator==	(	const IndexClerkIter &	lhs,
		const IndexClerkIter &	rhs
	)

Return true if lhs and rhs have the same value and false otherwise. Two iterators have the same value if they refer to the same element of the same container or if they both have the end iterator value for the same container. The behavior is undefined unless lhs and rhs refer to the same container and are non-singular (i.e., are not default-constructed or copies of singular iterators).

bool bdlc::operator!=	(	const IndexClerkIter &	lhs,
		const IndexClerkIter &	rhs
	)

Return true if lhs and rhs do not have the same value and false otherwise. Two iterators do not have the same value if they do not refer to the same element of the same container or if one has the end iterator value of a container and the other refers to an element (not the end) of the same container. The behavior is undefined unless lhs and rhs refer to the same container and are non-singular (i.e., are not default-constructed or copies of singular iterators).

bool bdlc::operator==	(	const IndexClerk &	lhs,
		const IndexClerk &	rhs
	)

Return true if the specified lhs and rhs index clerks have the same value, and false otherwise. Two IndexClerk objects have the same value if they have the same nextNewIndex() and would always generate the same sequence of integer indices.

bool bdlc::operator!=	(	const IndexClerk &	lhs,
		const IndexClerk &	rhs
	)

Return true if the specified lhs and rhs index clerks do not have the same value, and false otherwise. Two IndexClerk objects do not have the same value if they do not have the same nextNewIndex(), or might generate different sequences of integer indices.

bsl::ostream& bdlc::operator<<	(	bsl::ostream &	stream,
		const IndexClerk &	rhs
	)

Write the specified rhs index clerk to the specified output stream in some single-line (human-readable) format, and return a reference to the modifiable stream.

template<class TYPE >

PackedIntArrayConstIterator< TYPE > bdlc::operator++	(	PackedIntArrayConstIterator< TYPE > &	iter,
		int
	)

Advance the specified iterator iter to refer to the next element in the referenced array, and return an iterator referring to the original element (before the advancement). The returned iterator, it, referencing an element within a PackedIntArray, array, remains valid as long as 0 <= it - array.begin() <= array.length(). The behavior is undefined unless, on entry, PackedIntArrayConstInterator() != iter and iter - array.begin() < array.length().

template<class TYPE >

PackedIntArrayConstIterator< TYPE > bdlc::operator--	(	PackedIntArrayConstIterator< TYPE > &	iter,
		int
	)

Decrement the specified iterator iter to refer to the previous element in the referenced array, and return an iterator referring to the original element (before the decrementation). The returned iterator, it, referencing an element within a PackedIntArray, array, remains valid as long as 0 <= it - array.begin() <= array.length(). The behavior is undefined unless, on entry, PackedIntArrayConstInterator() != iter and 0 < iter - array.begin().

template<class TYPE >

bool bdlc::operator==	(	const PackedIntArrayConstIterator< TYPE > &	lhs,
		const PackedIntArrayConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs and rhs iterators have the same value, and false otherwise. Two PackedIntArrayConstIterator iterators have the same value if they refer to the same array, and have the same index.

template<class TYPE >

bool bdlc::operator!=	(	const PackedIntArrayConstIterator< TYPE > &	lhs,
		const PackedIntArrayConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs and rhs iterators do not have the same value and false otherwise. Two PackedIntArrayConstIterator iterators do not have the same value if they do not refer to the same array, or do not have the same index.

template<class TYPE >

bsl::ptrdiff_t bdlc::operator-	(	const PackedIntArrayConstIterator< TYPE > &	lhs,
		const PackedIntArrayConstIterator< TYPE > &	rhs
	)

Return the number of elements between specified lhs and rhs. The behavior is undefined unless lhs and rhs reference the same array.

template<class TYPE >

bool bdlc::operator<	(	const PackedIntArrayConstIterator< TYPE > &	lhs,
		const PackedIntArrayConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs has a value less than the specified rhs, false otherwise. An iterator has a value less than another if its index is less the other's index. The behavior is undefined unless lhs and rhs refer to the same array.

template<class TYPE >

bool bdlc::operator<=	(	const PackedIntArrayConstIterator< TYPE > &	lhs,
		const PackedIntArrayConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs has a value less than or equal to the specified rhs, 'false otherwise. An iterator has a value less than or equal to another if its index is less or equal the other's index. The behavior is undefined unless lhs and rhs refer to the same array.

template<class TYPE >

bool bdlc::operator>	(	const PackedIntArrayConstIterator< TYPE > &	lhs,
		const PackedIntArrayConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs has a value greater than the specified rhs, false otherwise. An iterator has a value greater than another if its index is greater the other's index. The behavior is undefined unless lhs and rhs refer to the same array.

template<class TYPE >

bool bdlc::operator>=	(	const PackedIntArrayConstIterator< TYPE > &	lhs,
		const PackedIntArrayConstIterator< TYPE > &	rhs
	)

Return true if the specified lhs has a value greater or equal than the specified rhs, false otherwise. An iterator has a value greater than or equal to another if its index is greater the other's index. The behavior is undefined unless lhs and rhs refer to the same array.

template<class TYPE >

bsl::ostream& bdlc::operator<<	(	bsl::ostream &	stream,
		const PackedIntArray< TYPE > &	array
	)

Write the value of the specified array to the specified output stream in a single-line format, and return a reference providing modifiable access to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice.

template<class TYPE >

bool bdlc::operator==	(	const PackedIntArray< TYPE > &	lhs,
		const PackedIntArray< TYPE > &	rhs
	)

Return true if the specified lhs and rhs arrays have the same value, and false otherwise. Two PackedIntArray arrays have the same value if they have the same length, and all corresponding elements (those at the same indices) have the same value.

template<class TYPE >

bool bdlc::operator!=	(	const PackedIntArray< TYPE > &	lhs,
		const PackedIntArray< TYPE > &	rhs
	)

Return true if the specified lhs and rhs arrays do not have the same value, and false otherwise. Two PackedIntArray arrays do not have the same value if they do not have the same length, or if any corresponding elements (those at the same indices) do not have the same value.

template<class TYPE >

void bdlc::swap	(	PackedIntArray< TYPE > &	a,
		PackedIntArray< TYPE > &	b
	)

Exchange the values of the specified a and b objects. This function provides the no-throw exception-safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.

template<class HASHALG , class TYPE >

void bdlc::hashAppend	(	HASHALG &	hashAlg,
		const PackedIntArray< TYPE > &	input
	)

Pass the specified input to the specified hashAlg

template<class T >

bool bdlc::operator==	(	const Queue< T > &	lhs,
		const Queue< T > &	rhs
	)			`[inline]`

Return true if the specified lhs and rhs queues have the same value, and false otherwise. Two queues have the same value if they have the same length and the same element value at each respective index position.

template<class T >

bool bdlc::operator!=	(	const Queue< T > &	lhs,
		const Queue< T > &	rhs
	)			`[inline]`

Return true if the specified lhs and rhs queues do not have the same value, and false otherwise. Two queues do not have the same value if they have different lengths or differ in at least one index position.

template<class T >

bsl::ostream& bdlc::operator<<	(	bsl::ostream &	stream,
		const Queue< T > &	queue
	)			`[inline]`

Write the specified queue to the specified output stream and return a reference to the modifiable stream.

Classes

Functions

Function Documentation