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( boost::mem_fun_ref( &sat::Solvable::supportsLocales ) )
        {}

        explicit ByLocaleSupport( const Locale & locale_r )
        : _sel( boost::bind( boost::mem_fun_ref( (LS1)&sat::Solvable::supportsLocale ), _1, locale_r ) )
        {}

        explicit ByLocaleSupport( const LocaleSet & locales_r )
        : _sel( boost::bind( boost::mem_fun_ref( (LS2)&sat::Solvable::supportsLocale ), _1, locales_r ) )
        {}

      public:
        bool operator()( const sat::Solvable & solv_r ) const
        { return _sel && _sel( solv_r ); }

        template<class _Solv>
        bool operator()( const _Solv & solv_r ) const
        { return operator()( solv_r.satSolvable() ); }

      private:
        function<bool(const sat::Solvable &)> _sel;
    };

    //
    //  CLASS NAME : ByKind
    //
    class ByKind
    {
      public:
        ByKind( const ResKind & kind_r )
        : _kind( kind_r )
        {}

      public:
        bool operator()( const sat::Solvable & solv_r ) const
        { return solv_r.isKind( _kind ); }

        template<class _Solv>
        bool operator()( const _Solv & solv_r ) const
        { return operator()( solv_r.satSolvable() ); }

      private:
        ResKind _kind;
    };

    template<class _Res>
    inline ByKind byKind()
    { return ByKind( ResTraits<_Res>::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 _Solv>
        bool operator()( const _Solv & 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 _Solv>
        SameItemAs( const _Solv & 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 _Solv>
        bool operator()( const _Solv & solv_r ) const
        { return operator()( solv_r.satSolvable() ); }

      private:
        sat::Solvable _item;
    };


  } // namespace filter
} // namespace zypp

#include "zypp/ResFilters.h"

#endif // ZYPP_FILTER_H