Filter.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_FILTER_H
#define ZYPP_FILTER_H
 
#include <iosfwd>
 
#include <zypp/base/Functional.h>
#include <zypp/base/Function.h>
// #include <zypp/ResFilters.h>  included at the end!
#include <zypp/sat/Pool.h>
#include <zypp/PoolItem.h>
 
namespace zypp
{ 
  namespace filter
  { 
 
    //
    //  CLASS NAME : ByLocaleSupport
    //
    class ByLocaleSupport
    {
      private:
        typedef bool (sat::Solvable::*LS1) (const Locale &) const;
        typedef bool (sat::Solvable::*LS2) (const LocaleSet &) const;
 
      public:
        ByLocaleSupport()
        : _sel( std::mem_fn(&sat::Solvable::supportsLocales) )
        {}
 
        explicit ByLocaleSupport( const Locale & locale_r )
        : _sel( std::bind( std::mem_fn((LS1)&sat::Solvable::supportsLocale), _1, locale_r ) )
        {}
 
        explicit ByLocaleSupport( const LocaleSet & locales_r )
        : _sel( std::bind( std::mem_fn((LS2)&sat::Solvable::supportsLocale), _1, locales_r ) )
        {}
 
      public:
        bool operator()( const sat::Solvable & solv_r ) const
        { return _sel && _sel( solv_r ); }
 
        template<class TSolv>
        bool operator()( const TSolv & solv_r ) const
        { return operator()( solv_r.satSolvable() ); }
 
      private:
        function<bool(const sat::Solvable &)> _sel;
    };
 
    //
    //  CLASS NAME : ByKind
    //
    class ByKind
    {
      public:
        ByKind()
        {}
 
        ByKind( const ResKind & kind_r )
        : _kind( kind_r )
        {}
 
      public:
        bool operator()( const sat::Solvable & solv_r ) const
        { return solv_r.isKind( _kind ); }
 
        template<class TSolv>
        bool operator()( const TSolv & solv_r ) const
        { return operator()( solv_r.satSolvable() ); }
 
      private:
        ResKind _kind;
    };
 
    template<class TRes>
    inline ByKind byKind()
    { return ByKind( ResTraits<TRes>::kind ); }
 
    //
    //  CLASS NAME : ByStatus
    //
    class ByStatus
    {
      public:
        typedef bool (ResStatus::*Predicate)() const;
 
      public:
        ByStatus( Predicate pred_r = 0 )
        : _pred( pred_r )
        {}
 
      public:
        bool operator()( const PoolItem & pi_r ) const
        { return _pred && (pi_r.status().*_pred)(); }
 
        template<class TSolv>
        bool operator()( const TSolv & solv_r ) const
        { return operator()( PoolItem(solv_r) ); }
 
      private:
        Predicate _pred;
    };
 
 
    //
    //  CLASS NAME : SameItemAs
    //
    class SameItemAs
    {
      public:
        SameItemAs( const sat::Solvable & solv_r )
        : _item( solv_r )
        {}
 
        template<class TSolv>
        SameItemAs( const TSolv & solv_r )
        : _item( solv_r.satSolvable() )
        {}
 
      public:
        bool operator()( const sat::Solvable & solv_r ) const
        {
          return solv_r.name()    == _item.name()
              && solv_r.edition() == _item.edition()
              && solv_r.arch()    == _item.arch()
              && solv_r.vendor()  == _item.vendor();
        }
 
        template<class TSolv>
        bool operator()( const TSolv & solv_r ) const
        { return operator()( solv_r.satSolvable() ); }
 
      private:
        sat::Solvable _item;
    };
 
 
  } // namespace filter
} // namespace zypp
 
#include <zypp/ResFilters.h>
 
#endif // ZYPP_FILTER_H