ResFilters.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_RESFILTERS_H
#define ZYPP_RESFILTERS_H
 
#include <boost/function.hpp>
 
#include <zypp/base/Functional.h>
#include <zypp/Filter.h>
#include <zypp/Resolvable.h>
 
#include <zypp/PoolItem.h>
#include <zypp/Repository.h>
 
namespace zypp
{ 
  namespace resfilter
  { 
 
    //
    // Some ResObject attributes
    //
 
    typedef std::unary_function<ResObject::constPtr, bool> ResObjectFilterFunctor;
    typedef boost::function<bool ( ResObject::constPtr )> ResFilter;
 
    template<class TRes>
      inline filter::ByKind byKind()
      { return filter::ByKind( ResTraits<TRes>::kind ); }
 
    struct ByName : public ResObjectFilterFunctor
    {
      ByName()
      {}
 
      ByName( const std::string & name_r )
      : _name( name_r )
      {}
 
      bool operator()( ResObject::constPtr p ) const
      {
        return p->name() == _name;
      }
 
      std::string _name;
    };
 
    struct ByRepository : public ResObjectFilterFunctor
    {
      ByRepository( Repository repository_r )
      : _alias( repository_r.info().alias() )
      {}
 
      ByRepository( const std::string & alias_r )
      : _alias( alias_r )
      {}
 
      bool operator()( ResObject::constPtr p ) const
      {
        return p->repoInfo().alias() == _alias;
      }
 
      std::string _alias;
    };
 
    template<class TCompare = CompareByEQ<Edition> >
      struct ByEdition : public ResObjectFilterFunctor
      {
        ByEdition( const Edition & edition_r, TCompare cmp_r )
        : _edition( edition_r )
        , _cmp( cmp_r )
        {}
 
        bool operator()( ResObject::constPtr p ) const
        {
          return _cmp( p->edition(), _edition );
        }
 
        Edition  _edition;
        TCompare _cmp;
      };
 
    template<class TCompare>
      ByEdition<TCompare> byEdition( const Edition & edition_r, TCompare cmp_r )
      { return ByEdition<TCompare>( edition_r, cmp_r ); }
 
    template<class TCompare>
      ByEdition<TCompare> byEdition( const Edition & edition_r )
      { return byEdition( edition_r, TCompare() ); }
 
 
    template<class TCompare = CompareByEQ<Arch> >
      struct ByArch : public ResObjectFilterFunctor
      {
        ByArch( const Arch & arch_r, TCompare cmp_r )
        : _arch( arch_r )
        , _cmp( cmp_r )
        {}
 
        bool operator()( ResObject::constPtr p ) const
        {
          return _cmp( p->arch(), _arch );
        }
 
        Arch  _arch;
        TCompare _cmp;
      };
 
    template<class TCompare>
      ByArch<TCompare> byArch( const Arch & arch_r, TCompare cmp_r )
      { return ByArch<TCompare>( arch_r, cmp_r ); }
 
    template<class TCompare>
      ByArch<TCompare> byArch( const Arch & arch_r )
      { return byArch( arch_r, TCompare() ); }
 
 
 
    //
    // Some PoolItem attributes
    //
 
    typedef std::unary_function<PoolItem, bool> PoolItemFilterFunctor;
 
    struct ByInstalled : public PoolItemFilterFunctor
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isInstalled();
      }
    };
 
    struct ByUninstalled : public PoolItemFilterFunctor
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isUninstalled();
      }
    };
 
    struct ByTransact : public PoolItemFilterFunctor
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().transacts();
      }
    };
 
    struct ByLock : public PoolItemFilterFunctor
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isLocked();
      }
    };
 
    struct ByKeep : public PoolItemFilterFunctor
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isKept();
      }
    };
 
    struct ByRecommended : public PoolItemFilterFunctor
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isRecommended();
      }
    };
 
    struct BySuggested : public PoolItemFilterFunctor
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isSuggested();
      }
    };
 
 
  } // namespace resfilter
} // namespace zypp
#endif // ZYPP_RESFILTERS_H