ball Namespace Reference [Component ball_administration, Component ball_asyncfileobserver, Component ball_attribute, Component ball_attributecollectorregistry, Component ball_attributecontainer, Component ball_attributecontainerlist, Component ball_attributecontext, Component ball_broadcastobserver, Component ball_category, Component ball_categorymanager, Component ball_context, Component ball_countingallocator, Component ball_defaultattributecontainer, Component ball_fileobserver, Component ball_fileobserver2, Component ball_filteringobserver, Component ball_fixedsizerecordbuffer, Component ball_log, Component ball_logfilecleanerutil, Component ball_loggercategoryutil, Component ball_loggerfunctorpayloads, Component ball_loggermanager, Component ball_loggermanagerconfiguration, Component ball_loggermanagerdefaults, Component ball_managedattribute, Component ball_managedattributeset, Component ball_multiplexobserver, Component ball_observer, Component ball_observeradapter, Component ball_patternutil, Component ball_predicate, Component ball_predicateset, Component ball_record, Component ball_recordattributes, Component ball_recordbuffer, Component ball_recordjsonformatter, Component ball_recordstringformatter, Component ball_rule, Component ball_ruleset, Component ball_scopedattribute, Component ball_scopedattributes, Component ball_severity, Component ball_severityutil, Component ball_streamobserver, Component ball_testobserver, Component ball_thresholdaggregate, Component ball_transmission, Component ball_userfields, Component ball_userfieldtype, Component ball_userfieldvalue]

