1 /*---------------------------------------------------------------------\
3 | |__ / \ / / . \ . \ |
8 \---------------------------------------------------------------------*/
9 /** \file zypp/RelCompare.h
12 #ifndef ZYPP_RELCOMPARE_H
13 #define ZYPP_RELCOMPARE_H
19 ///////////////////////////////////////////////////////////////////
21 { /////////////////////////////////////////////////////////////////
23 /** \defgroup RelCompare Comparison using relational operator zypp::Rel.
25 * . Take a class like zypp::Edition. Editions are comaprable.
26 * You can compare them lexicographical, or according to their
27 * version and release values, or match them (i.e. taking empty
28 * version or release values as wildcard).
30 * No matter which way is appropriate within a certain context.
31 * You need functions to compare, and may want to use classes like
32 * zypp::Range, based on the desired comparison.
34 * All the class has to do, is providing a general comparison
35 * method (preferably static)
37 * // Compare two elements returning -1, 0, 1
38 * // if the elemants compare <,==,>.
39 * static int compare( const _Tp & lhs, const _Tp & rhs );
42 * <tt>Compare\<_Tp\></tt> provides a functor wrapping \c compare.
43 * In case the general comparison method is named differently, the
44 * class, or you, have to provide an approriate functor.
46 * <tt>compareByRel</tt> then compares two elements using a certain
47 * operator and general comparison method.
49 * compareByRel( Rel::EQ, lhs, rhs, Edition::compare );
50 * compareByRel( Rel::EQ, lhs, rhs, Edition::match );
51 * compareByRel( Rel::EQ, lhs, rhs ); // defaults to Compare\<Edition\>
52 * // thus Edition::compare
55 * Furthermore a bunch of functors using a certain opertator is
56 * defined. All templated by type and general comparison
57 * method (defaults to Compare\<_Tp\>).
59 * // Editions sets use lexicographical order per default:
62 * // An Edition set using Edition::compare as order:
63 * std::set<Edition,CompareByLT<Edition> >;
65 * // Edition::match is not transitive, thus not an appropriate
66 * // order relation for std::set or std::map.
69 * Classes like zypp:Range are templated by by type and general
70 * comparison method as well. Thus you may use Edition ranges based
71 * on Edition::Compare, as well as ranges based on Edition::Match
72 * (Edition provides these two functors).
74 * Again: Everything a class has to provide is the general
75 * comparison method. Comparison functors and ranges are then
76 * immediately available.
80 /** General compare functor returning <tt>-1, 0, 1</tt>.
81 * Expects _Tp::compare to be a static comaprison method
82 * returning <tt>-1, 0, 1</tt> if the elements compare
86 struct Compare : public std::binary_function<_Tp,_Tp,int>
88 int operator()( const _Tp & lhs, const _Tp & rhs ) const
89 { return _Tp::compare( lhs, rhs ); }
92 ///////////////////////////////////////////////////////////////////
94 /** Comparison of two elements using relational operator \a op.
95 * Expects \a _Compare to be a binary operator returning
96 * <tt>-1, 0, 1</tt> if the elemants compare <tt>\<,==,\></tt>.
98 * // Signature of compare function or functor:
99 * int compare( const _Tp & lhs, const _Tp & rhs );
101 * \li If \a op is Rel::ANY, the expression is always \c true.
102 * \li If \a op is Rel::NONE, the expression is always \c false.
103 * \li Otherwise the expression is evaluated using \a compare.
105 * \ingroup RelCompare
107 template<class _Tp, class _Compare>
108 inline bool compareByRel( Rel op, const _Tp & lhs, const _Tp & rhs,
111 switch ( op.inSwitch() )
114 return compare( lhs, rhs ) == 0;
117 return compare( lhs, rhs ) != 0;
120 return compare( lhs, rhs ) < 0;
123 return compare( lhs, rhs ) <= 0;
126 return compare( lhs, rhs ) > 0;
129 return compare( lhs, rhs ) >= 0;
141 /** \ref compareByRel convenience using Compare<_Tp> as general compare
145 inline bool compareByRel( Rel op, const _Tp & lhs, const _Tp & rhs )
146 { return compareByRel( op, lhs, rhs, Compare<_Tp>() ); }
148 ///////////////////////////////////////////////////////////////////
150 ///////////////////////////////////////////////////////////////////
152 /** Functor to compare two elements by \ref Rel based on
153 * a general \a _Compare functor.
155 * Expects \a _Compare to be suitable for use in \ref compareByRel.
156 * Defaults to Compare\<_Tp\>.
158 template<class _Tp, class _Compare = Compare<_Tp> >
159 struct CompareBy : public std::binary_function<_Tp,_Tp,bool>
161 CompareBy( Rel op_r )
165 bool operator()( const _Tp & lhs, const _Tp & rhs ) const
166 { return compareByRel( _op, lhs, rhs, _Compare() ); }
171 template<class _Tp, class _Compare = Compare<_Tp> >
172 struct CompareByEQ : public std::binary_function<_Tp,_Tp,bool>
174 bool operator()( const _Tp & lhs, const _Tp & rhs ) const
175 { return compareByRel( Rel::EQ, lhs, rhs, _Compare() ); }
178 template<class _Tp, class _Compare = Compare<_Tp> >
179 struct CompareByNE : public std::binary_function<_Tp,_Tp,bool>
181 bool operator()( const _Tp & lhs, const _Tp & rhs ) const
182 { return compareByRel( Rel::NE, lhs, rhs, _Compare() ); }
185 template<class _Tp, class _Compare = Compare<_Tp> >
186 struct CompareByLT : public std::binary_function<_Tp,_Tp,bool>
188 bool operator()( const _Tp & lhs, const _Tp & rhs ) const
189 { return compareByRel( Rel::LT, lhs, rhs, _Compare() ); }
192 template<class _Tp, class _Compare = Compare<_Tp> >
193 struct CompareByLE : public std::binary_function<_Tp,_Tp,bool>
195 bool operator()( const _Tp & lhs, const _Tp & rhs ) const
196 { return compareByRel( Rel::LE, lhs, rhs, _Compare() ); }
199 template<class _Tp, class _Compare = Compare<_Tp> >
200 struct CompareByGT : public std::binary_function<_Tp,_Tp,bool>
202 bool operator()( const _Tp & lhs, const _Tp & rhs ) const
203 { return compareByRel( Rel::GT, lhs, rhs, _Compare() ); }
206 template<class _Tp, class _Compare = Compare<_Tp> >
207 struct CompareByGE : public std::binary_function<_Tp,_Tp,bool>
209 bool operator()( const _Tp & lhs, const _Tp & rhs ) const
210 { return compareByRel( Rel::GE, lhs, rhs, _Compare() ); }
213 template<class _Tp, class _Compare = Compare<_Tp> >
214 struct CompareByANY : public std::binary_function<_Tp,_Tp,bool>
216 bool operator()( const _Tp & lhs, const _Tp & rhs ) const
217 { return compareByRel( Rel::ANY, lhs, rhs, _Compare() ); }
220 template<class _Tp, class _Compare = Compare<_Tp> >
221 struct CompareByNONE : public std::binary_function<_Tp,_Tp,bool>
223 bool operator()( const _Tp & lhs, const _Tp & rhs ) const
224 { return compareByRel( Rel::NONE, lhs, rhs, _Compare() ); }
227 ///////////////////////////////////////////////////////////////////
230 /////////////////////////////////////////////////////////////////
232 ///////////////////////////////////////////////////////////////////
233 #endif // ZYPP_RELCOMPARE_H