balcl Namespace Reference [Component balcl_commandline, Component balcl_constraint, Component balcl_occurrenceinfo, Component balcl_option, Component balcl_optioninfo, Component balcl_optiontype, Component balcl_optionvalue, Component balcl_typeinfo]

Classes
struct	CommandLine_SchemaData
class	CommandLine
class	CommandLineOptionsHandle
struct	Constraint
class	OccurrenceInfo
class	Option
struct	OptionInfo
struct	OptionType
class	OptionValue_NullOf
class	OptionValue
class	TypeInfo
struct	TypeInfoUtil
Functions
bool	operator== (const CommandLine_SchemaData &lhs, const CommandLine_SchemaData &rhs)
bool	operator!= (const CommandLine_SchemaData &lhs, const CommandLine_SchemaData &rhs)
bool	operator== (const CommandLine &lhs, const CommandLine &rhs)
bool	operator!= (const CommandLine &lhs, const CommandLine &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const CommandLine &rhs)
bool	operator== (const CommandLineOptionsHandle &lhs, const CommandLineOptionsHandle &rhs)
bool	operator!= (const CommandLineOptionsHandle &lhs, const CommandLineOptionsHandle &rhs)
bool	operator== (const OccurrenceInfo &lhs, const OccurrenceInfo &rhs)
bool	operator!= (const OccurrenceInfo &lhs, const OccurrenceInfo &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const OccurrenceInfo &rhs)
bool	operator== (const Option &lhs, const Option &rhs)
bool	operator!= (const Option &lhs, const Option &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const Option &rhs)
bool	operator== (const OptionInfo &lhs, const OptionInfo &rhs)
bool	operator!= (const OptionInfo &lhs, const OptionInfo &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const OptionInfo &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, OptionType::Enum value)
bool	operator== (const OptionValue_NullOf &lhs, const OptionValue_NullOf &rhs)
bool	operator!= (const OptionValue_NullOf &lhs, const OptionValue_NullOf &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const OptionValue_NullOf &object)
bool	operator== (const OptionValue &lhs, const OptionValue &rhs)
bool	operator!= (const OptionValue &lhs, const OptionValue &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const OptionValue &object)
void	swap (OptionValue &a, OptionValue &b)
bool	operator== (const TypeInfo &lhs, const TypeInfo &rhs)
bool	operator!= (const TypeInfo &lhs, const TypeInfo &rhs)
bsl::ostream &	operator<< (bsl::ostream &stream, const TypeInfo &rhs)

---

Function Documentation

