SolvIterMixin.h

Go to the documentation of this file.

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

#include <iosfwd>

#include "zypp/base/PtrTypes.h"
#include "zypp/base/Iterator.h"
#include "zypp/base/Tr1hash.h"

#include "zypp/sat/Solvable.h"

namespace zypp
{ 

  class PoolItem;
  class asPoolItem; // transform functor

  namespace ui
  {
    class asSelectable; // transform functor
  }

  namespace sat
  { 

    class Solvable;
    class asSolvable; // transform functor

    namespace solvitermixin_detail
    {
      struct UnifyByIdent
      {
        bool operator()( const Solvable & solv_r ) const;

        typedef std::tr1::unordered_set<unsigned> Uset;
        UnifyByIdent()
          : _uset( new Uset )
        {}
        shared_ptr<Uset> _uset;
      };


    } // namespace solvitermixin_detail


    //
    //  CLASS NAME : SolvIterMixin<Derived,DerivedSolvable_iterator>
    //
    template <class Derived,class DerivedSolvable_iterator>
    class SolvIterMixin
    {
      public:
        typedef size_t size_type;

      public:
        bool empty() const
        { return( self().begin() == self().end() ); }

        size_type size() const
        { size_type s = 0; for_( it, self().begin(), self().end() ) ++s; return s;}

        template<class _Solv>
        bool contains( const _Solv & solv_r ) const
        {
          Solvable solv( asSolvable()( solv_r ) );
          for_( it, self().begin(), self().end() )
            if ( *it == solv )
              return true;
          return false;
        }

      public:
        typedef  DerivedSolvable_iterator Solvable_iterator;
        Solvable_iterator solvableBegin() const
        { return self().begin(); }
        Solvable_iterator solvableEnd() const
        { return self().end(); }

        typedef transform_iterator<asPoolItem,Solvable_iterator> PoolItem_iterator;
        PoolItem_iterator poolItemBegin() const
        { return make_transform_iterator( solvableBegin(), asPoolItem() ); }
        PoolItem_iterator poolItemEnd() const
        { return make_transform_iterator( solvableEnd(), asPoolItem() ); }

      private:
        typedef filter_iterator<solvitermixin_detail::UnifyByIdent,Solvable_iterator> UnifiedSolvable_iterator;
      public:
        typedef transform_iterator<ui::asSelectable,UnifiedSolvable_iterator> Selectable_iterator;
        Selectable_iterator selectableBegin() const
        { return make_transform_iterator( unifiedSolvableBegin(), ui::asSelectable() ); }
        Selectable_iterator selectableEnd() const
        { return make_transform_iterator( unifiedSolvableEnd(), ui::asSelectable() ); }

      private:
        UnifiedSolvable_iterator unifiedSolvableBegin() const
        { return make_filter_iterator( solvitermixin_detail::UnifyByIdent(), solvableBegin(), solvableEnd() ); }
        UnifiedSolvable_iterator unifiedSolvableEnd() const
        { return make_filter_iterator( solvitermixin_detail::UnifyByIdent(), solvableEnd(), solvableEnd() );; }
      private:
        const Derived & self() const
        { return *static_cast<const Derived*>( this ); }
      protected:
        SolvIterMixin() {}
        ~SolvIterMixin() {}
        SolvIterMixin(const SolvIterMixin &) {}
        void operator=(const SolvIterMixin &) {}
     };

  } // namespace sat
} // namespace zypp
#endif // ZYPP_SAT_SOLVITERMIXIN_H