SolvIterMixin.h

Go to the documentation of this file.

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

#include <iosfwd>

#include <zypp-core/base/PtrTypes.h>
#include <zypp-core/base/Iterator.h>
#include <zypp-core/base/Hash.h>

#include <zypp/sat/Solvable.h>
#include <zypp/PoolItem.h>
#include <zypp/ui/Selectable.h>

namespace zypp
{ 

  namespace sat
  { 

    class Solvable;
    //class asSolvable; // transform functor

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

        using Umap = std::unordered_map<sat::detail::IdType,sat::detail::SolvableIdType>;
        UnifyByIdent2()
          : _umap( new Umap )
        {}
        shared_ptr<Umap> _umap;
      };

#if LEGACY(1735)
      // Keep legacy version to stay binary compatible.
      // Recompiled code will use UnifyByIdent2.
      struct ZYPP_API UnifyByIdent
      {
        bool operator()( const Solvable & solv_r ) const;

        using Uset = std::unordered_set<unsigned int>;
        UnifyByIdent()
          : _uset( new Uset )
        {}
        shared_ptr<Uset> _uset;
      };
#endif
    } // namespace solvitermixin_detail


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

      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 TSolv>
        bool contains( const TSolv & solv_r ) const
        {
          Solvable solv( asSolvable()( solv_r ) );
          for_( it, self().begin(), self().end() )
            if ( *it == solv )
              return true;
          return false;
        }

      public:
        using Solvable_iterator = DerivedSolvable_iterator;
        Solvable_iterator solvableBegin() const
        { return self().begin(); }
        Solvable_iterator solvableEnd() const
        { return self().end(); }
        Iterable<Solvable_iterator> solvable() const
        { return makeIterable( solvableBegin(), solvableEnd() ); }

        using PoolItem_iterator = transform_iterator<asPoolItem, Solvable_iterator>;
        PoolItem_iterator poolItemBegin() const
        { return make_transform_iterator( solvableBegin(), asPoolItem() ); }
        PoolItem_iterator poolItemEnd() const
        { return make_transform_iterator( solvableEnd(), asPoolItem() ); }
        Iterable<PoolItem_iterator> poolItem() const
        { return makeIterable( poolItemBegin(), poolItemEnd() ); }

      private:
        using UnifiedSolvable_iterator = filter_iterator<solvitermixin_detail::UnifyByIdent2, Solvable_iterator>;
      public:
        using Selectable_iterator = transform_iterator<ui::asSelectable, UnifiedSolvable_iterator>;
        Selectable_iterator selectableBegin() const
        { return make_transform_iterator( unifiedSolvableBegin(), ui::asSelectable() ); }
        Selectable_iterator selectableEnd() const
        { return make_transform_iterator( unifiedSolvableEnd(), ui::asSelectable() ); }
        Iterable<Selectable_iterator> selectable() const
        { return makeIterable( selectableBegin(), selectableEnd() ); }

      private:
        UnifiedSolvable_iterator unifiedSolvableBegin() const
        { return make_filter_iterator( solvitermixin_detail::UnifyByIdent2(), solvableBegin(), solvableEnd() ); }
        UnifiedSolvable_iterator unifiedSolvableEnd() const
        { return make_filter_iterator( solvitermixin_detail::UnifyByIdent2(), solvableEnd(), solvableEnd() ); }
        Iterable<UnifiedSolvable_iterator> unifiedSolvable() const
        { return makeIterable( unifiedSolvableBegin(), unifiedSolvableEnd() ); }
      private:
        const Derived & self() const
        { return *static_cast<const Derived*>( this ); }
      protected:
        SolvIterMixin() {}
        ~SolvIterMixin() {}
        SolvIterMixin(const SolvIterMixin &) = default;
        SolvIterMixin & operator=(const SolvIterMixin &) = default;
        SolvIterMixin(SolvIterMixin &&) noexcept = default;
        SolvIterMixin &operator=(SolvIterMixin &&) noexcept = default;
     };

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