bsltf Namespace Reference

Classes
class	AllocArgumentType
class	AllocBitwiseMoveableTestType
class	AllocEmplacableTestType
class	AllocTestType
class	ArgumentType
class	ArgumentTypeByValue
struct	ArgumentTypeDefault
class	BitwiseCopyableTestType
class	BitwiseMoveableTestType
struct	ConvertibleValueWrapper
struct	CopyMoveState
class	CopyMoveTracker
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
class	StdTestAllocator
class	StdTestAllocator< void >
struct	StdTestAllocator_CommonUtil
struct	StdTestAllocatorConfiguration
class	StdTestAllocatorConfigurationGuard
struct	TemplateTestFacility
class	TemplateTestFacility_CompareHelper
class	TemplateTestFacility_StubClass
class	TestValuesArray
struct	TestValuesArray_DefaultConverter
class	TestValuesArray_PostIncrementPtr
class	TestValuesArrayIterator
union	UnionTestType
class	WellBehavedMoveOnlyAllocTestType

Functions
template<int N>
MoveState::Enum	getMovedFrom (const AllocArgumentType< N > &object)
	Return the move-from state of the specified object.
template<int N>
MoveState::Enum	getMovedInto (const AllocArgumentType< N > &object)
	Return the move-into state of the specified 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>
void	debugprint (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)
bool	operator! (CopyMoveState::Enum value)
	Return true if value is e_ORIGINAL; otherwise return false.
bool	operator== (CopyMoveState::Enum a, int b)
bool	operator== (int a, CopyMoveState::Enum b)
bool	operator!= (CopyMoveState::Enum a, int b)
bool	operator!= (int a, CopyMoveState::Enum b)
CopyMoveState::Enum	copyMoveState (bslmf::MatchAnyType)
void	setCopyMoveState (void *, CopyMoveState::Enum)
void	debugprint (const CopyMoveState::Enum &value)
template<class FUNCTOR >
void	swap (DegenerateFunctor< FUNCTOR, true > &lhs, DegenerateFunctor< FUNCTOR, true > &rhs)
	Exchange the values of the specified lhs and rhs objects.
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)
bool	operator== (const MovableTestType &lhs, const MovableTestType &rhs)
bool	operator!= (const MovableTestType &lhs, const MovableTestType &rhs)
MoveState::Enum	getMovedFrom (const MovableTestType &object)
	Return the move-from state of the specified object.
MoveState::Enum	getMovedInto (const MovableTestType &object)
	Return the move-into state of the specified 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)
	Return the move-from state of the specified object.
MoveState::Enum	getMovedInto (const MoveOnlyAllocTestType &object)
	Return the move-into state of the specified object.
void	setMovedInto (MoveOnlyAllocTestType *object, MoveState::Enum value)
void	swap (MoveOnlyAllocTestType &a, MoveOnlyAllocTestType &b)
void	debugprint (const MoveState::Enum &value)
	Print the specified value as a string.
template<class TYPE >
MoveState::Enum	getMovedFrom (const TYPE &object)
template<class TYPE >
MoveState::Enum	getMovedInto (const TYPE &object)
template<class TYPE >
void	setMovedInto (TYPE *object, 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 TYPE1 , class TYPE2 , 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< TYPE1, 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< TYPE2, 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 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< TYPE1, 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< TYPE2, 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)
	Return true because StdTestAllocator does not hold a state.