bool balcl::operator==	(	const CommandLine_SchemaData &	lhs,
		const CommandLine_SchemaData &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two CommandLine_SchemaData objects have the same value if their type attributes are the same and if their name attributes compare equal.

bool balcl::operator!=	(	const CommandLine_SchemaData &	lhs,
		const CommandLine_SchemaData &	rhs
	)

Return true if the specified lhs and rhs do note have the same value, and false otherwise. Two CommandLine_SchemaData objects do not have the same value if their type attributes are not the same or if their name attributes do not compare equal.

bool balcl::operator==	(	const CommandLine &	lhs,
		const CommandLine &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two command-line arguments have the same value if and only if they are both parsed successfully and have the same command-line specifications and the same values for flags, options, and non-option arguments. Note that two identical copies built with the same option table, but unparsed, are not equal.

bool balcl::operator!=	(	const CommandLine &	lhs,
		const CommandLine &	rhs
	)

Return false if the specified lhs and rhs have the same value, and true otherwise. Two command-line arguments do not have the same value if and only if they have different command-line specifications, or one is parsed successfully but the other is not, or neither is, or else both have the same specification and both are parsed successfully but they have different values for at least one flag, option or non-option argument. Note that two identical copies built with the same option table, but unparsed, are not equal.

bsl::ostream& balcl::operator<<	(	bsl::ostream &	stream,
		const CommandLine &	rhs
	)

Write the options and their values in the specified rhs to the specified output stream in a (multi-line) human readable format and return a reference to stream. Note that the last line is not terminated by a newline character.

bool balcl::operator==	(	const CommandLineOptionsHandle &	lhs,
		const CommandLineOptionsHandle &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two CommandLineOptionsHandle objects have the same value if they have the same numOptions and each of those options have the same name, type, and value or are in the null state.

bool balcl::operator!=	(	const CommandLineOptionsHandle &	lhs,
		const CommandLineOptionsHandle &	rhs
	)

Return true if the specified lhs and rhs do not have the same value, and false otherwise. Two CommandLineOptionsHandle objects do not have the same value if they do not have the same numOptions or if any of their options differ in name, type, or 'value (or null state).

bool balcl::operator==	(	const OccurrenceInfo &	lhs,
		const OccurrenceInfo &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two objects of type OccurrenceInfo have the same value if and only if they have the same occurrence type and either both do not have a default value, or their respective default values have the same type and value.

bool balcl::operator!=	(	const OccurrenceInfo &	lhs,
		const OccurrenceInfo &	rhs
	)

Return true if the specified lhs and rhs do not have the same value, and false otherwise. Two objects of type OccurrenceInfo do not have the same value if and only if they have different occurrence types, or exactly one has a default value, or else both have a default value but their respective default values have either different types or different values.

bsl::ostream& balcl::operator<<	(	bsl::ostream &	stream,
		const OccurrenceInfo &	rhs
	)

Write the value of the specified rhs object to the specified stream in a (multi-line) human readable format and return a reference to the stream. Note that the last line is not terminated by a newline character.

bool balcl::operator==	(	const Option &	lhs,
		const Option &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two Option objects have the same value if their underlying OptionInfo objects have the same value.

bool balcl::operator!=	(	const Option &	lhs,
		const Option &	rhs
	)

Return true if the specified lhs command-line option has a different value from the specified rhs command-line option, and false otherwise. Two Option objects do not have the same value if their underlying OptionInfo objects do not have the same value.

bsl::ostream& balcl::operator<<	(	bsl::ostream &	stream,
		const Option &	rhs
	)

Write the value of the specified rhs object to the specified stream in a (multi-line) human readable format and return a reference to stream. Note that the last line is not terminated by a newline character.

bool balcl::operator==	(	const OptionInfo &	lhs,
		const OptionInfo &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two OptionInfo objects have the same value if they have the same tag string, the same name, the same description, the same type info, and the same occurrence info values.

bool balcl::operator!=	(	const OptionInfo &	lhs,
		const OptionInfo &	rhs
	)

Return true if the specified lhs and rhs do not have the same value, and false otherwise. Two OptionInfo object do not have the same value if they do not have the same tag strings, or the same names, or the same descriptions, or the same type information, or the same occurrence information.

bsl::ostream& balcl::operator<<	(	bsl::ostream &	stream,
		const OptionInfo &	rhs
	)

Write the value of the specified rhs object to the specified stream in a (multi-line) human readable format and return a reference to stream. Note that the last line is not terminated by a newline character.

bsl::ostream& balcl::operator<<	(	bsl::ostream &	stream,
		OptionType::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 OptionType::Enum value. Note that this method has the same behavior as:

      balcl::OptionType::print(stream, value, 0, -1);

bool balcl::operator==	(	const OptionValue_NullOf &	lhs,
		const OptionValue_NullOf &	rhs
	)

Return true if the type of the specified lhs and rhs are equal, and return false if they are not equal. Two OptionValue_NullOf objects are equal when their type attributes are equal.

bool balcl::operator!=	(	const OptionValue_NullOf &	lhs,
		const OptionValue_NullOf &	rhs
	)

Return true if the type of the specified lhs and rhs are not equal, and return false if they are not equal. Two OptionValue_NullOf objects are equal when their type attributes are note equal.

bsl::ostream& balcl::operator<<	(	bsl::ostream &	stream,
		const OptionValue_NullOf &	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: object.print(stream, 0, -1);

bool balcl::operator==	(	const OptionValue &	lhs,
		const OptionValue &	rhs
	)

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two OptionValue 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 balcl::operator!=	(	const OptionValue &	lhs,
		const OptionValue &	rhs
	)

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two OptionValue 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& balcl::operator<<	(	bsl::ostream &	stream,
		const OptionValue &	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 balcl::swap	(	OptionValue &	a,
		OptionValue &	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.

bool balcl::operator==	(	const TypeInfo &	lhs,
		const TypeInfo &	rhs
	)

Return true if the specified lhs and rhs have the same value, and false otherwise. Two TypeInfo objects have the same value if their associated options have the same type, both objects do not have a linked variable or both refer to the same variable, and both do not have a constraint or both refer to the same constraint. Note that two objects constructed from copies of the same constraint will not be identical. (Use constraint/setConstraint to ensure that both constraints are the same.)

bool balcl::operator!=	(	const TypeInfo &	lhs,
		const TypeInfo &	rhs
	)

Return true if the specified lhs command-line option info has a different value from the specified rhs command-line option info, and false otherwise. Two TypeInfo objects do not have the same value if the associated options have different types, or one object has a linked variable and the other either does not or refers to a different variable, and one has a constraint and the other either does not or refers to a different constraint. Note that two objects constructed from copies of the same constraint will not be identical. (Use constraint/setConstraint to ensure that both constraints are the same.)

bsl::ostream& balcl::operator<<	(	bsl::ostream &	stream,
		const TypeInfo &	rhs
	)

Write the value of the specified rhs object to the specified stream in a (multi-line) human readable format and return a reference to stream. Note that the last line is not terminated by a newline character.