bsltf Namespace Reference [Component bsltf_allocargumenttype, Component bsltf_allocbitwisemoveabletesttype, Component bsltf_allocemplacabletesttype, Component bsltf_alloctesttype, Component bsltf_argumenttype, Component bsltf_bitwisecopyabletesttype, Component bsltf_bitwisemoveabletesttype, Component bsltf_convertiblevaluewrapper, Component bsltf_degeneratefunctor, Component bsltf_emplacabletesttype, Component bsltf_enumeratedtesttype, Component bsltf_evilbooleantype, Component bsltf_inputiterator, Component bsltf_movablealloctesttype, Component bsltf_movabletesttype, Component bsltf_moveonlyalloctesttype, Component bsltf_movestate, Component bsltf_nonassignabletesttype, Component bsltf_noncopyconstructibletesttype, Component bsltf_nondefaultconstructibletesttype, Component bsltf_nonequalcomparabletesttype, Component bsltf_nonoptionalalloctesttype, Component bsltf_nontypicaloverloadstesttype, Component bsltf_simpletesttype, Component bsltf_stdallocatoradaptor, Component bsltf_stdalloctesttype, Component bsltf_stdstatefulallocator, Component bsltf_stdtestallocator, Component bsltf_templatetestfacility, Component bsltf_testvaluesarray, Component bsltf_uniontesttype, Component bsltf_wellbehavedmoveonlyalloctesttype]

