ResPool.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_RESPOOL_H
#define ZYPP_RESPOOL_H
 
#include <iosfwd>
 
#include <zypp/APIConfig.h>
#include <zypp/base/Iterator.h>
 
#include <zypp/pool/PoolTraits.h>
#include <zypp/PoolItem.h>
#include <zypp/Filter.h>
 
namespace zypp
{ 
 
  class SerialNumber;
  class ResPoolProxy;
  class Resolver;
 
  //
  //    CLASS NAME : ResPool
  //
  class ResPool
  {
    friend std::ostream & operator<<( std::ostream & str, const ResPool & obj );
 
    public:
      typedef PoolItem                                   value_type;
      typedef pool::PoolTraits::size_type                size_type;
      typedef pool::PoolTraits::const_iterator           const_iterator;
      typedef pool::PoolTraits::repository_iterator      repository_iterator;
 
    public:
      static ResPool instance();
 
      ResPoolProxy proxy() const;
 
      Resolver & resolver() const;
 
    public:
      const SerialNumber & serial() const;
 
    public:
      bool empty() const;
      size_type size() const;
 
      const_iterator begin() const
      { return make_filter_begin( pool::ByPoolItem(), store() ); }
      const_iterator end() const
      { return make_filter_end( pool::ByPoolItem(), store() ); }
 
    public:
      PoolItem find( const sat::Solvable & slv_r ) const;
      PoolItem find( const ResObject::constPtr & resolvable_r ) const
      { return( resolvable_r ? find( resolvable_r->satSolvable() ) : PoolItem() ); }
 
    public:
      template<class TFilter>
      filter_iterator<TFilter,const_iterator> filterBegin( const TFilter & filter_r ) const
      { return make_filter_begin( filter_r, *this ); }
 
      template<class TFilter>
      filter_iterator<TFilter,const_iterator> filterEnd( const TFilter & filter_r ) const
      { return make_filter_end( filter_r, *this ); }
 
      template<class TFilter>
      Iterable<filter_iterator<TFilter,const_iterator> > filter( const TFilter & filter_r ) const
      { return makeIterable( filterBegin( filter_r ), filterEnd( filter_r ) ); }
 
      filter_iterator<filter::ByStatus,const_iterator> byStatusBegin( const filter::ByStatus & filter_r ) const
      { return make_filter_begin( filter_r, *this ); }
 
      filter_iterator<filter::ByStatus,const_iterator> byStatusEnd( const filter::ByStatus & filter_r ) const
      { return make_filter_end( filter_r, *this ); }
 
      Iterable<filter_iterator<filter::ByStatus,const_iterator> > byStatus( const filter::ByStatus & filter_r ) const
      { return makeIterable( byStatusBegin( filter_r ), byStatusEnd( filter_r ) ); }
 
    public:
      typedef pool::ByIdent                       ByIdent;
      typedef pool::PoolTraits::byIdent_iterator  byIdent_iterator;
 
      byIdent_iterator byIdentBegin( const ByIdent & ident_r ) const
      {
        return make_transform_iterator( id2item().equal_range( ident_r.get() ).first,
                                        pool::PoolTraits::Id2ItemValueSelector() );
      }
 
      byIdent_iterator byIdentBegin( ResKind kind_r, IdString name_r ) const
      { return byIdentBegin( ByIdent(kind_r,name_r) ); }
 
      byIdent_iterator byIdentBegin( ResKind kind_r, const C_Str & name_r ) const
      { return byIdentBegin( ByIdent(kind_r,name_r) ); }
 
      template<class TRes>
      byIdent_iterator byIdentBegin( IdString name_r ) const
      { return byIdentBegin( ByIdent(ResTraits<TRes>::kind,name_r) ); }
 
      template<class TRes>
      byIdent_iterator byIdentBegin( const C_Str & name_r ) const
      { return byIdentBegin( ByIdent(ResTraits<TRes>::kind,name_r) ); }
 
