libzypp 17.31.7
RelCompare.h
Go to the documentation of this file.
1/*---------------------------------------------------------------------\
2| ____ _ __ __ ___ |
3| |__ / \ / / . \ . \ |
4| / / \ V /| _/ _/ |
5| / /__ | | | | | | |
6| /_____||_| |_| |_| |
7| |
8\---------------------------------------------------------------------*/
12#ifndef ZYPP_RELCOMPARE_H
13#define ZYPP_RELCOMPARE_H
14
15#include <functional>
16
17#include <zypp/Rel.h>
18
20namespace zypp
21{
22
79
85 template<class Tp>
86 struct Compare
87 {
88 int operator()( const Tp & lhs, const Tp & rhs ) const
89 { return Tp::compare( lhs, rhs ); }
90 };
91
93
107 template<class Tp, class TCompare>
108 inline bool compareByRel( Rel op, const Tp & lhs, const Tp & rhs, TCompare compare )
109 {
110 switch ( op.inSwitch() )
111 {
112 case Rel::EQ_e:
113 return compare( lhs, rhs ) == 0;
114 break;
115 case Rel::NE_e:
116 return compare( lhs, rhs ) != 0;
117 break;
118 case Rel::LT_e:
119 return compare( lhs, rhs ) < 0;
120 break;
121 case Rel::LE_e:
122 return compare( lhs, rhs ) <= 0;
123 break;
124 case Rel::GT_e:
125 return compare( lhs, rhs ) > 0;
126 break;
127 case Rel::GE_e:
128 return compare( lhs, rhs ) >= 0;
129 break;
130 case Rel::ANY_e:
131 return true;
132 break;
133 case Rel::NONE_e:
134 return false;
135 break;
136 }
137 return false;
138 }
139
143 template<class Tp>
144 inline bool compareByRel( Rel op, const Tp & lhs, const Tp & rhs )
145 { return compareByRel( op, lhs, rhs, Compare<Tp>() ); }
146
148
150
157 template<class Tp, class TCompare = Compare<Tp> >
159 {
161 : _op( op_r )
162 {}
163
164 bool operator()( const Tp & lhs, const Tp & rhs ) const
165 { return compareByRel( _op, lhs, rhs, TCompare() ); }
166
168 };
169
170 template<class Tp, class TCompare = Compare<Tp> >
172 {
173 bool operator()( const Tp & lhs, const Tp & rhs ) const
174 { return compareByRel( Rel::EQ, lhs, rhs, TCompare() ); }
175 };
176
177 template<class Tp, class TCompare = Compare<Tp> >
179 {
180 bool operator()( const Tp & lhs, const Tp & rhs ) const
181 { return compareByRel( Rel::NE, lhs, rhs, TCompare() ); }
182 };
183
184 template<class Tp, class TCompare = Compare<Tp> >
186 {
187 bool operator()( const Tp & lhs, const Tp & rhs ) const
188 { return compareByRel( Rel::LT, lhs, rhs, TCompare() ); }
189 };
190
191 template<class Tp, class TCompare = Compare<Tp> >
193 {
194 bool operator()( const Tp & lhs, const Tp & rhs ) const
195 { return compareByRel( Rel::LE, lhs, rhs, TCompare() ); }
196 };
197
198 template<class Tp, class TCompare = Compare<Tp> >
200 {
201 bool operator()( const Tp & lhs, const Tp & rhs ) const
202 { return compareByRel( Rel::GT, lhs, rhs, TCompare() ); }
203 };
204
205 template<class Tp, class TCompare = Compare<Tp> >
207 {
208 bool operator()( const Tp & lhs, const Tp & rhs ) const
209 { return compareByRel( Rel::GE, lhs, rhs, TCompare() ); }
210 };
211
212 template<class Tp, class TCompare = Compare<Tp> >
214 {
215 bool operator()( const Tp & lhs, const Tp & rhs ) const
216 { return compareByRel( Rel::ANY, lhs, rhs, TCompare() ); }
217 };
218
219 template<class Tp, class TCompare = Compare<Tp> >
221 {
222 bool operator()( const Tp & lhs, const Tp & rhs ) const
223 { return compareByRel( Rel::NONE, lhs, rhs, TCompare() ); }
224 };
225
227
229
230} // namespace zypp
232#endif // ZYPP_RELCOMPARE_H
bool compareByRel(Rel op, const Tp &lhs, const Tp &rhs, TCompare compare)
Comparison of two elements using relational operator op.
Definition: RelCompare.h:108
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
bool operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:215
bool operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:173
bool operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:208
bool operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:201
bool operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:194
bool operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:187
bool operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:180
bool operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:222
Functor to compare two elements by Rel based on a general TCompare functor.
Definition: RelCompare.h:159
CompareBy(Rel op_r)
Definition: RelCompare.h:160
bool operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:164
General compare functor returning -1, 0, 1.
Definition: RelCompare.h:87
int operator()(const Tp &lhs, const Tp &rhs) const
Definition: RelCompare.h:88
Relational operators.
Definition: Rel.h:44
for_use_in_switch inSwitch() const
Enumarator provided for use in switch statement.
Definition: Rel.h:141
static const Rel LT
Definition: Rel.h:52
static const Rel GT
Definition: Rel.h:54
static const Rel LE
Definition: Rel.h:53
static const Rel GE
Definition: Rel.h:55
static const Rel NONE
Definition: Rel.h:57
static const Rel NE
Definition: Rel.h:51
static const Rel ANY
Definition: Rel.h:56
static const Rel EQ
Definition: Rel.h:50
@ ANY_e
Definition: Rel.h:73
@ LT_e
Definition: Rel.h:69
@ GT_e
Definition: Rel.h:67
@ NE_e
Definition: Rel.h:72
@ LE_e
Definition: Rel.h:71
@ NONE_e
Definition: Rel.h:66
@ EQ_e
Definition: Rel.h:68
@ GE_e
Definition: Rel.h:70