libzypp: zypp::Rel Struct Reference

List of all members.


Public Types
enum	for_use_in_switch { EQ_e, NE_e, LT_e, LE_e, GT_e, GE_e, ANY_e, NONE_e }
	Enumarators provided only for use inSwitch statement. More...
Public Member Functions
	Rel ()
	DefaultCtor ANY.
	Rel (const std::string &strval_r)
	Ctor from string.
const std::string &	asString () const
	String representation of relational operator.
for_use_in_switch	inSwitch () const
	Enumarator provided for use in `switch` statement.
Static Public Attributes
Relational operators
These are the real relational operator contants to use. Don't mind that it's not an enum. See also: zypp::Rel::inSwitch
static const Rel	EQ
static const Rel	NE
static const Rel	LT
static const Rel	LE
static const Rel	GT
static const Rel	GE
static const Rel	ANY
static const Rel	NONE
Private Member Functions
	Rel (for_use_in_switch op_r)
	Ctor to initialize the relational operator contants.
Private Attributes
for_use_in_switch	_op
	The operator.
Related Functions
(Note that these are not member functions.)
std::ostream &	operator<< (std::ostream &str, const Rel &obj)
	Stream output.
bool	operator== (const Rel &lhs, const Rel &rhs)
bool	operator!= (const Rel &lhs, const Rel &rhs)

Detailed Description

Yes, it could as well be simply an enum.
Yes, you can use the relational operators as if it was an enum.
Except for use in a switch statement; see inSwitch for this.

But we want to construct them from a string representation, as well as providing one. And this way they are wrapped into a namespace, which is a good idea anyway.

ANY and NONE are somewhat special. ANY is the operator created by the default ctor, and it should always resolve to true. This may be handy in queries when you're looking for a Resolvable in ANY Edition if no operator was specified. While NONE should always resolve to false.

Member Enumeration Documentation

enum zypp::Rel::for_use_in_switch

Enumarators provided only for use inSwitch statement.

See also:: inSwitch

Enumerator:

EQ_e
NE_e
LT_e
LE_e
GT_e
GE_e
ANY_e
NONE_e

Definition at line 63 of file Rel.h.

Constructor & Destructor Documentation

zypp::Rel::Rel ( ) [inline]

DefaultCtor ANY.

Definition at line 66 of file Rel.h.

zypp::Rel::Rel ( const std::string & strval_r ) [explicit]

Ctor from string.

Legal values for strval_r are: "==", "!=", "<", "<=", ">", ">=",
as well as "EQ", "NE", "LT", "LE", "GT", "GE", "ANY", "NONE"
and "" (empty string resolves to ANY).

Lower case names are accepted as well.

Exceptions:

PARSE

if strval_r is not legal.

Todo:: refine exceptions and check throw.

Definition at line 69 of file Rel.cc.

zypp::Rel::Rel ( for_use_in_switch op_r ) [inline, private]

Ctor to initialize the relational operator contants.

Definition at line 112 of file Rel.h.

Member Function Documentation

const std::string & zypp::Rel::asString ( ) const

String representation of relational operator.

Returns:: "==", "!=", "<", "<=", ">", ">=", "ANY" or "NONE"

Definition at line 78 of file Rel.cc.

References _op, zypp::_table, ANY_e, EQ_e, GE_e, GT_e, LE_e, LT_e, NE_e, and NONE_e.

Referenced by zypp::capability::buildHal(), zypp::capability::buildModalias(), zypp::capability::ModaliasCap::encode(), zypp::capability::HalCap::encode(), and operator<<().

for_use_in_switch zypp::Rel::inSwitch ( ) const [inline]

Enumarator provided for use in switch statement.

The sole reason for providing enum for_use_in_switch is, that we may want to use the relational operators in a switch statement. Tht's the only case where you should have to use the enumarator.

   Rel op;
   switch ( op.inSwitch() )
     {
     case Rel::EQ_e:
       ...
       break;
     case Rel::NE_e:
       ...

     // No default! Let compiler warn if case is missing
     }

Definition at line 107 of file Rel.h.

References _op.

Referenced by zypp::compareByRel(), zypp::capability::isEditionSpec(), and operator==().

Friends And Related Function Documentation