      byIdent_iterator byIdentBegin( const PoolItem & pi_r ) const
      { return byIdentBegin( ByIdent(pi_r.satSolvable()) ); }
      byIdent_iterator byIdentBegin( sat::Solvable slv_r ) const
      { return byIdentBegin( ByIdent(slv_r) ); }
      byIdent_iterator byIdentBegin( IdString ident_r ) const
      { return byIdentBegin( ByIdent(ident_r) ); }
 
 
      byIdent_iterator byIdentEnd( const ByIdent & ident_r ) const
      {
        return make_transform_iterator( id2item().equal_range( ident_r.get() ).second,
                                        pool::PoolTraits::Id2ItemValueSelector() );
      }
 
      byIdent_iterator byIdentEnd( ResKind kind_r, IdString name_r ) const
      { return byIdentEnd( ByIdent(kind_r,name_r) ); }
 
      byIdent_iterator byIdentEnd( ResKind kind_r, const C_Str & name_r ) const
      { return byIdentEnd( ByIdent(kind_r,name_r) ); }
 
      template<class TRes>
      byIdent_iterator byIdentEnd( IdString name_r ) const
      { return byIdentEnd( ByIdent(ResTraits<TRes>::kind,name_r) ); }
 
      template<class TRes>
      byIdent_iterator byIdentEnd( const C_Str & name_r ) const
      { return byIdentEnd( ByIdent(ResTraits<TRes>::kind,name_r) ); }
 
      byIdent_iterator byIdentEnd( const PoolItem & pi_r ) const
      { return byIdentEnd( ByIdent(pi_r.satSolvable()) ); }
      byIdent_iterator byIdentEnd( sat::Solvable slv_r ) const
      { return byIdentEnd( ByIdent(slv_r) ); }
      byIdent_iterator byIdentEnd( IdString ident_r ) const
      { return byIdentEnd( ByIdent(ident_r) ); }
 
 
      Iterable<byIdent_iterator> byIdent( const ByIdent & ident_r ) const
      { return makeIterable( byIdentBegin( ident_r ), byIdentEnd( ident_r ) ); }
 
      Iterable<byIdent_iterator> byIdent( ResKind kind_r, IdString name_r ) const
      { return makeIterable( byIdentBegin( kind_r, name_r ), byIdentEnd(  kind_r, name_r ) ); }
 
      Iterable<byIdent_iterator> byIdent( ResKind kind_r, const C_Str & name_r ) const
      { return makeIterable( byIdentBegin(  kind_r, name_r ), byIdentEnd(  kind_r, name_r ) ); }
 
      template<class TRes>
      Iterable<byIdent_iterator> byIdent( IdString name_r ) const
      { return makeIterable( byIdentBegin<TRes>( name_r ), byIdentEnd<TRes>( name_r ) ); }
 
      template<class TRes>
      Iterable<byIdent_iterator> byIdent( const C_Str & name_r ) const
      { return makeIterable( byIdentBegin<TRes>( name_r ), byIdentEnd<TRes>( name_r ) ); }
 
      Iterable<byIdent_iterator> byIdent( const PoolItem & pi_r ) const
      { return makeIterable( byIdentBegin( pi_r ), byIdentEnd( pi_r ) ); }
 
      Iterable<byIdent_iterator> byIdent(sat::Solvable slv_r ) const
      { return makeIterable( byIdentBegin( slv_r ), byIdentEnd( slv_r ) ); }
 
      Iterable<byIdent_iterator> byIdent( IdString ident_r ) const
      { return makeIterable( byIdentBegin( ident_r ), byIdentEnd( ident_r ) ); }
 
    public:
      typedef filter::ByKind ByKind;
      typedef filter_iterator<ByKind,const_iterator> byKind_iterator;
 
      byKind_iterator byKindBegin( const ResKind & kind_r ) const
      { return make_filter_begin( ByKind(kind_r), *this ); }
 
      template<class TRes>
          byKind_iterator byKindBegin() const
      { return make_filter_begin( resfilter::byKind<TRes>(), *this ); }
 
      byKind_iterator byKindEnd( const ResKind & kind_r ) const
      { return make_filter_end( ByKind(kind_r), *this ); }
 
