#include <iosfwd>
-#include "zypp/base/Deprecated.h"
+#include "zypp/APIConfig.h"
#include "zypp/base/Iterator.h"
#include "zypp/pool/PoolTraits.h"
class SerialNumber;
class ResPoolProxy;
+ class Resolver;
///////////////////////////////////////////////////////////////////
//
* an ordinary filter iterator. Do not provide filter iterators
* here, if there is no index table for it.
*
+ * For most (*Begin,*End) iterator-pairs there's also an \ref Iterable
+ * provided, so you can use then in range-based for loops:
+ * \code
+ * // classic:
+ * for_( it, pool.filterBegin(myfilter), pool.filterEnd(myfilter) )
+ * { ... }
+ *
+ * // range based:
+ * for ( const PoolItem & pi : pool.filter(myfilter) )
+ * { ... }
+ * \endcode
+ *
* \include n_ResPool_nomorenameiter
*/
class ResPool
/** preliminary */
ResPoolProxy proxy() const;
+ /** The Resolver */
+ Resolver & resolver() const;
+
public:
/** The pools serial number. Changing whenever the
* whenever the content changes. (Resolvables or
{ return( resolvable_r ? find( resolvable_r->satSolvable() ) : PoolItem() ); }
public:
- /** \name Iterate over all PoolItems matching a \c _Filter. */
+ /** \name Iterate over all PoolItems matching a \c TFilter. */
+ //@{
+ 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 ) ); }
+ //@}
+
+ /** \name Iterate over all PoolItems by status.
+ *
+ * Simply pass the \ref ResStatus predicate you want to use as filter:
+ * \code
+ * // iterate over all orphaned items:
+ * for_( it, pool.byStatusBegin(&ResStatus::isOrphaned), pool.byStatusEnd(&ResStatus::isOrphaned) )
+ * {...}
+ * \endcode
+ *
+ * Or use \ref filter::ByStatus in more complex queries:
+ * \code
+ * // iterate over all (orphaned and recommended) items:
+ * functor::Chain<filter::ByStatus,filter::ByStatus> myfilter( filter::ByStatus(&ResStatus::isOrphaned),
+ * filter::ByStatus(&ResStatus::isRecommended) );
+ * for_( it, pool.filterBegin(myfilter), pool.filterEnd(myfilter) )
+ * { ... }
+ * \endcode
+ */
//@{
- template<class _Filter>
- filter_iterator<_Filter,const_iterator> filterBegin( const _Filter & filter_r ) const
+ filter_iterator<filter::ByStatus,const_iterator> byStatusBegin( const filter::ByStatus & filter_r ) const
{ return make_filter_begin( filter_r, *this ); }
- template<class _Filter>
- filter_iterator<_Filter,const_iterator> filterEnd( const _Filter & filter_r ) const
+ 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:
byIdent_iterator byIdentBegin( ResKind kind_r, const C_Str & name_r ) const
{ return byIdentBegin( ByIdent(kind_r,name_r) ); }
- template<class _Res>
+ template<class TRes>
byIdent_iterator byIdentBegin( IdString name_r ) const
- { return byIdentBegin( ByIdent(ResTraits<_Res>::kind,name_r) ); }
+ { return byIdentBegin( ByIdent(ResTraits<TRes>::kind,name_r) ); }
- template<class _Res>
+ template<class TRes>
byIdent_iterator byIdentBegin( const C_Str & name_r ) const
- { return byIdentBegin( ByIdent(ResTraits<_Res>::kind,name_r) ); }
+ { return byIdentBegin( ByIdent(ResTraits<TRes>::kind,name_r) ); }
/** Derive name and kind from \ref PoolItem. */
byIdent_iterator byIdentBegin( const PoolItem & pi_r ) const
byIdent_iterator byIdentEnd( ResKind kind_r, const C_Str & name_r ) const
{ return byIdentEnd( ByIdent(kind_r,name_r) ); }
- template<class _Res>
+ template<class TRes>
byIdent_iterator byIdentEnd( IdString name_r ) const
- { return byIdentEnd( ByIdent(ResTraits<_Res>::kind,name_r) ); }
+ { return byIdentEnd( ByIdent(ResTraits<TRes>::kind,name_r) ); }
- template<class _Res>
+ template<class TRes>
byIdent_iterator byIdentEnd( const C_Str & name_r ) const
- { return byIdentEnd( ByIdent(ResTraits<_Res>::kind,name_r) ); }
+ { return byIdentEnd( ByIdent(ResTraits<TRes>::kind,name_r) ); }
/** Derive name and kind from \ref PoolItem. */
byIdent_iterator byIdentEnd( const PoolItem & pi_r ) const
/** Takes a \ref sat::Solvable::ident string. */
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:
byKind_iterator byKindBegin( const ResKind & kind_r ) const
{ return make_filter_begin( ByKind(kind_r), *this ); }
- template<class _Res>
+ template<class TRes>
byKind_iterator byKindBegin() const
- { return make_filter_begin( resfilter::byKind<_Res>(), *this ); }
+ { 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 _Res>
+ template<class TRes>
byKind_iterator byKindEnd() const
- { return make_filter_end( resfilter::byKind<_Res>(), *this ); }
+ { 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:
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:
- /** \name Special iterators. */
+ /** \name Misc Data. */
//@{
-
- /** \name Iterate over all satisfied products.
- * \note Is satisfied status is computed and updated on each solver
- * run. So it does not reflect any changes made since the last solver run.
+ ///////////////////////////////////////////////////////////////////
+ /// A copy of the Pools initial ValidateValues of pseudo installed items.
+ ///
+ /// AKA Patch status. Whenever the Pools content changes, the status
+ /// of pseudo installed items (like Patches) is computed (roughly whether
+ /// their dependencies are broken or satisfied) and remembered.
+ ///
+ /// Comparing the items established state against it's current state
+ /// tells how the current transaction would influence the item (break
+ /// or repair a Patch).
+ ///
+ class EstablishedStates
+ {
+ public:
+ ~EstablishedStates();
+ /** Map holding pseudo installed items where current and established status differ. */
+ typedef std::map<PoolItem,ResStatus::ValidateValue> ChangedPseudoInstalled;
+ /** Return all pseudo installed items whose current state differs from the established one */
+ ChangedPseudoInstalled changedPseudoInstalled() const;
+ private:
+ class Impl;
+ RW_pointer<Impl> _pimpl;
+ private:
+ friend class pool::PoolImpl;
+ /** Factory: \ref ResPool::establishedStates */
+ EstablishedStates( shared_ptr<Impl> pimpl_r )
+ : _pimpl { pimpl_r }
+ {}
+ };
+ ///////////////////////////////////////////////////////////////////
+
+ /** Factory for \ref EstablishedStates.
+ * A few internal algorithms benefit from keeping an instance across pool
+ * content changes. User code usually want's to call \ref changedPseudoInstalled
+ * directly.
*/
- //@{
- typedef filter_iterator<filter::SatisfiedProducts,const_iterator> satisfiedProducts_iterator;
+ EstablishedStates establishedStates() const;
- satisfiedProducts_iterator satisfiedProductsBegin() const
- { return filterBegin( filter::SatisfiedProducts() ); }
-
- satisfiedProducts_iterator satisfiedProductsEnd() const
- { return filterEnd( filter::SatisfiedProducts() ); }
- //@}
+ /** Map holding pseudo installed items where current and established status differ. */
+ typedef EstablishedStates::ChangedPseudoInstalled ChangedPseudoInstalled;
+ /** Return all pseudo installed items whose current state differs from their initial one.
+ * E.g. a Patch may become SATISFIED by updating the packages it refers to.
+ * For this to happen it does not matter whether you selected the Patch or
+ * whether you selected the individual Packages.
+ * A Patches status is computed and updated with every solver run.
+ */
+ ChangedPseudoInstalled changedPseudoInstalled() const
+ { return establishedStates().changedPseudoInstalled(); }
//@}
public:
/** \name Iterate over all Repositories that contribute ResObjects.
repository_iterator knownRepositoriesBegin() const;
repository_iterator knownRepositoriesEnd() const;
+
+ /** Find a \ref Repository named \c alias_r.
+ * Returns \ref Repository::noRepository if there is no such \ref Repository.
+ */
+ Repository reposFind( const std::string & alias_r ) const;
+
+ Iterable<repository_iterator> knownRepositories() const
+ { return makeIterable( knownRepositoriesBegin(), knownRepositoriesEnd() ); }
//@}
public:
*/
const LocaleSet & getRequestedLocales() const;
- /** Wheter this \ref Locale is in the set of requested locales. */
+ /** Whether this \ref Locale is in the set of requested locales. */
bool isRequestedLocale( const Locale & locale_r ) const;
/** Get the set of available locales.
*/
const LocaleSet & getAvailableLocales() const;
- /** Wheter this \ref Locale is in the set of available locales. */
+ /** Whether this \ref Locale is in the set of available locales. */
bool isAvailableLocale( const Locale & locale_r ) const;
//@}
+ public:
+ /** \name Handle hard locks (e.g set from /etc/zypp/locks).
+ *
+ * As this kind of lock is query based, it's quite expensive.
+ *
+ * These queries are re-evaluated when adding new repos to the pool.
+ */
+ //@{
+ 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() ); }
+
+ /** Set a new set of queries.
+ * The hard-locks of existing PoolItems are adjusted according
+ * to the queries. (usually called on target load)
+ */
+ void setHardLockQueries( const HardLockQueries & newLocks_r );
+
+ /** Suggest a new set of queries based on the current selection.
+ * (usually remembered on commit).
+ */
+ void getHardLockQueries( HardLockQueries & activeLocks_r );
+ //@}
+
private:
const pool::PoolTraits::ItemContainerT & store() const;
const pool::PoolTraits::Id2ItemT & id2item() const;
private:
/** Ctor */
- ResPool( pool::PoolTraits::Impl_constPtr impl_r );
- /** Const access to implementation. */
- pool::PoolTraits::Impl_constPtr _pimpl;
+ ResPool( pool::PoolTraits::Impl_Ptr impl_r );
+ /** Access to implementation. */
+ RW_pointer<pool::PoolTraits::Impl> _pimpl;
};
///////////////////////////////////////////////////////////////////