ResFilters.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_RESFILTERS_H
#define ZYPP_RESFILTERS_H
 
#include <zypp/base/Functional.h>
#include <zypp/Filter.h>
#include <zypp/Resolvable.h>
 
#include <zypp/PoolItem.h>
#include <zypp/Repository.h>
 
#include <utility>

namespace zypp
{ 
  namespace resfilter
  { 


    //
    // Some ResObject attributes
    //

    template<class TRes>
      inline filter::ByKind byKind()
      { return filter::ByKind( ResTraits<TRes>::kind ); }

    struct ByName
    {
      ByName()
      {}
 
      ByName( std::string  name_r )
      : _name(std::move( name_r ))
      {}
 
      bool operator()( const ResObject::constPtr& p ) const
      {
        return p->name() == _name;
      }
 
      std::string _name;
    };

    struct ByRepository
    {
      ByRepository( Repository repository_r )
      : _alias( repository_r.info().alias() )
      {}
 
      ByRepository( std::string  alias_r )
      : _alias(std::move( alias_r ))
      {}
 
      bool operator()( const ResObject::constPtr& p ) const
      {
        return p->repoInfo().alias() == _alias;
      }
 
      std::string _alias;
    };

    template<class TCompare = CompareByEQ<Edition> >
      struct ByEdition
      {
        ByEdition( Edition  edition_r, TCompare cmp_r )
        : _edition(std::move( edition_r ))
        , _cmp( cmp_r )
        {}
 
        bool operator()( const 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
      {
        ByArch( const Arch & arch_r, TCompare cmp_r )
        : _arch( arch_r )
        , _cmp( cmp_r )
        {}
 
        bool operator()( const 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
    //

    struct ByInstalled
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isInstalled();
      }
    };

    struct ByUninstalled
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isUninstalled();
      }
    };

    struct ByTransact
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().transacts();
      }
    };

    struct ByLock
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isLocked();
      }
    };

    struct ByKeep
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isKept();
      }
    };

    struct ByRecommended
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isRecommended();
      }
    };

    struct BySuggested
    {
      bool operator()( const PoolItem & p ) const
      {
        return p.status().isSuggested();
      }
    };


  } // namespace resfilter

} // namespace zypp
#endif // ZYPP_RESFILTERS_H