      template<class TRes>
          byKind_iterator byKindEnd() const
      { return make_filter_end( resfilter::byKind<TRes>(), *this ); }
 
      Iterable<byKind_iterator> byKind( const ResKind & kind_r ) const
      { return makeIterable( byKindBegin( kind_r ), byKindEnd( kind_r ) ); }
 
      template<class TRes>
      Iterable<byKind_iterator> byKind() const
      { return makeIterable( byKindBegin<TRes>(), byKindEnd<TRes>() ); }
 
    public:
      typedef zypp::resfilter::ByName ByName;
      typedef filter_iterator<ByName,const_iterator> byName_iterator;
 
      byName_iterator byNameBegin( const std::string & name_r ) const
      { return make_filter_begin( ByName(name_r), *this ); }
 
      byName_iterator byNameEnd( const std::string & name_r ) const
      { return make_filter_end( ByName(name_r), *this ); }
 
      Iterable<byName_iterator> byName( const std::string & name_r ) const
      { return makeIterable( byNameBegin( name_r ), byNameEnd( name_r ) ); }
 
    public:
      class EstablishedStates
      {
      public:
        ~EstablishedStates();
        typedef std::map<PoolItem,ResStatus::ValidateValue> ChangedPseudoInstalled;
        ChangedPseudoInstalled changedPseudoInstalled() const;
      private:
        class Impl;
        RW_pointer<Impl> _pimpl;
      private:
        friend class pool::PoolImpl;
        EstablishedStates( shared_ptr<Impl> pimpl_r )
        : _pimpl { pimpl_r }
        {}
      };
 
      EstablishedStates establishedStates() const;
 
      typedef EstablishedStates::ChangedPseudoInstalled ChangedPseudoInstalled;
 
      ChangedPseudoInstalled changedPseudoInstalled() const
      { return establishedStates().changedPseudoInstalled(); }
   public:
      size_type knownRepositoriesSize() const;
 
      repository_iterator knownRepositoriesBegin() const;
 
      repository_iterator knownRepositoriesEnd() const;
 
      Repository reposFind( const std::string & alias_r ) const;
 
      Iterable<repository_iterator> knownRepositories() const
      { return makeIterable( knownRepositoriesBegin(), knownRepositoriesEnd() ); }
 
    public:
      void setRequestedLocales( const LocaleSet & locales_r );
 
      bool addRequestedLocale( const Locale & locale_r );
 
      bool eraseRequestedLocale( const Locale & locale_r );
 
      const LocaleSet & getRequestedLocales() const;
 
      bool isRequestedLocale( const Locale & locale_r ) const;
 
      const LocaleSet & getAvailableLocales() const;
 
      bool isAvailableLocale( const Locale & locale_r ) const;
 
    public:
      typedef pool::PoolTraits::HardLockQueries           HardLockQueries;
      typedef pool::PoolTraits::hardLockQueries_iterator  hardLockQueries_iterator;
 
      bool hardLockQueriesEmpty() const;
      size_type hardLockQueriesSize() const;
      hardLockQueries_iterator hardLockQueriesBegin() const;
      hardLockQueries_iterator hardLockQueriesEnd() const;
 
      Iterable<hardLockQueries_iterator> hardLockQueries() const
      { return makeIterable( hardLockQueriesBegin(), hardLockQueriesEnd() ); }
 
      void setHardLockQueries( const HardLockQueries & newLocks_r );
 
      void getHardLockQueries( HardLockQueries & activeLocks_r );
 
    private:
      const pool::PoolTraits::ItemContainerT & store() const;
      const pool::PoolTraits::Id2ItemT & id2item() const;
 
    private:
      ResPool( pool::PoolTraits::Impl_Ptr impl_r );
      RW_pointer<pool::PoolTraits::Impl> _pimpl;
  };
 
  std::ostream & operator<<( std::ostream & str, const ResPool & obj );
 
} // namespace zypp
 
#include <zypp/ResPoolProxy.h>
 
#endif // ZYPP_RESPOOL_H