CapMatchHelper.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_CAPMATCHHELPER_H
#define ZYPP_CAPMATCHHELPER_H

#include "zypp/base/Algorithm.h"
#include "zypp/base/Function.h"
#include "zypp/ResPool.h"

namespace zypp
{ 

  class MatchesCapability
  {
  public:
    MatchesCapability( const Capability & lhs_r )
    : _lhs( lhs_r )
    {}

    bool operator()( const CapAndItem & capitem_r ) const
    { return operator()( capitem_r.cap ); }

    bool operator()( const Capability & rhs_r ) const
    { return( _lhs.matches( rhs_r ) == CapMatch::yes ); }

  private:
    const Capability & _lhs;
  };


  inline int forEachMatchIn( CapSet::const_iterator begin_r,
                             CapSet::const_iterator end_r,
                             const Capability & lhs_r,
                             function<bool(const Capability &)> action_r )
  {
    std::string index( lhs_r.index() );
    return invokeOnEach( begin_r, end_r,
                         MatchesCapability( lhs_r ), // filter
                         action_r );
  }

  inline int forEachMatchIn( const CapSet & capset_r,
                             const Capability & lhs_r,
                             function<bool(const Capability &)> action_r )
  {
    return invokeOnEach( capset_r.begin(), capset_r.end(),
                         MatchesCapability( lhs_r ), // filter
                         action_r );
  }

  inline int forEachMatchIn( const ResPool & pool_r, const Dep & dep_r,
                             const Capability & lhs_r,
                             function<bool(const CapAndItem &)> action_r )
  {
    std::string index( lhs_r.index() );
    return invokeOnEach( pool_r.byCapabilityIndexBegin( index, dep_r ),
                         pool_r.byCapabilityIndexEnd( index, dep_r ),
                         MatchesCapability( lhs_r ), // filter
                         action_r );
  }



  class ForEachMatchInCapSet
  {
  public:
    typedef function<bool(const Capability &, const Capability &)> Action;

  public:
    ForEachMatchInCapSet( const CapSet & set_r, const Action & action_r )
    : _set( set_r )
    , _action( action_r )
    {}

    bool operator()( const Capability & cap_r ) const
    {
      return( forEachMatchIn( _set, cap_r, bind( _action, _1, cap_r ) )
              >= 0 ); // i.e. _action did not return false
    }

  private:
    const CapSet & _set;
    Action         _action;
  };

  inline int forEachMatchIn( const CapSet & lhs_r,
                             const CapSet & rhs_r,
                             function<bool(const Capability &, const Capability &)> action_r )
  {
    return invokeOnEach( lhs_r.begin(), lhs_r.end(),
                         ForEachMatchInCapSet( rhs_r, action_r ) );
  }

  namespace capmatch_detail {
    struct AlwaysFalse
    {
      bool operator()( const Capability &, const Capability & ) const
      { return false; }
      bool operator()( const Capability & ) const
      { return false; }
    };
  }

  inline bool hasMatches( const CapSet & lhs_r, const Capability & rhs_r )
  {
    return( forEachMatchIn( lhs_r, rhs_r, capmatch_detail::AlwaysFalse() ) < 0 );
  }

  inline bool hasMatches( const CapSet & lhs_r, const CapSet & rhs_r )
  {
    return( forEachMatchIn( lhs_r, rhs_r, capmatch_detail::AlwaysFalse() ) < 0 );
  }



  class ForEachMatchInPool
  {
  public:
    typedef function<bool(const CapAndItem &)> Action;

  public:
    ForEachMatchInPool( const ResPool & pool_r,
                        const Dep &     dep_r,
                        const Action &  action_r )
    : _pool  ( pool_r )
    , _dep   ( dep_r )
    , _action( action_r )
    {}

    bool operator()( const Capability & cap_r ) const
    {
      return( forEachMatchIn( _pool, _dep, cap_r, _action )
              >= 0 ); // i.e. _action did not return false
    }

  private:
    ResPool _pool;
    Dep     _dep;
    Action  _action;
  };

  inline int forEachPoolItemMatchedBy( const ResPool &  pool_r,
                                        const PoolItem & poolitem_r,
                                        const Dep &      poolitemdep_r,
                                        function<bool(const CapAndItem &)> action_r )
  {
    return invokeOnEach( poolitem_r->dep(poolitemdep_r).begin(),
                         poolitem_r->dep(poolitemdep_r).end(),
                         ForEachMatchInPool( pool_r, Dep::PROVIDES, action_r ) );
  }

  inline int forEachPoolItemMatching( const ResPool &  pool_r,
                                      const Dep &      pooldep_r,
                                      const PoolItem & poolitem_r,
                                      function<bool(const CapAndItem &)> action_r )
  {
    return invokeOnEach( poolitem_r->dep(Dep::PROVIDES).begin(),
                         poolitem_r->dep(Dep::PROVIDES).end(),
                         ForEachMatchInPool( pool_r, pooldep_r, action_r ) );
  }

  struct OncePerPoolItem
  {
  public:
    typedef function<bool(const PoolItem &)> Action;

  public:
    explicit
    OncePerPoolItem( const PoolItem & self_r = PoolItem() )
    : _self  ( self_r )
    , _uset  ( new std::set<PoolItem> )
    {}

    OncePerPoolItem( const Action & action_r,
                     const PoolItem & self_r = PoolItem() )
    : _action( action_r )
    , _self  ( self_r )
    , _uset  ( new std::set<PoolItem> )
    {}

    bool operator()( const CapAndItem & cai_r ) const
    {
      if ( cai_r.item == _self ) // omit _self
        return true;
      // intentionally collect items in _uset even
      // if no _action specified.
      if ( _uset->insert( cai_r.item ).second
           && _action )
        return _action( cai_r.item );

      return true;
    }

    const std::set<PoolItem> & collectedItems() const
    { return *_uset; }

  private:
    Action   _action;
    PoolItem _self;
    shared_ptr<std::set<PoolItem> > _uset;
  };



} // namespace zypp
#endif // ZYPP_CAPMATCHHELPER_H

---