35      std::for_each( pool_r.
begin(), pool_r.
end(),
 
 
   47      std::for_each( pool_r.
begin(), pool_r.
end(),
 
 
 
   75                                           pool::PoolImpl::Id2ItemT::const_iterator end_r )
 
   79      sat::Solvable solv( begin->satSolvable() );
 
   81      return new ui::Selectable( 
ui::Selectable::Impl_Ptr( 
new ui::Selectable::Impl( solv.kind(), solv.name(), begin, end ) ) );
 
   97    using SelectableIndex = std::unordered_map<sat::detail::IdType, ui::Selectable::Ptr>;
 
  109      if ( ! id2item.empty() )
 
  112        pool::PoolImpl::Id2ItemT::const_iterator cbegin = id2item.begin();
 
  114        for_( it, id2item.begin(), id2item.end() )
 
  116          if ( it->first != cbegin->first )
 
  120            _selPool.insert( SelectablePool::value_type( p->kind(), p ) );
 
  128        _selPool.insert( SelectablePool::value_type( p->kind(), p ) );
 
 
  136      SelectableIndex::const_iterator it( 
_selIndex.find( ident_r.
get() ) );
 
 
  157    { 
return( 
_selPool.count( kind_r ) == 0 );  }
 
 
  160    { 
return _selPool.count( kind_r ); }
 
 
  170    { 
return _pool.knownRepositoriesSize(); }
 
 
  173    { 
return _pool.knownRepositoriesBegin(); }
 
 
  176    { 
return _pool.knownRepositoriesEnd(); }
 
 
 
  217               << 
"solv/" << obj.
size()<< 
"sel]";
 
 
  225      { 
return selp->toModify(); }
 
 
 
  277  { 
return _pimpl->lookup( ident_r ); }
 
 
  280  { 
return _pimpl->empty(); }
 
 
  283  { 
return _pimpl->size(); }
 
 
  286  { 
return _pimpl->begin(); }
 
 
  292  { 
return _pimpl->empty( kind_r ); }
 
 
  295  { 
return _pimpl->size( kind_r ); }
 
 
  298  { 
return _pimpl->byKindBegin( kind_r ); }
 
 
  301  { 
return _pimpl->byKindEnd( kind_r ); }
 
 
  304  { 
return _pimpl->knownRepositoriesSize(); }
 
 
  307  { 
return _pimpl->knownRepositoriesBegin(); }
 
 
  310  { 
return _pimpl->knownRepositoriesEnd(); }
 
 
  316  { 
_pimpl->saveState( kind_r ); }
 
 
  319  { 
_pimpl->restoreState(); }
 
 
  322  { 
_pimpl->restoreState( kind_r ); }
 
 
  325  { 
return _pimpl->diffState(); }
 
 
  328  { 
return _pimpl->diffState( kind_r ); }
 
 
void restoreState() const
ResPool::repository_iterator repository_iterator
const_iterator byKindEnd() const
size_type knownRepositoriesSize() const
const_iterator begin() const
std::multimap< ResKind, ui::Selectable::Ptr > SelectablePool
const_iterator end() const
ResPoolProxy()
Default ctor: no pool Nonempty proxies are provided by ResPool.
RW_pointer< Impl > _pimpl
Pointer to implementation.
MapKVIteratorTraits< SelectablePool >::Value_const_iterator const_iterator
void restoreState() const
SelectablePool::size_type size_type
repository_iterator knownRepositoriesBegin() const
ui::Selectable::Ptr lookup(const pool::ByIdent &ident_r) const
repository_iterator knownRepositoriesEnd() const
const_iterator byKindBegin() const
const_iterator end() const
byKind_iterator byKindEnd(const ResKind &kind_r) const
const SerialNumber & serial() const
The pools serial number.
byKind_iterator byKindBegin(const ResKind &kind_r) const
const_iterator begin() const
Main filter selecting PoolItems by name and kind.
sat::detail::IdType get() const
const Id2ItemT & id2item() const
PoolTraits::Id2ItemT Id2ItemT
shared_ptr< Impl > Impl_Ptr
intrusive_ptr< Selectable > Ptr
String related utilities and Regular expression matching.
Easy-to use interface to the ZYPP dependency resolver.
std::ostream & dumpRange(std::ostream &str, TIterator begin, TIterator end, const std::string &intro="{", const std::string &pfx="\n  ", const std::string &sep="\n  ", const std::string &sfx="\n", const std::string &extro="}")
Print range defined by iterators (multiline style).
MapKVIteratorTraits< TMap >::Value_const_iterator make_map_value_lower_bound(const TMap &map_r, const typename TMap::key_type &key_r)
Convenience to create the value iterator from container::lower_bound()
MapKVIteratorTraits< TMap >::Value_const_iterator make_map_value_begin(const TMap &map_r)
Convenience to create the value iterator from container::begin()
std::ostream & dumpOn(std::ostream &str, const Capability &obj)
filter_iterator< TFilter, typename TContainer::const_iterator > make_filter_begin(TFilter f, const TContainer &c)
Convenience to create filter_iterator from container::begin().
MapKVIteratorTraits< TMap >::Value_const_iterator make_map_value_end(const TMap &map_r)
Convenience to create the value iterator from container::end()
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
MapKVIteratorTraits< TMap >::Value_const_iterator make_map_value_upper_bound(const TMap &map_r, const typename TMap::key_type &key_r)
Convenience to create the value iterator from container::upper_bound()
filter_iterator< TFilter, typename TContainer::const_iterator > make_filter_end(TFilter f, const TContainer &c)
Convenience to create filter_iterator from container::end().
int invokeOnEach(TIterator begin_r, TIterator end_r, TFilter filter_r, TFunction fnc_r)
Iterate through [begin_r,end_r) and invoke fnc_r on each item that passes filter_r.
void saveState(const ResPool &pool_r, const ResKind &kind_r)
bool diffState(const ResPool &pool_r, const ResKind &kind_r) const
void saveState(const ResPool &pool_r)
void restoreState(const ResPool &pool_r, const ResKind &kind_r)
void restoreState(const ResPool &pool_r)
bool diffState(const ResPool &pool_r) const
ResPoolProxy implementation.
void restoreState(const ResKind &kind_r) const
bool diffState(const ResKind &kind_r) const
std::ostream & operator<<(std::ostream &str, const ResPoolProxy::Impl &obj)
Stream output.
repository_iterator knownRepositoriesEnd() const
repository_iterator knownRepositoriesBegin() const
Impl(ResPool &&pool_r, const pool::PoolImpl &poolImpl_r)
const_iterator begin() const
static shared_ptr< Impl > nullimpl()
Offer default Impl.
std::ostream & dumpOn(std::ostream &str, const ResPoolProxy::Impl &obj)
Verbose stream output.
void restoreState() const
SelectableIndex _selIndex
bool empty(const ResKind &kind_r) const
friend std::ostream & operator<<(std::ostream &str, const Impl &obj)
void saveState(const ResKind &kind_r) const
size_type size(const ResKind &kind_r) const
std::unordered_map< sat::detail::IdType, ui::Selectable::Ptr > SelectableIndex
ui::Selectable::Ptr lookup(const pool::ByIdent &ident_r) const
size_type knownRepositoriesSize() const
const_iterator end() const
ResPoolProxy::const_iterator const_iterator
const_iterator byKindEnd(const ResKind &kind_r) const
const_iterator byKindBegin(const ResKind &kind_r) const
friend std::ostream & dumpOn(std::ostream &str, const Impl &obj)
bool operator()(const ui::Selectable::Ptr &selp) const
P_Select2nd< Id2ItemT::value_type > Id2ItemValueSelector
transform_iterator< Id2ItemValueSelector, Id2ItemT::const_iterator > byIdent_iterator
#define for_(IT, BEG, END)
Convenient for-loops using iterator.