Classes
struct	Administration
struct	AsyncFileObserver_Record
class	AsyncFileObserver
class	Attribute
class	AttributeCollectorRegistry
class	AttributeContainer
class	AttributeContainerListIterator
class	AttributeContainerList
struct	AttributeContainerList_Node
class	AttributeContext_RuleEvaluationCache
class	AttributeContext
class	AttributeContextProctor
class	BroadcastObserver
class	Category
class	CategoryHolder
class	CategoryManagerImpUtil
class	CategoryManager
class	CategoryManagerIter
class	CategoryManagerManip
class	Context
class	CountingAllocator
class	DefaultAttributeContainer
class	FileObserver
class	FileObserver2
class	FilteringObserver
class	FixedSizeRecordBuffer
struct	Log
class	Log_Stream
class	Log_Formatter
struct	LogFileCleanerUtil
struct	LoggerCategoryUtil
struct	LoggerFunctorPayloads
class	Logger
class	LoggerManager
class	LoggerManagerScopedGuard
class	LoggerManagerCategoryIter
class	LoggerManagerCategoryManip
class	LoggerManagerConfiguration
class	LoggerManagerDefaults
class	ManagedAttribute
class	ManagedAttributeSet
class	MultiplexObserver
class	Observer
class	ObserverAdapter
struct	PatternUtil
class	Record
class	RecordAttributes
class	RecordBuffer
class	RecordJsonFormatter
class	RecordStringFormatter
class	Rule
class	RuleSet
class	ScopedAttribute_Container
class	ScopedAttribute
class	ScopedAttributes
struct	Severity
struct	SeverityUtil
class	StreamObserver
class	TestObserver
class	ThresholdAggregate
struct	Transmission
class	UserFields
struct	UserFieldType
class	UserFieldValue
Typedefs
typedef ManagedAttribute	Predicate
typedef ManagedAttributeSet	PredicateSet
Functions
bool	operator== (const Attribute &lhs, const Attribute &rhs)
bool	operator!= (const Attribute &lhs, const Attribute &rhs)
bsl::ostream &	operator<< (bsl::ostream &output, const Attribute &attribute)
bsl::ostream &	operator<< (bsl::ostream &stream, const AttributeContainer &container)
bool	operator== (const AttributeContainerListIterator &lhs, const AttributeContainerListIterator &rhs)
bool	operator!= (const AttributeContainerListIterator &lhs, const AttributeContainerListIterator &rhs)
bool	operator== (const AttributeContainerList &lhs, const AttributeContainerList &rhs)
bool	operator!= (const AttributeContainerList &lhs, const AttributeContainerList &rhs)
bsl::ostream &	operator<< (bsl::ostream &output, const AttributeContainerList &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const AttributeContext_RuleEvaluationCache &cache)
bsl::ostream &	operator<< (bsl::ostream &stream, const AttributeContext &context)
bool	operator== (const Context &lhs, const Context &rhs)
bool	operator!= (const Context &lhs, const Context &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const Context &rhs)
bool	operator== (const DefaultAttributeContainer &lhs, const DefaultAttributeContainer &rhs)
bool	operator!= (const DefaultAttributeContainer &lhs, const DefaultAttributeContainer &rhs)
bsl::ostream &	operator<< (bsl::ostream &output, const DefaultAttributeContainer &attributeContainer)
const BloombergLP::ball::CategoryHolder *	ball_log_getCategoryHolder (const BloombergLP::ball::CategoryHolder &categoryHolder)
bool	operator== (const LoggerManagerConfiguration &lhs, const LoggerManagerConfiguration &rhs)
bool	operator!= (const LoggerManagerConfiguration &lhs, const LoggerManagerConfiguration &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const LoggerManagerConfiguration &configuration)
bool	operator== (const LoggerManagerDefaults &lhs, const LoggerManagerDefaults &rhs)
bool	operator!= (const LoggerManagerDefaults &lhs, const LoggerManagerDefaults &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const LoggerManagerDefaults &defaults)
bool	operator== (const ManagedAttribute &lhs, const ManagedAttribute &rhs)
bool	operator== (const ManagedAttribute &lhs, const Attribute &rhs)
bool	operator== (const Attribute &lhs, const ManagedAttribute &rhs)
bool	operator!= (const ManagedAttribute &lhs, const ManagedAttribute &rhs)
bool	operator!= (const ManagedAttribute &lhs, const Attribute &rhs)
bool	operator!= (const Attribute &lhs, const ManagedAttribute &rhs)
bsl::ostream &	operator<< (bsl::ostream &output, const ManagedAttribute &attribute)
bool	operator== (const ManagedAttributeSet &lhs, const ManagedAttributeSet &rhs)
bool	operator!= (const ManagedAttributeSet &lhs, const ManagedAttributeSet &rhs)
bsl::ostream &	operator<< (bsl::ostream &output, const ManagedAttributeSet &attributeSet)
bool	operator== (const Record &lhs, const Record &rhs)
bool	operator!= (const Record &lhs, const Record &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const Record &record)
bool	operator== (const RecordAttributes &lhs, const RecordAttributes &rhs)
bool	operator!= (const RecordAttributes &lhs, const RecordAttributes &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const RecordAttributes &object)
bool	operator== (const RecordJsonFormatter &lhs, const RecordJsonFormatter &rhs)
bool	operator!= (const RecordJsonFormatter &lhs, const RecordJsonFormatter &rhs)
bool	operator== (const RecordStringFormatter &lhs, const RecordStringFormatter &rhs)
bool	operator!= (const RecordStringFormatter &lhs, const RecordStringFormatter &rhs)
bsl::ostream &	operator<< (bsl::ostream &output, const RecordStringFormatter &rhs)
bool	operator== (const Rule &lhs, const Rule &rhs)
bool	operator!= (const Rule &lhs, const Rule &rhs)
bsl::ostream &	operator<< (bsl::ostream &output, const Rule &rule)
bool	operator== (const RuleSet &lhs, const RuleSet &rhs)
bool	operator!= (const RuleSet &lhs, const RuleSet &rhs)
bsl::ostream &	operator<< (bsl::ostream &output, const RuleSet &rules)
bsl::ostream &	operator<< (bsl::ostream &stream, Severity::Level rhs)
bool	operator== (const ThresholdAggregate &lhs, const ThresholdAggregate &rhs)
bool	operator!= (const ThresholdAggregate &lhs, const ThresholdAggregate &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const ThresholdAggregate &aggregate)
bsl::ostream &	operator<< (bsl::ostream &stream, Transmission::Cause rhs)
bool	operator== (const UserFields &lhs, const UserFields &rhs)
bool	operator!= (const UserFields &lhs, const UserFields &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const UserFields &object)
void	swap (ball::UserFields &a, ball::UserFields &b)
bsl::ostream &	operator<< (bsl::ostream &stream, UserFieldType::Enum value)
bool	operator== (const UserFieldValue &lhs, const UserFieldValue &rhs)
bool	operator!= (const UserFieldValue &lhs, const UserFieldValue &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const UserFieldValue &object)
void	swap (ball::UserFieldValue &a, ball::UserFieldValue &b)

---

Typedef Documentation

typedef ManagedAttribute ball::Predicate

typedef ManagedAttributeSet ball::PredicateSet

---

Function Documentation

