zypp/RelCompare.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/RelCompare.h
  10  *
  11 */
  12 #ifndef ZYPP_RELCOMPARE_H
  13 #define ZYPP_RELCOMPARE_H
  14
  15 #include <functional>
  16
  17 #include "zypp/Rel.h"
  18
  19 ///////////////////////////////////////////////////////////////////
  20 namespace zypp
  21 { /////////////////////////////////////////////////////////////////
  22
  23   /** \defgroup RelCompare Comparison using relational operator zypp::Rel.
  24    *
  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).
  29    *
  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.
  33    *
  34    * All the class has to do, is providing a general comparison
  35    * method (preferably static)
  36    * \code
  37    *     // Compare two elements returning -1, 0, 1
  38    *     //  if the elemants compare <,==,>.
  39    *     static int compare( const Tp & lhs, const Tp & rhs );
  40    * \endcode
  41    *
  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.
  45    *
  46    * <tt>compareByRel</tt> then compares two elements using a certain
  47    * operator and general comparison method.
  48    * \code
  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
  53    * \endcode
  54    *
  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\>).
  58    * \code
  59    * // Editions sets use lexicographical order per default:
  60    * std::set<Edition>
  61    *
  62    * // An Edition set using Edition::compare as order:
  63    * std::set<Edition,CompareByLT<Edition> >;
  64    *
  65    * // Edition::match is not transitive, thus not an appropriate
  66    * // order relation for std::set or std::map.
  67    * \endcode
  68    *
  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).
  73    *
  74    * Again: Everything a class has to provide is the general
  75    * comparison method. Comparison functors and ranges are then
  76    * immediately available.
  77   */
  78   //@{
  79
  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
  83    * <tt>\<,==,\></tt>.
  84   */
  85   template<class Tp>
  86     struct Compare : public std::binary_function<Tp,Tp,int>
  87     {
  88       int operator()( const Tp & lhs, const Tp & rhs ) const
  89       { return Tp::compare( lhs, rhs ); }
  90     };
  91
  92   ///////////////////////////////////////////////////////////////////
  93
  94   /** Comparison of two elements using relational operator \a op.
  95    * Expects \a TCompare to be a binary operator returning
  96    * <tt>-1, 0, 1</tt> if the elemants compare <tt>\<,==,\></tt>.
  97    * \code
  98    *     // Signature of compare function or functor:
  99    *     int compare( const Tp & lhs, const Tp & rhs );
 100    * \endcode
 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.
 104    *
 105    * \ingroup RelCompare
 106   */
 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
 140   /** \ref compareByRel convenience using Compare<Tp> as general compare
 141    *  functor.
 142   */
 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
 147   ///////////////////////////////////////////////////////////////////
 148
 149   ///////////////////////////////////////////////////////////////////
 150
 151   /** Functor to compare two elements by \ref Rel based on
 152    * a general \a TCompare functor.
 153    *
 154    * Expects \a TCompare to be suitable for use in \ref compareByRel.
 155    * Defaults to Compare\<Tp\>.
 156   */
 157   template<class Tp, class TCompare = Compare<Tp> >
 158     struct CompareBy : public std::binary_function<Tp,Tp,bool>
 159     {
 160       CompareBy( Rel op_r )
 161       : _op( op_r )
 162       {}
 163
 164       bool operator()( const Tp & lhs, const Tp & rhs ) const
 165       { return compareByRel( _op, lhs, rhs, TCompare() ); }
 166
 167       Rel _op;
 168     };
 169
 170   template<class Tp, class TCompare = Compare<Tp> >
 171     struct CompareByEQ : public std::binary_function<Tp,Tp,bool>
 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> >
 178     struct CompareByNE : public std::binary_function<Tp,Tp,bool>
 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> >
 185     struct CompareByLT : public std::binary_function<Tp,Tp,bool>
 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> >
 192     struct CompareByLE : public std::binary_function<Tp,Tp,bool>
 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> >
 199     struct CompareByGT : public std::binary_function<Tp,Tp,bool>
 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> >
 206     struct CompareByGE : public std::binary_function<Tp,Tp,bool>
 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> >
 213     struct CompareByANY : public std::binary_function<Tp,Tp,bool>
 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> >
 220     struct CompareByNONE : public std::binary_function<Tp,Tp,bool>
 221     {
 222       bool operator()( const Tp & lhs, const Tp & rhs ) const
 223       { return compareByRel( Rel::NONE, lhs, rhs, TCompare() ); }
 224     };
 225
 226   ///////////////////////////////////////////////////////////////////
 227
 228   //@}
 229   /////////////////////////////////////////////////////////////////
 230 } // namespace zypp
 231 ///////////////////////////////////////////////////////////////////
 232 #endif // ZYPP_RELCOMPARE_H