libzypp  17.35.8
ResPool.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_RESPOOL_H
13 #define ZYPP_RESPOOL_H
14 
15 #include <iosfwd>
16 #include <utility>
17 
18 #include <zypp-core/Globals.h>
19 #include <zypp/base/Iterator.h>
20 
21 #include <zypp/pool/PoolTraits.h>
22 #include <zypp/PoolItem.h>
23 #include <zypp/Filter.h>
24 
26 namespace zypp
27 {
28 
29  class SerialNumber;
30  class ResPoolProxy;
31  class Resolver;
32 
34  //
35  // CLASS NAME : ResPool
36  //
62  {
63  friend std::ostream & operator<<( std::ostream & str, const ResPool & obj );
64 
65  public:
71 
72  public:
74  static ResPool instance();
75 
77  ResPoolProxy proxy() const;
78 
80  Resolver & resolver() const;
81 
82  public:
87  const SerialNumber & serial() const;
88 
89  public:
91  bool empty() const;
93  size_type size() const;
94 
99  { return make_filter_begin( pool::ByPoolItem(), store() ); }
102  { return make_filter_end( pool::ByPoolItem(), store() ); }
104 
105  public:
111  PoolItem find( const sat::Solvable & slv_r ) const;
113  PoolItem find( const ResObject::constPtr & resolvable_r ) const
114  { return( resolvable_r ? find( resolvable_r->satSolvable() ) : PoolItem() ); }
115 
116  public:
119  template<class TFilter>
120  filter_iterator<TFilter,const_iterator> filterBegin( const TFilter & filter_r ) const
121  { return make_filter_begin( filter_r, *this ); }
122 
123  template<class TFilter>
124  filter_iterator<TFilter,const_iterator> filterEnd( const TFilter & filter_r ) const
125  { return make_filter_end( filter_r, *this ); }
126 
127  template<class TFilter>
128  Iterable<filter_iterator<TFilter,const_iterator> > filter( const TFilter & filter_r ) const
129  { return makeIterable( filterBegin( filter_r ), filterEnd( filter_r ) ); }
131 
151  filter_iterator<filter::ByStatus,const_iterator> byStatusBegin( const filter::ByStatus & filter_r ) const
152  { return make_filter_begin( filter_r, *this ); }
153 
154  filter_iterator<filter::ByStatus,const_iterator> byStatusEnd( const filter::ByStatus & filter_r ) const
155  { return make_filter_end( filter_r, *this ); }
156 
158  { return makeIterable( byStatusBegin( filter_r ), byStatusEnd( filter_r ) ); }
160 
161  public:
166 
167  byIdent_iterator byIdentBegin( const ByIdent & ident_r ) const
168  {
169  return make_transform_iterator( id2item().equal_range( ident_r.get() ).first,
171  }
172 
174  { return byIdentBegin( ByIdent(std::move(kind_r),name_r) ); }
175 
176  byIdent_iterator byIdentBegin( ResKind kind_r, const C_Str & name_r ) const
177  { return byIdentBegin( ByIdent(std::move(kind_r),name_r) ); }
178 
179  template<class TRes>
181  { return byIdentBegin( ByIdent(ResTraits<TRes>::kind,name_r) ); }
182 
183  template<class TRes>
184  byIdent_iterator byIdentBegin( const C_Str & name_r ) const
185  { return byIdentBegin( ByIdent(ResTraits<TRes>::kind,name_r) ); }
186 
188  byIdent_iterator byIdentBegin( const PoolItem & pi_r ) const
189  { return byIdentBegin( ByIdent(pi_r.satSolvable()) ); }
192  { return byIdentBegin( ByIdent(slv_r) ); }
195  { return byIdentBegin( ByIdent(ident_r) ); }
196 
197 
198  byIdent_iterator byIdentEnd( const ByIdent & ident_r ) const
199  {
200  return make_transform_iterator( id2item().equal_range( ident_r.get() ).second,
202  }
203 
204  byIdent_iterator byIdentEnd( ResKind kind_r, IdString name_r ) const
205  { return byIdentEnd( ByIdent(std::move(kind_r),name_r) ); }
206 
207  byIdent_iterator byIdentEnd( ResKind kind_r, const C_Str & name_r ) const
208  { return byIdentEnd( ByIdent(std::move(kind_r),name_r) ); }
209 
210  template<class TRes>
212  { return byIdentEnd( ByIdent(ResTraits<TRes>::kind,name_r) ); }
213 
214  template<class TRes>
215  byIdent_iterator byIdentEnd( const C_Str & name_r ) const
216  { return byIdentEnd( ByIdent(ResTraits<TRes>::kind,name_r) ); }
217 
219  byIdent_iterator byIdentEnd( const PoolItem & pi_r ) const
220  { return byIdentEnd( ByIdent(pi_r.satSolvable()) ); }
223  { return byIdentEnd( ByIdent(slv_r) ); }
226  { return byIdentEnd( ByIdent(ident_r) ); }
227 
228 
229  Iterable<byIdent_iterator> byIdent( const ByIdent & ident_r ) const
230  { return makeIterable( byIdentBegin( ident_r ), byIdentEnd( ident_r ) ); }
231 
232  Iterable<byIdent_iterator> byIdent( const ResKind& kind_r, IdString name_r ) const
233  { return makeIterable( byIdentBegin( kind_r, name_r ), byIdentEnd( kind_r, name_r ) ); }
234 
235  Iterable<byIdent_iterator> byIdent( const ResKind& kind_r, const C_Str & name_r ) const
236  { return makeIterable( byIdentBegin( kind_r, name_r ), byIdentEnd( kind_r, name_r ) ); }
237 
238  template<class TRes>
240  { return makeIterable( byIdentBegin<TRes>( name_r ), byIdentEnd<TRes>( name_r ) ); }
241 
242  template<class TRes>
243  Iterable<byIdent_iterator> byIdent( const C_Str & name_r ) const
244  { return makeIterable( byIdentBegin<TRes>( name_r ), byIdentEnd<TRes>( name_r ) ); }
245 
247  { return makeIterable( byIdentBegin( pi_r ), byIdentEnd( pi_r ) ); }
248 
250  { return makeIterable( byIdentBegin( slv_r ), byIdentEnd( slv_r ) ); }
251 
253  { return makeIterable( byIdentBegin( ident_r ), byIdentEnd( ident_r ) ); }
255 
256  public:
260  using byKind_iterator = filter_iterator<ByKind, const_iterator>;
261 
262  byKind_iterator byKindBegin( const ResKind & kind_r ) const
263  { return make_filter_begin( ByKind(kind_r), *this ); }
264 
265  template<class TRes>
267  { return make_filter_begin( resfilter::byKind<TRes>(), *this ); }
268 
269  byKind_iterator byKindEnd( const ResKind & kind_r ) const
270  { return make_filter_end( ByKind(kind_r), *this ); }
271 
272  template<class TRes>
274  { return make_filter_end( resfilter::byKind<TRes>(), *this ); }
275 
276  Iterable<byKind_iterator> byKind( const ResKind & kind_r ) const
277  { return makeIterable( byKindBegin( kind_r ), byKindEnd( kind_r ) ); }
278 
279  template<class TRes>
281  { return makeIterable( byKindBegin<TRes>(), byKindEnd<TRes>() ); }
283 
284  public:
288  using byName_iterator = filter_iterator<ByName, const_iterator>;
289 
290  byName_iterator byNameBegin( const std::string & name_r ) const
291  { return make_filter_begin( ByName(name_r), *this ); }
292 
293  byName_iterator byNameEnd( const std::string & name_r ) const
294  { return make_filter_end( ByName(name_r), *this ); }
295 
296  Iterable<byName_iterator> byName( const std::string & name_r ) const
297  { return makeIterable( byNameBegin( name_r ), byNameEnd( name_r ) ); }
299 
300  public:
303  class EstablishedStates
315  {
316  public:
317  ~EstablishedStates();
319  using ChangedPseudoInstalled = std::map<PoolItem, ResStatus::ValidateValue>;
321  ChangedPseudoInstalled changedPseudoInstalled() const;
322  private:
323  class Impl;
325  private:
326  friend class pool::PoolImpl;
328  EstablishedStates( shared_ptr<Impl> pimpl_r )
329  : _pimpl { std::move(pimpl_r) }
330  {}
331  };
333 
339  EstablishedStates establishedStates() const;
340 
343 
351  { return establishedStates().changedPseudoInstalled(); }
353  public:
357  size_type knownRepositoriesSize() const;
358 
359  repository_iterator knownRepositoriesBegin() const;
360 
361  repository_iterator knownRepositoriesEnd() const;
362 
366  Repository reposFind( const std::string & alias_r ) const;
367 
369  { return makeIterable( knownRepositoriesBegin(), knownRepositoriesEnd() ); }
371 
372  public:
401  void setRequestedLocales( const LocaleSet & locales_r );
402 
406  bool addRequestedLocale( const Locale & locale_r );
407 
411  bool eraseRequestedLocale( const Locale & locale_r );
412 
416  const LocaleSet & getRequestedLocales() const;
417 
419  bool isRequestedLocale( const Locale & locale_r ) const;
420 
425  const LocaleSet & getAvailableLocales() const;
426 
428  bool isAvailableLocale( const Locale & locale_r ) const;
430 
431  public:
441 
442  bool hardLockQueriesEmpty() const;
443  size_type hardLockQueriesSize() const;
444  hardLockQueries_iterator hardLockQueriesBegin() const;
445  hardLockQueries_iterator hardLockQueriesEnd() const;
446 
448  { return makeIterable( hardLockQueriesBegin(), hardLockQueriesEnd() ); }
449 
454  void setHardLockQueries( const HardLockQueries & newLocks_r );
455 
459  void getHardLockQueries( HardLockQueries & activeLocks_r );
461 
462  private:
463  const pool::PoolTraits::ItemContainerT & store() const;
464  const pool::PoolTraits::Id2ItemT & id2item() const;
465 
466  private:
471  };
473 
475  std::ostream & operator<<( std::ostream & str, const ResPool & obj ) ZYPP_API;
476 
478 } // namespace zypp
480 
481 #include <zypp/ResPoolProxy.h>
482 
483 #endif // ZYPP_RESPOOL_H
sat::detail::IdType get() const
Definition: ByIdent.h:90
byIdent_iterator byIdentBegin(ResKind kind_r, IdString name_r) const
Definition: ResPool.h:173
Iterable< repository_iterator > knownRepositories() const
Definition: ResPool.h:368
A Solvable object within the sat Pool.
Definition: Solvable.h:53
filter_iterator< ByPoolItem, ItemContainerT::const_iterator > const_iterator
Definition: PoolTraits.h:73
byKind_iterator byKindEnd() const
Definition: ResPool.h:273
Iterable< byIdent_iterator > byIdent(const ByIdent &ident_r) const
Definition: ResPool.h:229
Iterable< byIdent_iterator > byIdent(sat::Solvable slv_r) const
Definition: ResPool.h:249
const_iterator end() const
Definition: ResPool.h:101
byIdent_iterator byIdentEnd(ResKind kind_r, const C_Str &name_r) const
Definition: ResPool.h:207
Filter solvables according to their status.
Definition: Filter.h:142
transform_iterator< Id2ItemValueSelector, Id2ItemT::const_iterator > byIdent_iterator
Definition: PoolTraits.h:79
byIdent_iterator byIdentBegin(IdString name_r) const
Definition: ResPool.h:180
pool::PoolTraits::hardLockQueries_iterator hardLockQueries_iterator
Definition: ResPool.h:440
filter_iterator< filter::ByStatus, const_iterator > byStatusEnd(const filter::ByStatus &filter_r) const
Definition: ResPool.h:154
Iterable< byIdent_iterator > byIdent(const ResKind &kind_r, IdString name_r) const
Definition: ResPool.h:232
std::unordered_set< Locale > LocaleSet
Definition: Locale.h:29
Iterable< filter_iterator< filter::ByStatus, const_iterator > > byStatus(const filter::ByStatus &filter_r) const
Definition: ResPool.h:157
pool::PoolTraits::const_iterator const_iterator
Definition: ResPool.h:69
byKind_iterator byKindBegin(const ResKind &kind_r) const
Definition: ResPool.h:262
sat::Pool::RepositoryIterator repository_iterator
list of known Repositories
Definition: PoolTraits.h:82
String related utilities and Regular expression matching.
std::_Select2nd
Definition: PoolTraits.h:49
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
Definition: SerialNumber.cc:52
Access to the sat-pools string space.
Definition: IdString.h:43
std::vector< PoolItem > ItemContainerT
pure items
Definition: PoolTraits.h:71
Iterable< filter_iterator< TFilter, const_iterator > > filter(const TFilter &filter_r) const
Definition: ResPool.h:128
Provides API related macros.
HardLockQueries::const_iterator hardLockQueries_iterator
Definition: PoolTraits.h:86
ResTraits.
Definition: ResTraits.h:79
byKind_iterator byKindBegin() const
Definition: ResPool.h:266
RW_pointer< Impl > _pimpl
Definition: ResPool.h:323
byIdent_iterator byIdentEnd(const C_Str &name_r) const
Definition: ResPool.h:215
Iterable< byIdent_iterator > byIdent(const ResKind &kind_r, const C_Str &name_r) const
Definition: ResPool.h:235
filter_iterator< TFilter, typename TContainer::const_iterator > make_filter_end(TFilter f, const TContainer &c)
Convenience to create filter_iterator from container::end().
Definition: Iterator.h:117
Select ResObject by name.
Definition: ResFilters.h:151
ResPool::instance().proxy();.
Definition: ResPoolProxy.h:35
const_iterator begin() const
Definition: ResPool.h:98
ChangedPseudoInstalled changedPseudoInstalled() const
Return all pseudo installed items whose current state differs from their initial one.
Definition: ResPool.h:350
Iterable< byKind_iterator > byKind() const
Definition: ResPool.h:280
byIdent_iterator byIdentEnd(IdString ident_r) const
Takes a sat::Solvable::ident string.
Definition: ResPool.h:225
byIdent_iterator byIdentEnd(IdString name_r) const
Definition: ResPool.h:211
Dependency resolver interface.
Definition: Resolver.h:44
Iterable< byIdent_iterator > byIdent(IdString ident_r) const
Definition: ResPool.h:252
filter_iterator< TFilter, const_iterator > filterBegin(const TFilter &filter_r) const
Definition: ResPool.h:120
Iterable< byIdent_iterator > byIdent(const C_Str &name_r) const
Definition: ResPool.h:243
byIdent_iterator byIdentBegin(sat::Solvable slv_r) const
Derive name and kind from sat::Solvable.
Definition: ResPool.h:191
const Arch Arch_armv7hnl Arch_armv7nhl ZYPP_API
Definition: ResTraits.h:93
Convenience char* constructible from std::string and char*, it maps (char*)0 to an empty string...
Definition: String.h:90
std::unordered_multimap< sat::detail::IdType, PoolItem > Id2ItemT
ident index
Definition: PoolTraits.h:77
byIdent_iterator byIdentBegin(const C_Str &name_r) const
Definition: ResPool.h:184
TraitsType::constPtrType constPtr
Definition: ResObject.h:43
byName_iterator byNameBegin(const std::string &name_r) const
Definition: ResPool.h:290
Iterable< hardLockQueries_iterator > hardLockQueries() const
Definition: ResPool.h:447
Iterable< byIdent_iterator > byIdent(const PoolItem &pi_r) const
Definition: ResPool.h:246
std::map< PoolItem, ResStatus::ValidateValue > ChangedPseudoInstalled
Map holding pseudo installed items where current and established status differ.
Definition: ResPool.h:319
Simple serial number provider.
Definition: SerialNumber.h:44
Iterable< byIdent_iterator > byIdent(IdString name_r) const
Definition: ResPool.h:239
&#39;Language[_Country]&#39; codes.
Definition: Locale.h:50
byKind_iterator byKindEnd(const ResKind &kind_r) const
Definition: ResPool.h:269
byIdent_iterator byIdentBegin(const PoolItem &pi_r) const
Derive name and kind from PoolItem.
Definition: ResPool.h:188
PoolItem find(const ResObject::constPtr &resolvable_r) const
Definition: ResPool.h:113
byIdent_iterator byIdentBegin(IdString ident_r) const
Takes a sat::Solvable::ident string.
Definition: ResPool.h:194
Global ResObject pool.
Definition: ResPool.h:61
EstablishedStates::ChangedPseudoInstalled ChangedPseudoInstalled
Map holding pseudo installed items where current and established status differ.
Definition: ResPool.h:342
Iterable< byName_iterator > byName(const std::string &name_r) const
Definition: ResPool.h:296
ItemContainerT::size_type size_type
Definition: PoolTraits.h:74
std::list< PoolQuery > HardLockQueries
hard locks from etc/zypp/locks
Definition: PoolTraits.h:85
Store initial establish status of pseudo installed items.
Definition: PoolImpl.h:117
Iterable< byKind_iterator > byKind(const ResKind &kind_r) const
Definition: ResPool.h:276
filter_iterator< ByKind, const_iterator > byKind_iterator
Definition: ResPool.h:260
byIdent_iterator byIdentEnd(const PoolItem &pi_r) const
Derive name and kind from PoolItem.
Definition: ResPool.h:219
pool::PoolTraits::size_type size_type
Definition: ResPool.h:68
filter_iterator< filter::ByStatus, const_iterator > byStatusBegin(const filter::ByStatus &filter_r) const
Definition: ResPool.h:151
byName_iterator byNameEnd(const std::string &name_r) const
Definition: ResPool.h:293
filter_iterator< TFilter, const_iterator > filterEnd(const TFilter &filter_r) const
Definition: ResPool.h:124
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:50
filter_iterator< TFilter, typename TContainer::const_iterator > make_filter_begin(TFilter f, const TContainer &c)
Convenience to create filter_iterator from container::begin().
Definition: Iterator.h:101
byIdent_iterator byIdentEnd(const ByIdent &ident_r) const
Definition: ResPool.h:198
pool::PoolTraits::byIdent_iterator byIdent_iterator
Definition: ResPool.h:165
EstablishedStates(shared_ptr< Impl > pimpl_r)
Factory: ResPool::establishedStates.
Definition: ResPool.h:328
Pool internal filter skiping invalid/unwanted PoolItems.
Definition: PoolTraits.h:40
Resolvable kinds.
Definition: ResKind.h:32
RW_pointer< pool::PoolTraits::Impl > _pimpl
Access to implementation.
Definition: ResPool.h:470
Easy-to use interface to the ZYPP dependency resolver.
Definition: Application.cc:19
shared_ptr< PoolImpl > Impl_Ptr
Definition: PoolTraits.h:89
SolvableIdType size_type
Definition: PoolMember.h:126
Solvable satSolvable() const
Return the corresponding sat::Solvable.
Definition: SolvableType.h:57
pool::PoolTraits::HardLockQueries HardLockQueries
Definition: ResPool.h:439
byIdent_iterator byIdentEnd(sat::Solvable slv_r) const
Derive name and kind from sat::Solvable.
Definition: ResPool.h:222
filter_iterator< ByName, const_iterator > byName_iterator
Definition: ResPool.h:288
byIdent_iterator byIdentBegin(const ByIdent &ident_r) const
Definition: ResPool.h:167
Main filter selecting PoolItems by name and kind.
Definition: ByIdent.h:28
byIdent_iterator byIdentEnd(ResKind kind_r, IdString name_r) const
Definition: ResPool.h:204
Filter solvables according to their kind.
Definition: Filter.h:106
byIdent_iterator byIdentBegin(ResKind kind_r, const C_Str &name_r) const
Definition: ResPool.h:176