bool ball::operator==	(	const Attribute &	lhs,
		const Attribute &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two Attribute objects have the same value if they have the same name (but not necessarily the identical representation in memory), the same attribute value type, and the same attribute value.

bool ball::operator!=	(	const Attribute &	lhs,
		const Attribute &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two Attribute objects do not have the same value if any of their respective names (value, not address), attribute value types, or attribute values differ.

bsl::ostream& ball::operator<<	(	bsl::ostream &	output,
		const Attribute &	attribute
	)

Write the value of the specified attribute to the specified output stream. Return the specified output stream.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const AttributeContainer &	container
	)

Write the value of the specified container to the specified output stream in a single-line format, and return a reference to the modifiable stream.

bool ball::operator==	(	const AttributeContainerListIterator &	lhs,
		const AttributeContainerListIterator &	rhs
	)

Return true if the specified lhs and the specified rhs iterators have the same value and false otherwise. Two iterators have the same value if they refer to the same position in the same list, or if both iterators are at an invalid position in the list (i.e., the "end" of the list, or the default constructed value).

bool ball::operator!=	(	const AttributeContainerListIterator &	lhs,
		const AttributeContainerListIterator &	rhs
	)

Return true if the specified lhs and the specified rhs iterators do not have the same value and false otherwise. Two iterators do not have the same value if they differ in either the list to which they refer or the position in the list object.

bool ball::operator==	(	const AttributeContainerList &	lhs,
		const AttributeContainerList &	rhs
	)

Return true if the specified lhs and rhs lists have the same value, and false otherwise. Two lists have the same value if they have the same number of attribute container addresses, and the address at each index position have the same value.

bool ball::operator!=	(	const AttributeContainerList &	lhs,
		const AttributeContainerList &	rhs
	)			[inline]

Return true if the specified lhs and rhs lists do not have the same value, and false otherwise. Two lists do not have the same value if have differing numbers of attribute container addresses or any of the addresses at corresponding indices have different values.

bsl::ostream& ball::operator<<	(	bsl::ostream &	output,
		const AttributeContainerList &	rhs
	)			[inline]

Write a formatted description of the specified rhs to the specified stream and return a reference to the modifiable stream.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const AttributeContext_RuleEvaluationCache &	cache
	)

Write a description of the data members of the specified cache to the specified stream in some single-line human readable format, and return the modifiable stream.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const AttributeContext &	context
	)

Write a description of the data members of the specified context to the specified stream in a single-line human readable format, and return a reference to the modifiable stream.

bool ball::operator==	(	const Context &	lhs,
		const Context &	rhs
	)

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

bool ball::operator!=	(	const Context &	lhs,
		const Context &	rhs
	)

Return true if the specified lhs and rhs context objects do not have the same value, and false otherwise. Two context objects do not have the same value if one or more respective attributes differ in value.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const Context &	rhs
	)

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

bool ball::operator==	(	const DefaultAttributeContainer &	lhs,
		const DefaultAttributeContainer &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two DefaultAttributeContainer objects have the same value if they contain the same number of (unique) attributes, and every attribute that appears in one object also appears in the other.

bool ball::operator!=	(	const DefaultAttributeContainer &	lhs,
		const DefaultAttributeContainer &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two DefaultAttributeContainer objects do not have the same value if they contain differing numbers of attributes or if there is at least one attribute that appears in one object, but not in the other.

bsl::ostream& ball::operator<<	(	bsl::ostream &	output,
		const DefaultAttributeContainer &	attributeContainer
	)

Write the value of the specified attributeContainer to the specified output stream in some single-line, human readable format. Return the output stream.

const BloombergLP::ball::CategoryHolder* ball::ball_log_getCategoryHolder

(

const BloombergLP::ball::CategoryHolder &

categoryHolder

)

[inline]

Parameters:

categoryHolder

Return the address of the specified categoryHolder. Note that this function facilitates consistent lookup of block-scope and class-scope category holders (see "Logging Macro Reuse" in the "IMPLEMENTATION NOTES" of the component implementation file for details).

bool ball::operator==	(	const LoggerManagerConfiguration &	lhs,
		const LoggerManagerConfiguration &	rhs
	)

Return true if the specified lhs and rhs attribute objects have the same (in-core) value, and false otherwise. Two attribute objects objects have the same in-core value if each respective attribute has the same in-core value. Note that functor attributes must have identically the same representation to have the same in-core value.

bool ball::operator!=	(	const LoggerManagerConfiguration &	lhs,
		const LoggerManagerConfiguration &	rhs
	)

Return true if the specified lhs and rhs attribute objects do not have the same (in-core) value, and false otherwise. Two attribute objects do not have the same in-core value if one or more respective attributes differ in in-core values. Note that functor attributes will have different in-core values if their representations are not identical.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const LoggerManagerConfiguration &	configuration
	)

Write a reasonable representation of the specified configuration object to the specified output stream, indicating whether the contained functors are or are not "null".

bool ball::operator==	(	const LoggerManagerDefaults &	lhs,
		const LoggerManagerDefaults &	rhs
	)

Return true if the specified lhs and rhs attribute objects have the same value, and false otherwise. Two attribute objects objects have the same value if each respective attribute has the same value.

bool ball::operator!=	(	const LoggerManagerDefaults &	lhs,
		const LoggerManagerDefaults &	rhs
	)

Return true if the specified lhs and rhs attribute objects do not have the same value, and false otherwise. Two attribute objects do not have the same value if one or more respective attributes differ in values.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const LoggerManagerDefaults &	defaults
	)