template<class TYPE1 , class TYPE2 >
bool	operator!= (const StdTestAllocator< TYPE1 > &lhs, const StdTestAllocator< TYPE2 > &rhs)
	Return false because StdTestAllocator does not hold a state.
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const TemplateTestFacility::MethodPtr &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const AllocBitwiseMoveableTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const AllocEmplacableTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const AllocTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const BitwiseCopyableTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const BitwiseMoveableTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const EmplacableTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const EnumeratedTestType::Enum &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const MovableAllocTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const MovableTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const MoveOnlyAllocTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const NonAssignableTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const NonCopyConstructibleTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const NonDefaultConstructibleTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const NonEqualComparableTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const NonOptionalAllocTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const NonTypicalOverloadsTestType &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const SimpleTestType &object)
template<class STREAM , class ALLOC >
STREAM &	operator<< (STREAM &stream, const StdAllocTestType< ALLOC > &object)
template<class STREAM >
STREAM &	operator<< (STREAM &stream, const UnionTestType &object)
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<>
int	TemplateTestFacility::getIdentifier< bsltf::TemplateTestFacility::MethodPtr > (const bsltf::TemplateTestFacility::MethodPtr &ptr)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::UnionTestType > (const bsltf::UnionTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::SimpleTestType > (const bsltf::SimpleTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::AllocTestType > (const bsltf::AllocTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::NonOptionalAllocTestType > (const bsltf::NonOptionalAllocTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::MovableAllocTestType > (const bsltf::MovableAllocTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::MovableTestType > (const bsltf::MovableTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::MoveOnlyAllocTestType > (const bsltf::MoveOnlyAllocTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::BitwiseCopyableTestType > (const bsltf::BitwiseCopyableTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::BitwiseMoveableTestType > (const bsltf::BitwiseMoveableTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::AllocBitwiseMoveableTestType > (const bsltf::AllocBitwiseMoveableTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::NonTypicalOverloadsTestType > (const bsltf::NonTypicalOverloadsTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::NonAssignableTestType > (const bsltf::NonAssignableTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::NonCopyConstructibleTestType > (const bsltf::NonCopyConstructibleTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::NonDefaultConstructibleTestType > (const bsltf::NonDefaultConstructibleTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::NonEqualComparableTestType > (const bsltf::NonEqualComparableTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::EmplacableTestType > (const bsltf::EmplacableTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::AllocEmplacableTestType > (const bsltf::AllocEmplacableTestType &object)
template<>
int	TemplateTestFacility::getIdentifier< bsltf::WellBehavedMoveOnlyAllocTestType > (const bsltf::WellBehavedMoveOnlyAllocTestType &object)
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)
	Return the move-from state of the specified object.
MoveState::Enum	getMovedInto (const WellBehavedMoveOnlyAllocTestType &object)
	Return the move-into state of the specified object.
void	setMovedInto (WellBehavedMoveOnlyAllocTestType *object, MoveState::Enum value)
void	swap (WellBehavedMoveOnlyAllocTestType &a, WellBehavedMoveOnlyAllocTestType &b)

Detailed Description

Usage

Function Documentation

copyMoveState()

CopyMoveState::Enum bsltf::copyMoveState ( bslmf::MatchAnyType  )

inline

Return e_UNKWOWN. Called from CopyMoveState::get, this default implementation is called if a customized copyMoveState is not found via ADL for a specific type. Note that this overload is defined such that, if copyMoveState is customized for a type, the customization is "inherited" by derived types.

debugprint() [1/23]

void bsltf::debugprint ( const AllocBitwiseMoveableTestType &  obj )

inline

debugprint() [2/23]

void bsltf::debugprint ( const AllocEmplacableTestType &  obj )

inline

debugprint() [3/23]

void bsltf::debugprint ( const AllocTestType &  obj )

inline

debugprint() [4/23]

template<int N>

void bsltf::debugprint ( const ArgumentType< N > &  object )

inline

Print the specified value as a string. This is an ADL customization point.

debugprint() [5/23]

void bsltf::debugprint ( const BitwiseCopyableTestType &  obj )

inline

debugprint() [6/23]

void bsltf::debugprint ( const BitwiseMoveableTestType &  obj )

inline

debugprint() [7/23]

void bsltf::debugprint

(

const CopyMoveState::Enum &

value

)

Print the specified value as a string. This is an ADL customization point.

debugprint() [8/23]

void bsltf::debugprint ( const EmplacableTestType &  obj )

inline

debugprint() [9/23]

void bsltf::debugprint ( const EnumeratedTestType::Enum &  obj )

inline

debugprint() [10/23]

void bsltf::debugprint ( const MovableAllocTestType &  obj )

inline

debugprint() [11/23]

void bsltf::debugprint ( const MovableTestType &  obj )

inline

debugprint() [12/23]

void bsltf::debugprint ( const MoveOnlyAllocTestType &  obj )

inline

debugprint() [13/23]

void bsltf::debugprint

(

const MoveState::Enum &

value

)

debugprint() [14/23]

void bsltf::debugprint ( const NonAssignableTestType &  obj )

inline

debugprint() [15/23]

void bsltf::debugprint ( const NonCopyConstructibleTestType &  obj )

inline

debugprint() [16/23]

void bsltf::debugprint ( const NonDefaultConstructibleTestType &  obj )

inline

debugprint() [17/23]

void bsltf::debugprint ( const NonEqualComparableTestType &  obj )

inline

debugprint() [18/23]

void bsltf::debugprint ( const NonOptionalAllocTestType &  obj )

inline

debugprint() [19/23]

void bsltf::debugprint ( const NonTypicalOverloadsTestType &  obj )

inline

debugprint() [20/23]

void bsltf::debugprint ( const SimpleTestType &  obj )

inline

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.

debugprint() [21/23]

template<class ALLOC >

void bsltf::debugprint ( const StdAllocTestType< ALLOC > &  obj )

inline

debugprint() [22/23]

void bsltf::debugprint ( const UnionTestType &  obj )

inline

debugprint() [23/23]

void bsltf::debugprint ( const WellBehavedMoveOnlyAllocTestType &  obj )

inline

getMovedFrom() [1/5]

template<int N>

MoveState::Enum bsltf::getMovedFrom ( const AllocArgumentType< N > &  object )

inline

getMovedFrom() [2/5]

MoveState::Enum bsltf::getMovedFrom ( const MovableTestType &  object )

inline

getMovedFrom() [3/5]

MoveState::Enum bsltf::getMovedFrom ( const MoveOnlyAllocTestType &  object )

inline

getMovedFrom() [4/5]

template<class TYPE >

MoveState::Enum bsltf::getMovedFrom

(

const TYPE &

object

)

Return the moved-from state of the specified object of (template parameter) TYPE. The default implementation of this ADL customization point calls CopyMoveState::get and translates the result into the correpsonding MoveState::Enum (which has been deprecated). Note that a customization of this function for a specific type will not be "inherited" by derived classes of that type; new types should customize copyMoveState, not getMovedFrom.

Deprecated:

Use CopyMoveState::isMovedFrom` or `CopyMoveState::get.

getMovedFrom() [5/5]

MoveState::Enum bsltf::getMovedFrom ( const WellBehavedMoveOnlyAllocTestType &  object )

inline

getMovedInto() [1/5]

template<int N>

MoveState::Enum bsltf::getMovedInto ( const AllocArgumentType< N > &  object )

inline

getMovedInto() [2/5]

MoveState::Enum bsltf::getMovedInto ( const MovableTestType &  object )

inline

getMovedInto() [3/5]

MoveState::Enum bsltf::getMovedInto ( const MoveOnlyAllocTestType &  object )

inline

getMovedInto() [4/5]

template<class TYPE >

MoveState::Enum bsltf::getMovedInto

(

const TYPE &

object

)

Return the moved-from state of the specified object of (template parameter) TYPE. The default implementation of this ADL customization point calls CopyMoveState::get and translates the result into the correpsonding MoveState::Enum. Note that a customization of this function for a specific type will not be "inherited" by derived classes of that type; new types should customize copyMoveState, not getMovedInto.

Deprecated:

Use CopyMoveState::isMovedInto` or `CopyMoveState::get.

getMovedInto() [5/5]

MoveState::Enum bsltf::getMovedInto ( const WellBehavedMoveOnlyAllocTestType &  object )

inline

operator!()

bool bsltf::operator!

(

CopyMoveState::Enum

value

)

operator!=() [1/26]

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.

operator!=() [2/26]

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

inline

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.

operator!=() [3/26]

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.

operator!=() [4/26]

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.

operator!=() [5/26]

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.

operator!=() [6/26]

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

inline

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.

operator!=() [7/26]

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.

operator!=() [8/26]

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.

operator!=() [9/26]

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.

operator!=() [10/26]

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.

operator!=() [11/26]

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.

operator!=() [12/26]

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

inline

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.

operator!=() [13/26]

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

inline

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.

operator!=() [14/26]

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

inline

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.

operator!=() [15/26]

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.

operator!=() [16/26]

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

inline

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.

operator!=() [17/26]

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

inline

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.

operator!=() [18/26]

template<class TYPE1 , class TYPE2 >

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

inline

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.

operator!=() [19/26]

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.

operator!=() [20/26]

template<class TYPE1 , class TYPE2 , 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< TYPE1, 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< TYPE2, 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.

operator!=() [21/26]

template<class TYPE1 , class TYPE2 >

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

inline

operator!=() [22/26]

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.

operator!=() [23/26]

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

inline

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.

operator!=() [24/26]

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.

operator!=() [25/26]

bool bsltf::operator!=	(	CopyMoveState::Enum	a,
		int	b
	)

Return true if the integral values of the specified a and b do not compare equal; otherwise return false.

operator!=() [26/26]

bool bsltf::operator!=	(	int	a,
		CopyMoveState::Enum	b
	)

operator<<() [1/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const AllocBitwiseMoveableTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [2/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const AllocEmplacableTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [3/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const AllocTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [4/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const BitwiseCopyableTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [5/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const BitwiseMoveableTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [6/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const EmplacableTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [7/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const EnumeratedTestType::Enum &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [8/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const MovableAllocTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [9/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const MovableTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [10/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const MoveOnlyAllocTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [11/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const NonAssignableTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [12/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const NonCopyConstructibleTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [13/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const NonDefaultConstructibleTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [14/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const NonEqualComparableTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [15/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const NonOptionalAllocTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [16/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const NonTypicalOverloadsTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [17/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const SimpleTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [18/20]

template<class STREAM , class ALLOC >

STREAM & bsltf::operator<< ( STREAM &  stream, const StdAllocTestType< ALLOC > &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [19/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const TemplateTestFacility::MethodPtr &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator<<() [20/20]

template<class STREAM >

STREAM & bsltf::operator<< ( STREAM &  stream, const UnionTestType &  object  )

inline

Stream the integer representing the value of the specified object to the specified stream. Return stream.

operator==() [1/26]

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.

operator==() [2/26]

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

inline

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.

operator==() [3/26]

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.

operator==() [4/26]

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.

operator==() [5/26]

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.

operator==() [6/26]

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

inline

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.

operator==() [7/26]

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.

operator==() [8/26]

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.

operator==() [9/26]

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.

operator==() [10/26]

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.

operator==() [11/26]

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.

operator==() [12/26]

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

inline

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.

operator==() [13/26]

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

inline

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.

operator==() [14/26]

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

inline

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.

operator==() [15/26]

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.

operator==() [16/26]

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

inline

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.

operator==() [17/26]

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

inline

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.

operator==() [18/26]

template<class TYPE1 , class TYPE2 >

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

inline

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.

operator==() [19/26]

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.

operator==() [20/26]

template<class TYPE1 , class TYPE2 , 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< TYPE1, 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< TYPE2, 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.

operator==() [21/26]

template<class TYPE1 , class TYPE2 >

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

inline

operator==() [22/26]

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.

operator==() [23/26]

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

inline

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.

operator==() [24/26]

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.

operator==() [25/26]

bool bsltf::operator==	(	CopyMoveState::Enum	a,
		int	b
	)

Return true if the integral values of the specified a and b compare equal; otherwise return false.

operator==() [26/26]

bool bsltf::operator==	(	int	a,
		CopyMoveState::Enum	b
	)

setCopyMoveState()

void bsltf::setCopyMoveState	(	void *	,
		CopyMoveState::Enum
	)

Do nothing. Called from CopyMoveState::set, this default implementation is called if a customized getCopyMoveState is not found via ADL for a specific type. Note that this overload is defined such that, if setCopyMoveState is customized for a type, the customization is "inherited" by derived types.

setMovedInto() [1/4]

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

inline

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

setMovedInto() [2/4]

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

inline

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

setMovedInto() [3/4]

template<class TYPE >

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

Set the moved-into state of the specified object to the specified value. The default implementation of this ADL customization point calls CopyMoveState::set and translates value into the correpsonding CopyMoveState::Enum. Note that a customization of this function for a specific type will not be "inherited" by derived classes of that type; new types should customize setCopyMoveState, not setMovedInto.

Deprecated:

Use CopyMoveState::set instead.

setMovedInto() [4/4]

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

inline

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

swap() [1/3]

template<class FUNCTOR >

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

swap() [2/3]

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.

swap() [3/3]

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.

TemplateTestFacility::getIdentifier< bsltf::AllocBitwiseMoveableTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::AllocBitwiseMoveableTestType > ( const bsltf::AllocBitwiseMoveableTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::AllocEmplacableTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::AllocEmplacableTestType > ( const bsltf::AllocEmplacableTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::AllocTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::AllocTestType > ( const bsltf::AllocTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::BitwiseCopyableTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::BitwiseCopyableTestType > ( const bsltf::BitwiseCopyableTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::BitwiseMoveableTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::BitwiseMoveableTestType > ( const bsltf::BitwiseMoveableTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::EmplacableTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::EmplacableTestType > ( const bsltf::EmplacableTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::MovableAllocTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::MovableAllocTestType > ( const bsltf::MovableAllocTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::MovableTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::MovableTestType > ( const bsltf::MovableTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::MoveOnlyAllocTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::MoveOnlyAllocTestType > ( const bsltf::MoveOnlyAllocTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::NonAssignableTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::NonAssignableTestType > ( const bsltf::NonAssignableTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::NonCopyConstructibleTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::NonCopyConstructibleTestType > ( const bsltf::NonCopyConstructibleTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::NonDefaultConstructibleTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::NonDefaultConstructibleTestType > ( const bsltf::NonDefaultConstructibleTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::NonEqualComparableTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::NonEqualComparableTestType > ( const bsltf::NonEqualComparableTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::NonOptionalAllocTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::NonOptionalAllocTestType > ( const bsltf::NonOptionalAllocTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::NonTypicalOverloadsTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::NonTypicalOverloadsTestType > ( const bsltf::NonTypicalOverloadsTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::SimpleTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::SimpleTestType > ( const bsltf::SimpleTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::TemplateTestFacility::MethodPtr >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::TemplateTestFacility::MethodPtr > ( const bsltf::TemplateTestFacility::MethodPtr &  ptr )

inline

TemplateTestFacility::getIdentifier< bsltf::UnionTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::UnionTestType > ( const bsltf::UnionTestType &  object )

inline

TemplateTestFacility::getIdentifier< bsltf::WellBehavedMoveOnlyAllocTestType >()

template<>

int bsltf::TemplateTestFacility::getIdentifier< bsltf::WellBehavedMoveOnlyAllocTestType > ( const bsltf::WellBehavedMoveOnlyAllocTestType &  object )

inline