libzypp 17.34.0
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/APIConfig.h>
19#include <zypp/base/Iterator.h>
20
22#include <zypp/PoolItem.h>
23#include <zypp/Filter.h>
24
26namespace 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;
114 { return( resolvable_r ? find( resolvable_r->satSolvable() ) : PoolItem() ); }
115
116 public:
119 template<class TFilter>
122
123 template<class TFilter>
126
127 template<class TFilter>
129 { return makeIterable( filterBegin( filter_r ), filterEnd( filter_r ) ); }
131
153
156
158 { return makeIterable( byStatusBegin( filter_r ), byStatusEnd( filter_r ) ); }
160
161 public:
166
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
177 { return byIdentBegin( ByIdent(std::move(kind_r),name_r) ); }
178
179 template<class TRes>
182
183 template<class TRes>
185 { return byIdentBegin( ByIdent(ResTraits<TRes>::kind,name_r) ); }
186
189 { return byIdentBegin( ByIdent(pi_r.satSolvable()) ); }
192 { return byIdentBegin( ByIdent(slv_r) ); }
195 { return byIdentBegin( ByIdent(ident_r) ); }
196
197
199 {
200 return make_transform_iterator( id2item().equal_range( ident_r.get() ).second,
202 }
203
205 { return byIdentEnd( ByIdent(std::move(kind_r),name_r) ); }
206
208 { return byIdentEnd( ByIdent(std::move(kind_r),name_r) ); }
209
210 template<class TRes>
213
214 template<class TRes>
216 { return byIdentEnd( ByIdent(ResTraits<TRes>::kind,name_r) ); }
217
220 { return byIdentEnd( ByIdent(pi_r.satSolvable()) ); }
223 { return byIdentEnd( ByIdent(slv_r) ); }
226 { return byIdentEnd( ByIdent(ident_r) ); }
227
228
230 { return makeIterable( byIdentBegin( ident_r ), byIdentEnd( ident_r ) ); }
231
233 { return makeIterable( byIdentBegin( kind_r, name_r ), byIdentEnd( kind_r, name_r ) ); }
234
236 { return makeIterable( byIdentBegin( kind_r, name_r ), byIdentEnd( kind_r, name_r ) ); }
237
238 template<class TRes>
241
242 template<class TRes>
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:
261
263 { return make_filter_begin( ByKind(kind_r), *this ); }
264
265 template<class TRes>
267 { return make_filter_begin( resfilter::byKind<TRes>(), *this ); }
268
270 { return make_filter_end( ByKind(kind_r), *this ); }
271
272 template<class TRes>
274 { return make_filter_end( resfilter::byKind<TRes>(), *this ); }
275
277 { return makeIterable( byKindBegin( kind_r ), byKindEnd( kind_r ) ); }
278
279 template<class TRes>
281 { return makeIterable( byKindBegin<TRes>(), byKindEnd<TRes>() ); }
283
284 public:
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:
315 {
316 public:
319 using ChangedPseudoInstalled = std::map<PoolItem, ResStatus::ValidateValue>;
321 ChangedPseudoInstalled changedPseudoInstalled() const;
322 private:
323 class Impl;
325 private:
326 friend class pool::PoolImpl;
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
Reference counted access to a Tp object calling a custom Dispose function when the last AutoDispose h...
Definition AutoDispose.h:95
Convenience char* constructible from std::string and char*, it maps (char*)0 to an empty string.
Definition String.h:91
Access to the sat-pools string space.
Definition IdString.h:44
'Language[_Country]' codes.
Definition Locale.h:51
Combining sat::Solvable and ResStatus.
Definition PoolItem.h:51
Resolvable kinds.
Definition ResKind.h:33
TraitsType::constPtrType constPtr
Definition ResObject.h:43
ResPool::instance().proxy();.
Store initial establish status of pseudo installed items.
Definition PoolImpl.h:118
A copy of the Pools initial ValidateValues of pseudo installed items.
Definition ResPool.h:315
RW_pointer< Impl > _pimpl
Definition ResPool.h:324
EstablishedStates(shared_ptr< Impl > pimpl_r)
Factory: ResPool::establishedStates.
Definition ResPool.h:328
std::map< PoolItem, ResStatus::ValidateValue > ChangedPseudoInstalled
Map holding pseudo installed items where current and established status differ.
Definition ResPool.h:319
Global ResObject pool.
Definition ResPool.h:62
pool::PoolTraits::HardLockQueries HardLockQueries
Definition ResPool.h:439
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
Iterable< byIdent_iterator > byIdent(IdString name_r) const
Definition ResPool.h:239
byIdent_iterator byIdentEnd(const PoolItem &pi_r) const
Derive name and kind from PoolItem.
Definition ResPool.h:219
filter_iterator< filter::ByStatus, const_iterator > byStatusEnd(const filter::ByStatus &filter_r) const
Definition ResPool.h:154
byKind_iterator byKindEnd() const
Definition ResPool.h:273
byIdent_iterator byIdentEnd(ResKind kind_r, IdString name_r) const
Definition ResPool.h:204
byIdent_iterator byIdentBegin(IdString ident_r) const
Takes a sat::Solvable::ident string.
Definition ResPool.h:194
Iterable< byKind_iterator > byKind() const
Definition ResPool.h:280
Iterable< byIdent_iterator > byIdent(const ResKind &kind_r, const C_Str &name_r) const
Definition ResPool.h:235
Iterable< filter_iterator< TFilter, const_iterator > > filter(const TFilter &filter_r) const
Definition ResPool.h:128
byIdent_iterator byIdentBegin(IdString name_r) const
Definition ResPool.h:180
byIdent_iterator byIdentBegin(const PoolItem &pi_r) const
Derive name and kind from PoolItem.
Definition ResPool.h:188
const_iterator end() const
Definition ResPool.h:101
filter_iterator< TFilter, const_iterator > filterBegin(const TFilter &filter_r) const
Definition ResPool.h:120
Iterable< hardLockQueries_iterator > hardLockQueries() const
Definition ResPool.h:447
byIdent_iterator byIdentEnd(IdString ident_r) const
Takes a sat::Solvable::ident string.
Definition ResPool.h:225
ChangedPseudoInstalled changedPseudoInstalled() const
Return all pseudo installed items whose current state differs from their initial one.
Definition ResPool.h:350
Iterable< byIdent_iterator > byIdent(const C_Str &name_r) const
Definition ResPool.h:243
byKind_iterator byKindEnd(const ResKind &kind_r) const
Definition ResPool.h:269
Iterable< byName_iterator > byName(const std::string &name_r) const
Definition ResPool.h:296
byKind_iterator byKindBegin() const
Definition ResPool.h:266
byIdent_iterator byIdentBegin(const C_Str &name_r) const
Definition ResPool.h:184
Iterable< byIdent_iterator > byIdent(const ResKind &kind_r, IdString name_r) const
Definition ResPool.h:232
pool::PoolTraits::hardLockQueries_iterator hardLockQueries_iterator
Definition ResPool.h:440
byName_iterator byNameBegin(const std::string &name_r) const
Definition ResPool.h:290
filter_iterator< filter::ByStatus, const_iterator > byStatusBegin(const filter::ByStatus &filter_r) const
Definition ResPool.h:151
Iterable< byIdent_iterator > byIdent(IdString ident_r) const
Definition ResPool.h:252
RW_pointer< pool::PoolTraits::Impl > _pimpl
Access to implementation.
Definition ResPool.h:470
byIdent_iterator byIdentEnd(sat::Solvable slv_r) const
Derive name and kind from sat::Solvable.
Definition ResPool.h:222
Iterable< byIdent_iterator > byIdent(sat::Solvable slv_r) const
Definition ResPool.h:249
byIdent_iterator byIdentBegin(sat::Solvable slv_r) const
Derive name and kind from sat::Solvable.
Definition ResPool.h:191
pool::PoolTraits::size_type size_type
Definition ResPool.h:68
byKind_iterator byKindBegin(const ResKind &kind_r) const
Definition ResPool.h:262
const_iterator begin() const
Definition ResPool.h:98
Iterable< byKind_iterator > byKind(const ResKind &kind_r) const
Definition ResPool.h:276
Iterable< byIdent_iterator > byIdent(const ByIdent &ident_r) const
Definition ResPool.h:229
byIdent_iterator byIdentEnd(IdString name_r) const
Definition ResPool.h:211
byIdent_iterator byIdentBegin(ResKind kind_r, IdString name_r) const
Definition ResPool.h:173
byIdent_iterator byIdentEnd(const C_Str &name_r) const
Definition ResPool.h:215
PoolItem find(const ResObject::constPtr &resolvable_r) const
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition ResPool.h:113
byIdent_iterator byIdentBegin(ResKind kind_r, const C_Str &name_r) const
Definition ResPool.h:176
Iterable< repository_iterator > knownRepositories() const
Definition ResPool.h:368
byIdent_iterator byIdentBegin(const ByIdent &ident_r) const
Definition ResPool.h:167
byIdent_iterator byIdentEnd(const ByIdent &ident_r) const
Definition ResPool.h:198
EstablishedStates::ChangedPseudoInstalled ChangedPseudoInstalled
Map holding pseudo installed items where current and established status differ.
Definition ResPool.h:342
byIdent_iterator byIdentEnd(ResKind kind_r, const C_Str &name_r) const
Definition ResPool.h:207
Iterable< byIdent_iterator > byIdent(const PoolItem &pi_r) const
Definition ResPool.h:246
Iterable< filter_iterator< filter::ByStatus, const_iterator > > byStatus(const filter::ByStatus &filter_r) const
Definition ResPool.h:157
Dependency resolver interface.
Definition Resolver.h:45
Simple serial number provider.
Filter solvables according to their kind.
Definition Filter.h:107
Filter solvables according to their status.
Definition Filter.h:143
Main filter selecting PoolItems by name and kind.
Definition ByIdent.h:29
A Solvable object within the sat Pool.
Definition Solvable.h:54
Definition Arch.h:364
String related utilities and Regular expression matching.
Easy-to use interface to the ZYPP dependency resolver.
std::unordered_set< Locale > LocaleSet
Definition Locale.h:29
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
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
const Arch Arch_armv7hnl Arch_armv7nhl ZYPP_API
Definition Arch.h:247
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
ResTraits.
Definition ResTraits.h:80
Pool internal filter skiping invalid/unwanted PoolItems.
Definition PoolTraits.h:41
filter_iterator< ByPoolItem, ItemContainerT::const_iterator > const_iterator
Definition PoolTraits.h:73
shared_ptr< PoolImpl > Impl_Ptr
Definition PoolTraits.h:89
sat::Pool::RepositoryIterator repository_iterator
list of known Repositories
Definition PoolTraits.h:82
std::unordered_multimap< sat::detail::IdType, PoolItem > Id2ItemT
ident index
Definition PoolTraits.h:77
ItemContainerT::size_type size_type
Definition PoolTraits.h:74
HardLockQueries::const_iterator hardLockQueries_iterator
Definition PoolTraits.h:86
std::vector< PoolItem > ItemContainerT
pure items
Definition PoolTraits.h:71
std::list< PoolQuery > HardLockQueries
hard locks from etc/zypp/locks
Definition PoolTraits.h:85
transform_iterator< Id2ItemValueSelector, Id2ItemT::const_iterator > byIdent_iterator
Definition PoolTraits.h:79
Select ResObject by name.
Definition ResFilters.h:152