Classes
class	AllocArgumentType
class	AllocBitwiseMoveableTestType
class	AllocEmplacableTestType
class	AllocTestType
class	ArgumentType
class	BitwiseCopyableTestType
class	BitwiseMoveableTestType
struct	ConvertibleValueWrapper
class	DegenerateFunctor
class	EmplacableTestType
struct	EnumeratedTestType
struct	EvilBooleanType
class	InputIterator
struct	InputIteratorUtil
class	MovableAllocTestType
class	MovableTestType
class	MoveOnlyAllocTestType
struct	MoveState
class	NonAssignableTestType
class	NonCopyConstructibleTestType
class	NonDefaultConstructibleTestType
class	NonEqualComparableTestType
class	NonOptionalAllocTestType
class	NonTypicalOverloadsTestType
class	SimpleTestType
class	StdAllocatorAdaptor
class	StdAllocTestType
class	StdStatefulAllocator
struct	StdTestAllocatorConfiguration
class	StdTestAllocatorConfigurationGuard
class	StdTestAllocator
class	StdTestAllocator< void >
struct	StdTestAllocator_CommonUtil
class	TemplateTestFacility_StubClass
class	TemplateTestFacility_CompareHelper
struct	TemplateTestFacility
class	TestValuesArrayIterator
class	TestValuesArray
struct	TestValuesArray_DefaultConverter
class	TestValuesArray_PostIncrementPtr
union	UnionTestType
class	WellBehavedMoveOnlyAllocTestType
Functions
template<int N>
MoveState::Enum	getMovedFrom (const AllocArgumentType< N > &object)
template<int N>
MoveState::Enum	getMovedInto (const AllocArgumentType< N > &object)
bool	operator== (const AllocBitwiseMoveableTestType &lhs, const AllocBitwiseMoveableTestType &rhs)
bool	operator!= (const AllocBitwiseMoveableTestType &lhs, const AllocBitwiseMoveableTestType &rhs)
bool	operator== (const AllocEmplacableTestType &lhs, const AllocEmplacableTestType &rhs)
bool	operator!= (const AllocEmplacableTestType &lhs, const AllocEmplacableTestType &rhs)
bool	operator== (const AllocTestType &lhs, const AllocTestType &rhs)
bool	operator!= (const AllocTestType &lhs, const AllocTestType &rhs)
template<int N>
MoveState::Enum	getMovedFrom (const ArgumentType< N > &object)
template<int N>
MoveState::Enum	getMovedInto (const ArgumentType< N > &object)
bool	operator== (const BitwiseCopyableTestType &lhs, const BitwiseCopyableTestType &rhs)
bool	operator!= (const BitwiseCopyableTestType &lhs, const BitwiseCopyableTestType &rhs)
bool	operator== (const BitwiseMoveableTestType &lhs, const BitwiseMoveableTestType &rhs)
bool	operator!= (const BitwiseMoveableTestType &lhs, const BitwiseMoveableTestType &rhs)
template<class FUNCTOR >
void	swap (DegenerateFunctor< FUNCTOR, true > &lhs, DegenerateFunctor< FUNCTOR, true > &rhs)
bool	operator== (const EmplacableTestType &lhs, const EmplacableTestType &rhs)
bool	operator!= (const EmplacableTestType &lhs, const EmplacableTestType &rhs)
EvilBooleanType	operator== (const EvilBooleanType &lhs, const EvilBooleanType &rhs)
EvilBooleanType	operator!= (const EvilBooleanType &lhs, const EvilBooleanType &rhs)
template<class TYPE >
bool	operator== (const InputIterator< TYPE > &lhs, const InputIterator< TYPE > &rhs)
template<class TYPE >
bool	operator!= (const InputIterator< TYPE > &lhs, const InputIterator< TYPE > &rhs)
bool	operator== (const MovableAllocTestType &lhs, const MovableAllocTestType &rhs)
bool	operator!= (const MovableAllocTestType &lhs, const MovableAllocTestType &rhs)
MoveState::Enum	getMovedFrom (const MovableAllocTestType &object)
MoveState::Enum	getMovedInto (const MovableAllocTestType &object)
void	setMovedInto (MovableAllocTestType *object, MoveState::Enum value)
bool	operator== (const MovableTestType &lhs, const MovableTestType &rhs)
bool	operator!= (const MovableTestType &lhs, const MovableTestType &rhs)
MoveState::Enum	getMovedFrom (const MovableTestType &object)
MoveState::Enum	getMovedInto (const MovableTestType &object)
void	setMovedInto (MovableTestType *object, MoveState::Enum value)
bool	operator== (const MoveOnlyAllocTestType &lhs, const MoveOnlyAllocTestType &rhs)
bool	operator!= (const MoveOnlyAllocTestType &lhs, const MoveOnlyAllocTestType &rhs)
MoveState::Enum	getMovedFrom (const MoveOnlyAllocTestType &object)
MoveState::Enum	getMovedInto (const MoveOnlyAllocTestType &object)
void	setMovedInto (MoveOnlyAllocTestType *object, MoveState::Enum value)
void	swap (MoveOnlyAllocTestType &a, MoveOnlyAllocTestType &b)
void	debugprint (const MoveState::Enum &value)
bool	operator== (const NonAssignableTestType &lhs, const NonAssignableTestType &rhs)
bool	operator!= (const NonAssignableTestType &lhs, const NonAssignableTestType &rhs)
bool	operator== (const NonCopyConstructibleTestType &lhs, const NonCopyConstructibleTestType &rhs)
bool	operator!= (const NonCopyConstructibleTestType &lhs, const NonCopyConstructibleTestType &rhs)
bool	operator== (const NonDefaultConstructibleTestType &lhs, const NonDefaultConstructibleTestType &rhs)
bool	operator!= (const NonDefaultConstructibleTestType &lhs, const NonDefaultConstructibleTestType &rhs)
bool	operator== (const NonOptionalAllocTestType &lhs, const NonOptionalAllocTestType &rhs)
bool	operator!= (const NonOptionalAllocTestType &lhs, const NonOptionalAllocTestType &rhs)
bool	operator== (const NonTypicalOverloadsTestType &lhs, const NonTypicalOverloadsTestType &rhs)
bool	operator!= (const NonTypicalOverloadsTestType &lhs, const NonTypicalOverloadsTestType &rhs)
bool	operator== (const SimpleTestType &lhs, const SimpleTestType &rhs)
bool	operator!= (const SimpleTestType &lhs, const SimpleTestType &rhs)
template<class TYPE1 , class TYPE2 >
bool	operator== (const StdAllocatorAdaptor< TYPE1 > &lhs, const StdAllocatorAdaptor< TYPE2 > &rhs)
template<class TYPE1 , class TYPE2 >
bool	operator!= (const StdAllocatorAdaptor< TYPE1 > &lhs, const StdAllocatorAdaptor< TYPE2 > &rhs)
template<class ALLOC >
bool	operator== (const StdAllocTestType< ALLOC > &lhs, const StdAllocTestType< ALLOC > &rhs)
template<class ALLOC >
bool	operator!= (const StdAllocTestType< ALLOC > &lhs, const StdAllocTestType< ALLOC > &rhs)
template<class TYPE , bool PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, bool PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, bool PROPAGATE_ON_CONTAINER_SWAP, bool PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, bool IS_ALWAYS_EQUAL>
bool	operator== (const StdStatefulAllocator< TYPE, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL > &lhs, const StdStatefulAllocator< TYPE, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL > &rhs)
template<class TYPE , bool PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, bool PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, bool PROPAGATE_ON_CONTAINER_SWAP, bool PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, bool IS_ALWAYS_EQUAL>
bool	operator!= (const StdStatefulAllocator< TYPE, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL > &lhs, const StdStatefulAllocator< TYPE, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL > &rhs)
template<class TYPE1 , class TYPE2 >
bool	operator== (const StdTestAllocator< TYPE1 > &lhs, const StdTestAllocator< TYPE2 > &rhs)
template<class TYPE1 , class TYPE2 >
bool	operator!= (const StdTestAllocator< TYPE1 > &lhs, const StdTestAllocator< TYPE2 > &rhs)
template<class TYPE >
bsltf::MoveState::Enum	getMovedFrom (const TYPE &object)
template<class TYPE >
bsltf::MoveState::Enum	getMovedInto (const TYPE &object)
template<class TYPE >
void	setMovedInto (TYPE *object, bsltf::MoveState::Enum value)
void	debugprint (const AllocTestType &obj)
void	debugprint (const NonOptionalAllocTestType &obj)
void	debugprint (const AllocBitwiseMoveableTestType &obj)
void	debugprint (const AllocEmplacableTestType &obj)
void	debugprint (const BitwiseCopyableTestType &obj)
void	debugprint (const BitwiseMoveableTestType &obj)
void	debugprint (const EmplacableTestType &obj)
void	debugprint (const EnumeratedTestType::Enum &obj)
void	debugprint (const MovableAllocTestType &obj)
void	debugprint (const MovableTestType &obj)
void	debugprint (const MoveOnlyAllocTestType &obj)
void	debugprint (const NonTypicalOverloadsTestType &obj)
void	debugprint (const NonAssignableTestType &obj)
void	debugprint (const NonCopyConstructibleTestType &obj)
void	debugprint (const NonDefaultConstructibleTestType &obj)
void	debugprint (const NonEqualComparableTestType &obj)
void	debugprint (const SimpleTestType &obj)
template<class ALLOC >
void	debugprint (const StdAllocTestType< ALLOC > &obj)
void	debugprint (const UnionTestType &obj)
void	debugprint (const WellBehavedMoveOnlyAllocTestType &obj)
template<class VALUE >
bool	operator== (const TestValuesArrayIterator< VALUE > &lhs, const TestValuesArrayIterator< VALUE > &rhs)
template<class VALUE >
bool	operator!= (const TestValuesArrayIterator< VALUE > &lhs, const TestValuesArrayIterator< VALUE > &rhs)
bool	operator== (const UnionTestType &lhs, const UnionTestType &rhs)
bool	operator!= (const UnionTestType &lhs, const UnionTestType &rhs)
bool	operator== (const WellBehavedMoveOnlyAllocTestType &lhs, const WellBehavedMoveOnlyAllocTestType &rhs)
bool	operator!= (const WellBehavedMoveOnlyAllocTestType &lhs, const WellBehavedMoveOnlyAllocTestType &rhs)
MoveState::Enum	getMovedFrom (const WellBehavedMoveOnlyAllocTestType &object)
MoveState::Enum	getMovedInto (const WellBehavedMoveOnlyAllocTestType &object)
void	setMovedInto (WellBehavedMoveOnlyAllocTestType *object, MoveState::Enum value)
void	swap (WellBehavedMoveOnlyAllocTestType &a, WellBehavedMoveOnlyAllocTestType &b)

