Filter.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_FILTER_H
#define ZYPP_FILTER_H
 
#include <iosfwd>
#include <utility>
 
#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:
        using LS1 = bool (sat::Solvable::*)(const Locale &) const;
        using LS2 = bool (sat::Solvable::*)(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( ResKind  kind_r )
        : _kind(std::move( 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:
        using Predicate = bool (ResStatus::*)() 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