PoolQueryResult.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_POOLQUERYRESULT_H
#define ZYPP_POOLQUERYRESULT_H
 
#include <iosfwd>
 
#include <zypp/base/Hash.h>
#include <zypp/base/Exception.h>
#include <zypp/sat/SolvIterMixin.h>
 
#include <zypp/PoolItem.h>
#include <zypp/PoolQuery.h>
 
namespace zypp
{ 
 
  //
  //    CLASS NAME : PoolQueryResult
  //
  class PoolQueryResult : public sat::SolvIterMixin<PoolQueryResult,std::unordered_set<sat::Solvable>::const_iterator>
  {
    public:
      typedef std::unordered_set<sat::Solvable> ResultSet;
      typedef ResultSet::size_type                      size_type;
      typedef ResultSet::const_iterator                 const_iterator;
 
    public:
      PoolQueryResult()
      {}
 
      explicit PoolQueryResult( sat::Solvable result_r )
      { operator+=( result_r ); }
 
      explicit PoolQueryResult( const PoolItem & result_r )
      { operator+=( result_r ); }
 
      explicit PoolQueryResult( const PoolQuery & query_r )
      { operator+=( query_r ); }
 
      template<class TQueryResultIter>
      PoolQueryResult( TQueryResultIter begin_r, TQueryResultIter end_r )
      {
        for_( it, begin_r, end_r )
        {
          operator+=( *it );
        }
      }
 
    public:
      bool empty() const
      { return _result.empty(); }
      size_type size() const
      { return _result.size(); }
      const_iterator begin() const
      { return _result.begin(); }
      const_iterator end() const
      { return _result.end(); }
 
      bool contains(sat::Solvable result_r ) const
      { return( _result.find( result_r ) != _result.end() ); }
      bool contains( const PoolItem & result_r ) const
      { return contains( result_r.satSolvable() ); }
 
    public:
      void clear()
      { _result.clear(); }
 
      PoolQueryResult & operator+=( const PoolQueryResult & query_r )
      {
        if ( ! query_r.empty() )
          _result.insert( query_r.begin(), query_r.end() );
        return *this;
      }
      PoolQueryResult & operator+=( const PoolQuery & query_r )
      {
        try
        {
          for_( it, query_r.begin(), query_r.end() )
            _result.insert( *it );
        }
        catch ( const Exception & )
        {}
        return *this;
      }
      PoolQueryResult & operator+=( sat::Solvable result_r )
      {
        _result.insert( result_r );
        return *this;
      }
      PoolQueryResult & operator+=( const PoolItem & result_r )
      {
        _result.insert( result_r.satSolvable() );
        return *this;
      }
 
      PoolQueryResult & operator-=( const PoolQueryResult & query_r )
      {
        if ( &query_r == this ) // catch self removal!
          clear();
        else
          for_( it, query_r.begin(), query_r.end() )
            _result.erase( *it );
        return *this;
      }
      PoolQueryResult & operator-=( const PoolQuery & query_r )
      {
        try
        {
          for_( it, query_r.begin(), query_r.end() )
            _result.erase( *it );
        }
        catch ( const Exception & )
        {}
        return *this;
      }
      PoolQueryResult & operator-=( sat::Solvable result_r )
      {
        _result.erase( result_r );
        return *this;
      }
      PoolQueryResult & operator-=( const PoolItem & result_r )
      {
        _result.erase( result_r.satSolvable() );
        return *this;
      }
 
    public:
      PoolQueryResult operator+( const PoolQueryResult & query_r ) const
      { return PoolQueryResult(*this) += query_r; }
      PoolQueryResult operator+( const PoolQuery & query_r ) const
      { return PoolQueryResult(*this) += query_r; }
      PoolQueryResult operator+( sat::Solvable result_r ) const
      { return PoolQueryResult(*this) += result_r; }
 
      PoolQueryResult operator-( const PoolQueryResult & query_r ) const
      { return PoolQueryResult(*this) -= query_r; }
      PoolQueryResult operator-( const PoolQuery & query_r ) const
      { return PoolQueryResult(*this) -= query_r; }
      PoolQueryResult operator-( sat::Solvable result_r ) const
      { return PoolQueryResult(*this) -= result_r; }
 
    private:
      ResultSet _result;
  };
 
  std::ostream & operator<<( std::ostream & str, const PoolQueryResult & obj );
 
} // namespace zypp
#endif // ZYPP_POOLQUERYRESULT_H