---

Function Documentation

template<int N>

MoveState::Enum bsltf::getMovedFrom

(

const AllocArgumentType< N > &

object

)

Return the move-from state of the specified object.

template<int N>

MoveState::Enum bsltf::getMovedInto

(

const AllocArgumentType< N > &

object

)

Return the move-into state of the specified object.

bool bsltf::operator==	(	const AllocBitwiseMoveableTestType &	lhs,
		const AllocBitwiseMoveableTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two AllocBitwiseMoveableTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const AllocBitwiseMoveableTestType &	lhs,
		const AllocBitwiseMoveableTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two AllocBitwiseMoveableTestType objects do not have the same value if their data attributes are not the same.

bool bsltf::operator==	(	const AllocEmplacableTestType &	lhs,
		const AllocEmplacableTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two AllocEmplacableTestType objects have the same value if each of their corresponding attributes have the same value.

bool bsltf::operator!=	(	const AllocEmplacableTestType &	lhs,
		const AllocEmplacableTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two AllocEmplacableTestType objects do not have the same value if any of their corresponding attributes do not have the same value.

bool bsltf::operator==	(	const AllocTestType &	lhs,
		const AllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two AllocTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const AllocTestType &	lhs,
		const AllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two AllocTestType objects do not have the same value if their data attributes are not the same.

template<int N>

MoveState::Enum bsltf::getMovedFrom

(

const ArgumentType< N > &

object

)

Return the move-from state of the specified object.

template<int N>

MoveState::Enum bsltf::getMovedInto

(

const ArgumentType< N > &

object

)

Return the move-into state of the specified object.

bool bsltf::operator==	(	const BitwiseCopyableTestType &	lhs,
		const BitwiseCopyableTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two BitwiseCopyableTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const BitwiseCopyableTestType &	lhs,
		const BitwiseCopyableTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two BitwiseCopyableTestType objects do not have the same value if their data attributes are not the same.

bool bsltf::operator==	(	const BitwiseMoveableTestType &	lhs,
		const BitwiseMoveableTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two BitwiseMoveableTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const BitwiseMoveableTestType &	lhs,
		const BitwiseMoveableTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two BitwiseMoveableTestType objects do not have the same value if their data attributes are not the same.

template<class FUNCTOR >

void bsltf::swap	(	DegenerateFunctor< FUNCTOR, true > &	lhs,
		DegenerateFunctor< FUNCTOR, true > &	rhs
	)

Exchange the values of the specified lhs and rhs objects.

bool bsltf::operator==	(	const EmplacableTestType &	lhs,
		const EmplacableTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two EmplacableTestType objects have the same value if each of their corresponding attributes have the same value.

bool bsltf::operator!=	(	const EmplacableTestType &	lhs,
		const EmplacableTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two EmplacableTestType objects do not have the same value if any of their corresponding attributes do not have the same value.

EvilBooleanType bsltf::operator==	(	const EvilBooleanType &	lhs,
		const EvilBooleanType &	rhs
	)

Return an EvilBoolanType value that converts to true if the specified lhs and rhs have the same value, and a value that converts to false otherwise. Two EvilBooleanType objects have the same value if the values resulting from converting each to bool have the same value.

EvilBooleanType bsltf::operator!=	(	const EvilBooleanType &	lhs,
		const EvilBooleanType &	rhs
	)

Return an EvilBoolanType value that converts to true if the specified lhs and rhs do not have the same value, and a value that converts to false otherwise. Two EvilBooleanType objects do not have the same value if the values resulting from converting each to bool do not have the same value.

template<class TYPE >

bool bsltf::operator==	(	const InputIterator< TYPE > &	lhs,
		const InputIterator< TYPE > &	rhs
	)			[inline]

Return true if the specified lhs and rhs refer to the same TYPE object and false othersise.

template<class TYPE >

bool bsltf::operator!=	(	const InputIterator< TYPE > &	lhs,
		const InputIterator< TYPE > &	rhs
	)			[inline]

Return true if the specified lhs and rhs do not refer to the same TYPE object and false othersise.

bool bsltf::operator==	(	const MovableAllocTestType &	lhs,
		const MovableAllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two MovableAllocTestType objects have the same if their data attributes are the same. TBD: think about the behavior when specified on an object that was moved-from on this as well as other functions/methods if appropriate.

bool bsltf::operator!=	(	const MovableAllocTestType &	lhs,
		const MovableAllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two MovableAllocTestType objects do not have the same value if their data attributes are not the same.

MoveState::Enum bsltf::getMovedFrom

(

const MovableAllocTestType &

object

)

Return the move-from state of the specified object.

MoveState::Enum bsltf::getMovedInto

(

const MovableAllocTestType &

object

)

Return the move-into state of the specified object.

void bsltf::setMovedInto	(	MovableAllocTestType *	object,
		MoveState::Enum	value
	)

Set the moved-into state of the specified object to the specified value.

bool bsltf::operator==	(	const MovableTestType &	lhs,
		const MovableTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same data() value, and false otherwise. Two MovableTestType objects have the same value if their data attributes are the same. TBD: think about the behavior when specified on an object that was moved-from on this as well as other functions/methods if appropriate.

bool bsltf::operator!=	(	const MovableTestType &	lhs,
		const MovableTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same data() value, and false otherwise. Two MovableTestType objects do not have the same value if their data attributes are not the same.

MoveState::Enum bsltf::getMovedFrom

(

const MovableTestType &

object

)

Return the move-from state of the specified object.

MoveState::Enum bsltf::getMovedInto

(

const MovableTestType &

object

)

Return the move-into state of the specified object.

void bsltf::setMovedInto	(	MovableTestType *	object,
		MoveState::Enum	value
	)

Set the moved-into state of the specified object to the specified value.

bool bsltf::operator==	(	const MoveOnlyAllocTestType &	lhs,
		const MoveOnlyAllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two MoveOnlyAllocTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const MoveOnlyAllocTestType &	lhs,
		const MoveOnlyAllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two MoveOnlyAllocTestType objects do not have the same value if their data attributes are not the same.

MoveState::Enum bsltf::getMovedFrom

(

const MoveOnlyAllocTestType &

object

)

Return the move-from state of the specified object.

MoveState::Enum bsltf::getMovedInto

(

const MoveOnlyAllocTestType &

object

)

Return the move-into state of the specified object.

void bsltf::setMovedInto	(	MoveOnlyAllocTestType *	object,
		MoveState::Enum	value
	)

Set the moved-into state of the specified object to the specified value.

void bsltf::swap	(	MoveOnlyAllocTestType &	a,
		MoveOnlyAllocTestType &	b
	)

Exchange the states of the specified a and b. Both a and b will be left in a moved-into state. No allocations shall occur (so no exceptions will be thrown) unless a and b have different allocators.

void bsltf::debugprint

(

const MoveState::Enum &

value

)

[inline]

Parameters:

value

Print the specified value as a string.

References bsltf::MoveState::toAscii().

bool bsltf::operator==	(	const NonAssignableTestType &	lhs,
		const NonAssignableTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two NonAssignableTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const NonAssignableTestType &	lhs,
		const NonAssignableTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two NonAssignableTestType objects do not have the same value if their data attributes are not the same.

bool bsltf::operator==	(	const NonCopyConstructibleTestType &	lhs,
		const NonCopyConstructibleTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two NonCopyConstructibleTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const NonCopyConstructibleTestType &	lhs,
		const NonCopyConstructibleTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two NonCopyConstructibleTestType objects do not have the same value if their data attributes are not the same.

bool bsltf::operator==	(	const NonDefaultConstructibleTestType &	lhs,
		const NonDefaultConstructibleTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two NonDefaultConstructibleTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const NonDefaultConstructibleTestType &	lhs,
		const NonDefaultConstructibleTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two NonDefaultConstructibleTestType objects do not have the same value if data attributes are not the same.

bool bsltf::operator==	(	const NonOptionalAllocTestType &	lhs,
		const NonOptionalAllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two NonOptionalAllocTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const NonOptionalAllocTestType &	lhs,
		const NonOptionalAllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two NonOptionalAllocTestType objects do not have the same value if their data attributes are not the same.

bool bsltf::operator==	(	const NonTypicalOverloadsTestType &	lhs,
		const NonTypicalOverloadsTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two NonTypicalOverloadsTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const NonTypicalOverloadsTestType &	lhs,
		const NonTypicalOverloadsTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two NonTypicalOverloadsTestType objects do not have the same value if their data attributes are not the same.

bool bsltf::operator==	(	const SimpleTestType &	lhs,
		const SimpleTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two SimpleTestType objects have the same value if their data attributes are the same.

bool bsltf::operator!=	(	const SimpleTestType &	lhs,
		const SimpleTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two SimpleTestType objects do not have the same value if their data attributes are not the same.

template<class TYPE1 , class TYPE2 >

bool bsltf::operator==	(	const StdAllocatorAdaptor< TYPE1 > &	lhs,
		const StdAllocatorAdaptor< TYPE2 > &	rhs
	)

Return true if the specified lhs and rhs adaptors are equal and false otherwise. Two allocator adaptor instances are equal if their associated allocator instances are equal.

template<class TYPE1 , class TYPE2 >

bool bsltf::operator!=	(	const StdAllocatorAdaptor< TYPE1 > &	lhs,
		const StdAllocatorAdaptor< TYPE2 > &	rhs
	)

Return true if the specified lhs and rhs adaptors are not equal and false otherwise. Two allocator adaptor instances are not equal if their associated allocator instances are not equal.

template<class ALLOC >

bool bsltf::operator==	(	const StdAllocTestType< ALLOC > &	lhs,
		const StdAllocTestType< ALLOC > &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two AllocTestType objects have the same if their data attributes are the same.

template<class ALLOC >

bool bsltf::operator!=	(	const StdAllocTestType< ALLOC > &	lhs,
		const StdAllocTestType< ALLOC > &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two AllocTestType objects do not have the same value if their data attributes are not the same.

template<class TYPE , bool PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, bool PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, bool PROPAGATE_ON_CONTAINER_SWAP, bool PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, bool IS_ALWAYS_EQUAL>

bool bsltf::operator==	(	const StdStatefulAllocator< TYPE, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL > &	lhs,
		const StdStatefulAllocator< TYPE, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL > &	rhs
	)

Return true if the specified lhs and rhs have the same underlying test allocator, and false otherwise.

template<class TYPE , bool PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, bool PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, bool PROPAGATE_ON_CONTAINER_SWAP, bool PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, bool IS_ALWAYS_EQUAL>

bool bsltf::operator!=	(	const StdStatefulAllocator< TYPE, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL > &	lhs,
		const StdStatefulAllocator< TYPE, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL > &	rhs
	)

Return true if the specified lhs and rhs have different underlying test allocators, and false otherwise.

template<class TYPE1 , class TYPE2 >

bool bsltf::operator==	(	const StdTestAllocator< TYPE1 > &	lhs,
		const StdTestAllocator< TYPE2 > &	rhs
	)

Return true because StdTestAllocator does not hold a state.

template<class TYPE1 , class TYPE2 >

bool bsltf::operator!=	(	const StdTestAllocator< TYPE1 > &	lhs,
		const StdTestAllocator< TYPE2 > &	rhs
	)

Return false because StdTestAllocator does not hold a state.

template<class TYPE >

bsltf::MoveState::Enum bsltf::getMovedFrom

(

const TYPE &

object

)

Return the moved-from state of the specified 'object if the (template parameter) TYPE supports such as query. The default implementation provided in this component returns e_UNKNOWN; test types will presumably provide an specialized version of this function.

template<class TYPE >

bsltf::MoveState::Enum bsltf::getMovedInto

(

const TYPE &

object

)

Return the moved-into state of the specified 'object if the (template parameter) TYPE supports such as query. The default implementation provided in this component returns e_UNKNOWN; test types will presumably provide an specialized version of this function.

template<class TYPE >

void bsltf::setMovedInto	(	TYPE *	object,
		bsltf::MoveState::Enum	value
	)

Set the moved-into state of the specified 'object to the specified value if the (template parameter) TYPE supports such move states. The default implementation provided in this component does nothing; test types will presumably provide an specialized version of this function.

void bsltf::debugprint

(

const AllocTestType &

obj

)

void bsltf::debugprint

(

const NonOptionalAllocTestType &

obj

)

void bsltf::debugprint

(

const AllocBitwiseMoveableTestType &

obj

)

void bsltf::debugprint

(

const AllocEmplacableTestType &

obj

)

void bsltf::debugprint

(

const BitwiseCopyableTestType &

obj

)

void bsltf::debugprint

(

const BitwiseMoveableTestType &

obj

)

void bsltf::debugprint

(

const EmplacableTestType &

obj

)

void bsltf::debugprint

(

const EnumeratedTestType::Enum &

obj

)

void bsltf::debugprint

(

const MovableAllocTestType &

obj

)

void bsltf::debugprint

(

const MovableTestType &

obj

)

void bsltf::debugprint

(

const MoveOnlyAllocTestType &

obj

)

void bsltf::debugprint

(

const NonTypicalOverloadsTestType &

obj

)

void bsltf::debugprint

(

const NonAssignableTestType &

obj

)

void bsltf::debugprint

(

const NonCopyConstructibleTestType &

obj

)

void bsltf::debugprint

(

const NonDefaultConstructibleTestType &

obj

)

void bsltf::debugprint

(

const NonEqualComparableTestType &

obj

)

void bsltf::debugprint

(

const SimpleTestType &

obj

)

template<class ALLOC >

void bsltf::debugprint

(

const StdAllocTestType< ALLOC > &

obj

)

void bsltf::debugprint

(

const UnionTestType &

obj

)

void bsltf::debugprint

(

const WellBehavedMoveOnlyAllocTestType &

obj

)

Print the value of the specified obj to the console. Note that this free function is provided to allow bsls_bsltestutil to support these types intended for testing. See the component-level documentation for bsls_bsltestutil for more details.

template<class VALUE >

bool bsltf::operator==	(	const TestValuesArrayIterator< VALUE > &	lhs,
		const TestValuesArrayIterator< VALUE > &	rhs
	)

Return true if the specified lhs and the specified rhs refer to the same element, and false otherwise. The behavior is undefined unless lhs and rhs are comparable.

template<class VALUE >

bool bsltf::operator!=	(	const TestValuesArrayIterator< VALUE > &	lhs,
		const TestValuesArrayIterator< VALUE > &	rhs
	)

Return true if the specified lhs and the specified rhs do not refer to the same element, and false otherwise. The behavior is undefined unless lhs and rhs are comparable.

bool bsltf::operator==	(	const UnionTestType &	lhs,
		const UnionTestType &	rhs
	)

Return true if the specified lhs and rhs unions have the same value, and false otherwise. Two UnionTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const UnionTestType &	lhs,
		const UnionTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two UnionTestType objects do not have the same value if their data attributes are not the same.

bool bsltf::operator==	(	const WellBehavedMoveOnlyAllocTestType &	lhs,
		const WellBehavedMoveOnlyAllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two WellBehavedMoveOnlyAllocTestType objects have the same if their data attributes are the same.

bool bsltf::operator!=	(	const WellBehavedMoveOnlyAllocTestType &	lhs,
		const WellBehavedMoveOnlyAllocTestType &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two WellBehavedMoveOnlyAllocTestType objects do not have the same value if their data attributes are not the same.

MoveState::Enum bsltf::getMovedFrom

(

const WellBehavedMoveOnlyAllocTestType &

object

)

Return the move-from state of the specified object.

MoveState::Enum bsltf::getMovedInto

(

const WellBehavedMoveOnlyAllocTestType &

object

)

Return the move-into state of the specified object.

void bsltf::setMovedInto	(	WellBehavedMoveOnlyAllocTestType *	object,
		MoveState::Enum	value
	)

Set the moved-into state of the specified object to the specified value.

void bsltf::swap	(	WellBehavedMoveOnlyAllocTestType &	a,
		WellBehavedMoveOnlyAllocTestType &	b
	)

Exchange the states of the specified a and b. If the allocators match, both a and b will be left in a moved-into state, otherwise, both will not. If a and b are the same object, this function will have no effect. No allocations shall occur (so no exceptions will be thrown) unless a and b have different allocators.