bdlcc Namespace Reference

Classes
class	BoundedQueue
struct	BoundedQueue_Node
struct	BoundedQueue_Node< TYPE, false >
struct	BoundedQueue_Node< TYPE, true >
class	BoundedQueue_PopCompleteGuard
class	BoundedQueue_PushExceptionCompleteProctor
class	Cache
class	Cache_QueueProctor
class	Cache_TestUtil
struct	CacheEvictionPolicy
class	Deque
class	FixedQueue
class	FixedQueue_PopGuard
class	FixedQueue_PushProctor
class	FixedQueueIndexManager
class	MultipriorityQueue
class	MultipriorityQueue_Node
class	ObjectCatalog
class	ObjectCatalog_AutoCleanup
class	ObjectCatalogIter
class	ObjectPool
class	ObjectPool_CreatorConverter
class	ObjectPool_CreatorConverter< ObjectPoolFunctors::DefaultCreator, bsl::function< void(void *)> >
class	ObjectPool_DefaultProxy
class	ObjectPool_GeneralProxy
struct	ObjectPool_ProxyPicker
struct	ObjectPool_ProxyPicker< ObjectPoolFunctors::DefaultCreator >
struct	ObjectPoolFunctors
class	Queue
class	SharedObjectPool
class	SharedObjectPool_Rep
class	SingleConsumerQueue
class	SingleConsumerQueueImpl
class	SingleConsumerQueueImpl_AllocateLockGuard
class	SingleConsumerQueueImpl_MarkReclaimProctor
class	SingleConsumerQueueImpl_PopCompleteGuard
class	SingleProducerQueue
class	SingleProducerQueueImpl
class	SingleProducerQueueImpl_PopCompleteGuard
class	SingleProducerQueueImpl_ReleaseAllRawProctor
class	SingleProducerSingleConsumerBoundedQueue
class	SingleProducerSingleConsumerBoundedQueue_PopCompleteGuard
class	SkipList
class	SkipList_DoubleLockGuard
struct	SkipList_Node
	This component-private structure is a node in the SkipList. More...
class	SkipList_NodeCreationHelper
struct	SkipList_PoolUtil
	This component-private utility handles the lock-free pool of list nodes. More...
class	SkipList_RandomLevelGenerator
class	SkipListPair
class	SkipListPairHandle
class	StripedUnorderedContainerImpl
class	StripedUnorderedContainerImpl_Bucket
class	StripedUnorderedContainerImpl_LockElement
class	StripedUnorderedContainerImpl_LockElementReadGuard
class	StripedUnorderedContainerImpl_LockElementWriteGuard
class	StripedUnorderedContainerImpl_Node
struct	StripedUnorderedContainerImpl_SortItem
class	StripedUnorderedContainerImpl_TestUtil
class	StripedUnorderedMap
class	StripedUnorderedMultiMap
class	TimeQueue
class	TimeQueueItem

Functions
template<class KEY , class DATA >
bool	operator== (const SkipList< KEY, DATA > &lhs, const SkipList< KEY, DATA > &rhs)
template<class KEY , class DATA >
bool	operator!= (const SkipList< KEY, DATA > &lhs, const SkipList< KEY, DATA > &rhs)
template<class KEY , class DATA >
bsl::ostream &	operator<< (bsl::ostream &stream, const SkipList< KEY, DATA > &list)
bool	operator< (const StripedUnorderedContainerImpl_SortItem &lhs, const StripedUnorderedContainerImpl_SortItem &rhs)

Function Documentation

operator!=()

template<class KEY , class DATA >

bool bdlcc::operator!=	(	const SkipList< KEY, DATA > &	lhs,
		const SkipList< KEY, DATA > &	rhs
	)

Return true if the specified lhs list list has a different value from the specified rhs list, and false otherwise. Two lists A and B have different values if they have a different of elements, or if there exists an i in the range [0, numberOfElements) such that the i'th pair from the front of A differs in key or data values from i'th pair from the front of B.

operator<()

bool bdlcc::operator<	(	const StripedUnorderedContainerImpl_SortItem &	lhs,
		const StripedUnorderedContainerImpl_SortItem &	rhs
	)

Return true if the specified lhs is smaller than the specified rhs in the order of stripe, and data.

operator<<()

template<class KEY , class DATA >

bsl::ostream & bdlcc::operator<<	(	bsl::ostream &	stream,
		const SkipList< KEY, DATA > &	list
	)

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

operator==()

template<class KEY , class DATA >

bool bdlcc::operator==	(	const SkipList< KEY, DATA > &	lhs,
		const SkipList< KEY, DATA > &	rhs
	)

Return true if the specified lhs list has the same value as the specified rhs list, and false otherwise. Two lists A and B have the same value if they have the same number of elements, and if for all i in the range [0, numberOfElements), the i'th pair from the front of A has the same key and data values as the i'th pair from the front of B. Note that if there are duplicate key values in a list, the order of iteration over those pairs may be different than for another list that was constructed from the same sequence of values (and thus the lists may not compare equal).