PoolQueryResult.h

Go to the documentation of this file.

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

#include <iosfwd>

#include "zypp/base/Tr1hash.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::tr1::unordered_set<sat::Solvable>::const_iterator>
  {
    public:
      typedef std::tr1::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 _QueryResultIter>
      PoolQueryResult( _QueryResultIter begin_r, _QueryResultIter 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