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/Resolvable.h"
#include "zypp/CapFilters.h"

#include "zypp/Source.h"

#include "zypp/PoolItem.h"
#include "zypp/CapAndItem.h"

namespace zypp
{ 

  namespace resfilter
  { 


    //
    // Some ResObject attributes
    //

    typedef std::unary_function<ResObject::constPtr, bool> ResObjectFilterFunctor;
    typedef boost::function<bool ( ResObject::constPtr )> ResFilter;

    struct ByKind : public ResObjectFilterFunctor
    {
      ByKind( const ResObject::Kind & kind_r )
      : _kind( kind_r )
      {}

      bool operator()( ResObject::constPtr p ) const
      {
        return p->kind() == _kind;
      }

      ResObject::Kind _kind;
    };

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

    struct ByName : public ResObjectFilterFunctor
    {
      ByName( const std::string & name_r )
      : _name( name_r )
      {}

      bool operator()( ResObject::constPtr p ) const
      {
        return p->name() == _name;
      }

      std::string _name;
    };


    struct BySource : public ResObjectFilterFunctor
    {
      BySource( Source_Ref source_r )
      : _source( source_r )
      {}

      bool operator()( ResObject::constPtr p ) const
      {
        return p->source() == _source;
      }

      Source_Ref _source;
    };


    template<class _Compare = CompareByEQ<Edition> >
      struct ByEdition : public ResObjectFilterFunctor
      {
        ByEdition( const Edition & edition_r,
                   _Compare cmp_r )
        : _edition( edition_r )
        , _cmp( cmp_r )
        {}

        bool operator()( ResObject::constPtr p ) const
        {
          return _cmp( p->edition(), _edition );
        }

        Edition  _edition;
        _Compare _cmp;
      };

    template<class _Compare>
      ByEdition<_Compare> byEdition( const Edition & edition_r, _Compare cmp_r )
      { return ByEdition<_Compare>( edition_r, cmp_r ); }

    template<class _Compare>
      ByEdition<_Compare> byEdition( const Edition & edition_r )
      { return byEdition( edition_r, _Compare() ); }


    template<class _Compare = CompareByEQ<Arch> >
      struct ByArch : public ResObjectFilterFunctor
      {
        ByArch( const Arch & arch_r,
                   _Compare cmp_r )
        : _arch( arch_r )
        , _cmp( cmp_r )
        {}

        bool operator()( ResObject::constPtr p ) const
        {
          return _cmp( p->arch(), _arch );
        }

        Arch  _arch;
        _Compare _cmp;
      };

    template<class _Compare>
      ByArch<_Compare> byArch( const Arch & arch_r, _Compare cmp_r )
      { return ByArch<_Compare>( arch_r, cmp_r ); }

    template<class _Compare>
      ByArch<_Compare> byArch( const Arch & arch_r )
      { return byArch( arch_r, _Compare() ); }



    //
    // 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 ByCapabilityIndex
    {
      bool operator()( const CapAndItem & /*cai*/ ) const
      {
        return true;                    // its all in the PoolImpl !
      }
    };


    struct ByCapMatch
    {
      bool operator()( const CapAndItem & cai ) const
      {
        return cai.cap.matches( _cap ) == CapMatch::yes;
      }
      ByCapMatch( const Capability & cap_r )
        : _cap( cap_r )
      {}
      Capability _cap;
    };


    struct ByCaIUninstalled
    {
      bool operator()( const CapAndItem & cai ) const
      {
        return cai.item.status().isUninstalled();
      }
    };

    struct ByCaIInstalled
    {
      bool operator()( const CapAndItem & cai ) const
      {
        return cai.item.status().isInstalled();
      }
    };

    struct ByCaITransact
    {
      bool operator()( const CapAndItem & cai ) const
      {
        return cai.item.status().transacts();
      }
    };

    struct ByCaINotTransact
    {
      bool operator()( const CapAndItem & cai ) const
      {
        return !(cai.item.status().transacts());
      }
    };


    struct ByCaIKind
    {
      ByCaIKind( const ResObject::Kind & kind_r )
      : _kind( kind_r )
      {}

      bool operator()( const CapAndItem & cai ) const
      {
        return cai.item->kind() == _kind;
      }

      ResObject::Kind _kind;
    };

    template<class _Res>
      inline ByCaIKind byCaIKind()
      { return ByCaIKind( ResTraits<_Res>::kind ); }



  } // namespace resfilter
} // namespace zypp
#endif // ZYPP_RESFILTERS_H

---