RelCompare.h

Go to the documentation of this file.

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

#include <zypp/Rel.h>

namespace zypp
{ 


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


  template<class Tp, class TCompare>
    inline bool compareByRel( Rel op, const Tp & lhs, const Tp & rhs, TCompare 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 TCompare = Compare<Tp> >
    struct CompareBy
    {
      CompareBy( Rel op_r )
      : _op( op_r )
      {}

      bool operator()( const Tp & lhs, const Tp & rhs ) const
      { return compareByRel( _op, lhs, rhs, TCompare() ); }

      Rel _op;
    };

  template<class Tp, class TCompare = Compare<Tp> >
    struct CompareByEQ
    {
      bool operator()( const Tp & lhs, const Tp & rhs ) const
      { return compareByRel( Rel::EQ, lhs, rhs, TCompare() ); }
    };

  template<class Tp, class TCompare = Compare<Tp> >
    struct CompareByNE
    {
      bool operator()( const Tp & lhs, const Tp & rhs ) const
      { return compareByRel( Rel::NE, lhs, rhs, TCompare() ); }
    };

  template<class Tp, class TCompare = Compare<Tp> >
    struct CompareByLT
    {
      bool operator()( const Tp & lhs, const Tp & rhs ) const
      { return compareByRel( Rel::LT, lhs, rhs, TCompare() ); }
    };

  template<class Tp, class TCompare = Compare<Tp> >
    struct CompareByLE
    {
      bool operator()( const Tp & lhs, const Tp & rhs ) const
      { return compareByRel( Rel::LE, lhs, rhs, TCompare() ); }
    };

  template<class Tp, class TCompare = Compare<Tp> >
    struct CompareByGT
    {
      bool operator()( const Tp & lhs, const Tp & rhs ) const
      { return compareByRel( Rel::GT, lhs, rhs, TCompare() ); }
    };

  template<class Tp, class TCompare = Compare<Tp> >
    struct CompareByGE
    {
      bool operator()( const Tp & lhs, const Tp & rhs ) const
      { return compareByRel( Rel::GE, lhs, rhs, TCompare() ); }
    };

  template<class Tp, class TCompare = Compare<Tp> >
    struct CompareByANY
    {
      bool operator()( const Tp & lhs, const Tp & rhs ) const
      { return compareByRel( Rel::ANY, lhs, rhs, TCompare() ); }
    };

  template<class Tp, class TCompare = Compare<Tp> >
    struct CompareByNONE
    {
      bool operator()( const Tp & lhs, const Tp & rhs ) const
      { return compareByRel( Rel::NONE, lhs, rhs, TCompare() ); }
    };


} // namespace zypp
#endif // ZYPP_RELCOMPARE_H