RelCompare.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_RELCOMPARE_H
#define ZYPP_RELCOMPARE_H

#include <functional>

#include "zypp/Rel.h"

namespace zypp
{ 


  template<class _Tp>
    struct Compare : public std::binary_function<_Tp,_Tp,int>
    {
      int operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return _Tp::compare( lhs, rhs ); }
    };


  template<class _Tp, class _Compare>
    inline bool compareByRel( Rel op, const _Tp & lhs, const _Tp & rhs,
                              _Compare compare )
    {
      switch ( op.inSwitch() )
      {
      case Rel::EQ_e:
        return compare( lhs, rhs ) == 0;
        break;
      case Rel::NE_e:
        return compare( lhs, rhs ) != 0;
        break;
      case Rel::LT_e:
        return compare( lhs, rhs ) < 0;
        break;
      case Rel::LE_e:
        return compare( lhs, rhs ) <= 0;
        break;
      case Rel::GT_e:
        return compare( lhs, rhs ) > 0;
        break;
      case Rel::GE_e:
        return compare( lhs, rhs ) >= 0;
        break;
      case Rel::ANY_e:
        return true;
        break;
      case Rel::NONE_e:
        return false;
        break;
      }
      return false;
    }

  template<class _Tp>
    inline bool compareByRel( Rel op, const _Tp & lhs, const _Tp & rhs )
    { return compareByRel( op, lhs, rhs, Compare<_Tp>() ); }



  template<class _Tp, class _Compare = Compare<_Tp> >
    struct CompareBy : public std::binary_function<_Tp,_Tp,bool>
    {
      CompareBy( Rel op_r )
      : _op( op_r )
      {}

      bool operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return compareByRel( _op, lhs, rhs, _Compare() ); }

      Rel _op;
    };

  template<class _Tp, class _Compare = Compare<_Tp> >
    struct CompareByEQ : public std::binary_function<_Tp,_Tp,bool>
    {
      bool operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return compareByRel( Rel::EQ, lhs, rhs, _Compare() ); }
    };

  template<class _Tp, class _Compare = Compare<_Tp> >
    struct CompareByNE : public std::binary_function<_Tp,_Tp,bool>
    {
      bool operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return compareByRel( Rel::NE, lhs, rhs, _Compare() ); }
    };

  template<class _Tp, class _Compare = Compare<_Tp> >
    struct CompareByLT : public std::binary_function<_Tp,_Tp,bool>
    {
      bool operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return compareByRel( Rel::LT, lhs, rhs, _Compare() ); }
    };

  template<class _Tp, class _Compare = Compare<_Tp> >
    struct CompareByLE : public std::binary_function<_Tp,_Tp,bool>
    {
      bool operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return compareByRel( Rel::LE, lhs, rhs, _Compare() ); }
    };

  template<class _Tp, class _Compare = Compare<_Tp> >
    struct CompareByGT : public std::binary_function<_Tp,_Tp,bool>
    {
      bool operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return compareByRel( Rel::GT, lhs, rhs, _Compare() ); }
    };

  template<class _Tp, class _Compare = Compare<_Tp> >
    struct CompareByGE : public std::binary_function<_Tp,_Tp,bool>
    {
      bool operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return compareByRel( Rel::GE, lhs, rhs, _Compare() ); }
    };

  template<class _Tp, class _Compare = Compare<_Tp> >
    struct CompareByANY : public std::binary_function<_Tp,_Tp,bool>
    {
      bool operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return compareByRel( Rel::ANY, lhs, rhs, _Compare() ); }
    };

  template<class _Tp, class _Compare = Compare<_Tp> >
    struct CompareByNONE : public std::binary_function<_Tp,_Tp,bool>
    {
      bool operator()( const _Tp & lhs, const _Tp & rhs ) const
      { return compareByRel( Rel::NONE, lhs, rhs, _Compare() ); }
    };


} // namespace zypp
#endif // ZYPP_RELCOMPARE_H