Write the specified defaults object to the specified output stream in a reasonable multi-line format.

bool ball::operator==	(	const ManagedAttribute &	lhs,
		const ManagedAttribute &	rhs
	)

bool ball::operator==	(	const ManagedAttribute &	lhs,
		const Attribute &	rhs
	)

bool ball::operator==	(	const Attribute &	lhs,
		const ManagedAttribute &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two ManagedAttribute objects have the same value if they have the same name, same attribute value type, and the same attribute value.

bool ball::operator!=	(	const ManagedAttribute &	lhs,
		const ManagedAttribute &	rhs
	)

bool ball::operator!=	(	const ManagedAttribute &	lhs,
		const Attribute &	rhs
	)

bool ball::operator!=	(	const Attribute &	lhs,
		const ManagedAttribute &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two ManagedAttribute objects do not have the same value if any of their respective names, attribute value types, or attribute values differ.

bsl::ostream& ball::operator<<	(	bsl::ostream &	output,
		const ManagedAttribute &	attribute
	)

Write the value of the specified attribute to the specified output stream. Return the specified output stream.

bool ball::operator==	(	const ManagedAttributeSet &	lhs,
		const ManagedAttributeSet &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two ManagedAttributeSet objects have the same value if they have the same number of attributes and every attribute value that appears in one object also appears in the other.

bool ball::operator!=	(	const ManagedAttributeSet &	lhs,
		const ManagedAttributeSet &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two ManagedAttributeSet objects do not have the same value if they do not have the same number of attributes or there is at least one attribute value that appears in one object, but not in the other.

bsl::ostream& ball::operator<<	(	bsl::ostream &	output,
		const ManagedAttributeSet &	attributeSet
	)

Write the value of the specified attributeSet to the specified output stream. Return the specified output stream.

bool ball::operator==	(	const Record &	lhs,
		const Record &	rhs
	)

Return true if the specified lhs and rhs log records have the same value, and false otherwise. Two log records have the same value if the respective fixed fields have the same value and the respective user-defined fields have the same value.

bool ball::operator!=	(	const Record &	lhs,
		const Record &	rhs
	)

Return true if the specified lhs and rhs log records do not have the same value, and false otherwise. Two log records do not have the same value if either the respective fixed fields or user-defined fields do not have the same value.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const Record &	record
	)

Format the members of the specified record to the specified output stream and return a reference to the modifiable stream.

bool ball::operator==	(	const RecordAttributes &	lhs,
		const RecordAttributes &	rhs
	)

Return true if the specified lhs and rhs record attributes objects have the same value, and false otherwise. Two record attributes objects have the same value if each respective pair of attributes have the same value.

bool ball::operator!=	(	const RecordAttributes &	lhs,
		const RecordAttributes &	rhs
	)			[inline]

Return true if the specified lhs and rhs record attributes objects do not have the same value, and false otherwise. Two record attributes objects do not have the same value if one or more respective attributes differ in value.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const RecordAttributes &	object
	)			[inline]

Format the members of the specified object to the specified output stream and return a reference to the modifiable stream.

bool ball::operator==	(	const RecordJsonFormatter &	lhs,
		const RecordJsonFormatter &	rhs
	)

Return true if the specified lhs and rhs record formatters have the same value, and false otherwise. Two record formatters have the same value if they have the same format specification and record separator.

bool ball::operator!=	(	const RecordJsonFormatter &	lhs,
		const RecordJsonFormatter &	rhs
	)

Return true if the specified lhs and rhs record formatters do not have the same value, and false otherwise. Two record formatters differ in value if their format specifications or record separators differ.

bool ball::operator==	(	const RecordStringFormatter &	lhs,
		const RecordStringFormatter &	rhs
	)

Return true if the specified lhs and rhs record formatters have the same value, and false otherwise. Two record formatters have the same value if they have the same format specification and the same timestamp offset.

bool ball::operator!=	(	const RecordStringFormatter &	lhs,
		const RecordStringFormatter &	rhs
	)

Return true if the specified lhs and rhs record formatters do not have the same value, and false otherwise. Two record formatters differ in value if their format specifications differ or their timestamp offsets differ.

bsl::ostream& ball::operator<<	(	bsl::ostream &	output,
		const RecordStringFormatter &	rhs
	)

Write the specified rhs record formatter to the specified output stream in some reasonable (single-line) format and return a reference to the modifiable stream.

bool ball::operator==	(	const Rule &	lhs,
		const Rule &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two Rule objects have the same value if they have the same attributes, the same four respective threshold levels, and the same pattern.

bool ball::operator!=	(	const Rule &	lhs,
		const Rule &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two Rule objects do not have the same value if they have different attributes, different values for any of the four respective threshold levels, or different patterns.

bsl::ostream& ball::operator<<	(	bsl::ostream &	output,
		const Rule &	rule
	)

Write the value of the specified rule to the specified output stream. Return the specified output stream.

bool ball::operator==	(	const RuleSet &	lhs,
		const RuleSet &	rhs
	)

Return true if the specified lhs and rhs rule sets have the same value, and false otherwise. Two rule sets have the same value if every rule that exists in one rule set also exists in the other.

bool ball::operator!=	(	const RuleSet &	lhs,
		const RuleSet &	rhs
	)

Return true if the specified lhs and rhs rule sets do not have the same value, and false otherwise. Two rule sets do not have the same value if there is at least one rule that exists in one rule but does not exist in the other.

bsl::ostream& ball::operator<<	(	bsl::ostream &	output,
		const RuleSet &	rules
	)

Write the value of the specified rules to the specified output stream. Return the specified output stream

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		Severity::Level	rhs
	)

Format the specified rhs to the specified output stream and return a reference to the modifiable stream.

bool ball::operator==	(	const ThresholdAggregate &	lhs,
		const ThresholdAggregate &	rhs
	)

Return true if the specified lhs and rhs threshold aggregates have the same value, and false otherwise. Two threshold aggregates have the same value if all four of their respective threshold levels are the same.

bool ball::operator!=	(	const ThresholdAggregate &	lhs,
		const ThresholdAggregate &	rhs
	)

Return true if the specified lhs and rhs threshold aggregates do not have the same value, and false otherwise. Two threshold aggregates do not have the same value if any of their four respective threshold levels differ.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const ThresholdAggregate &	aggregate
	)

Write the value of the specified threshold aggregate to the specified output stream and return a reference to the modifiable stream.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		Transmission::Cause	rhs
	)

Format the specified rhs to the specified output stream and return a reference to the modifiable stream.

bool ball::operator==	(	const UserFields &	lhs,
		const UserFields &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two ball::UserFields objects have the same value if they have the same number of elements, and each element in lhs has the same value as corresponding element at the same index in rhs.

bool ball::operator!=	(	const UserFields &	lhs,
		const UserFields &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two UserFields objects do not have the same value if they have a different number of elements, or if any element in lhs has a different value from the corresponding element at the same index in rhs.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const UserFields &	object
	)

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

      print(stream, 0, -1);

void ball::swap	(	ball::UserFields &	a,
		ball::UserFields &	b
	)

Swap the value of the specified a object with the value of the specified b object. If a and b were created with the same allocator, then this method provides the no-throw exception-safety guarantee; otherwise, it provides the basic guarantee.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		UserFieldType::Enum	value
	)

Write the string representation of the specified enumeration value to the specified output stream in a single-line format, and return a reference to stream. See toAscii for what constitutes the string representation of a ball::UserFieldType::Enum value. Note that this method has the same behavior as

      ball::UserFieldType::print(stream, value, 0, -1);

bool ball::operator==	(	const UserFieldValue &	lhs,
		const UserFieldValue &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two UserFieldValue objects have the same value if they have the same type, and (if the type is not e_VOID) the value of that type (as accessed through the* methods) is the same.

bool ball::operator!=	(	const UserFieldValue &	lhs,
		const UserFieldValue &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two UserFieldValue objects do not have the same value if their type is not the same, or (if their type is not e_VOID) the value of that type (as accessed through the* methods) is not the same.

bsl::ostream& ball::operator<<	(	bsl::ostream &	stream,
		const UserFieldValue &	object
	)

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

      print(stream, 0, -1);

void ball::swap	(	ball::UserFieldValue &	a,
		ball::UserFieldValue &	b
	)

Swap the value of the specified a object with the value of the specified b object. This method provides the no-throw exception-safety guarantee if either a.type() is the same as b.type() and a and b were created with the same allocator, or neither a.type() nor b.type() is a type that requires allocation; otherwise, it provides the basic guarantee.