libzypp 17.31.1
Selectable.cc
Go to the documentation of this file.
1/*---------------------------------------------------------------------\
2| ____ _ __ __ ___ |
3| |__ / \ / / . \ . \ |
4| / / \ V /| _/ _/ |
5| / /__ | | | | | | |
6| /_____||_| |_| |_| |
7| |
8\---------------------------------------------------------------------*/
12#include <iostream>
13//#include <zypp/base/Logger.h>
14
15#include <zypp/ui/Selectable.h>
17#include <zypp/ResPool.h>
18
20namespace zypp
21{
23 namespace ui
24 {
25
27
29 { return ResPool::instance().proxy().lookup( ident_r ); }
30
32 //
33 // METHOD NAME : Selectable::Selectable
34 // METHOD TYPE : Ctor
35 //
37 : _pimpl( pimpl_r )
38 {}
39
41 //
42 // METHOD NAME : Selectable::~Selectable
43 // METHOD TYPE : Dtor
44 //
46 {}
47
49 //
50 // Forward to implementation.
51 // Restrict PoolItems to ResObject::constPtr!
52 //
54
56 { return _pimpl->ident(); }
57
59 { return _pimpl->kind(); }
60
61 const std::string & Selectable::name() const
62 { return _pimpl->name(); }
63
65 { return _pimpl->status(); }
66
68 { return _pimpl->setStatus( state_r, causer_r ); }
69
71 { return _pimpl->installedObj(); }
72
74 { return _pimpl->candidateObj(); }
75
77 { return _pimpl->candidateObjFrom( repo_r ); }
78
80 { return _pimpl->updateCandidateObj(); }
81
83 { return _pimpl->highestAvailableVersionObj(); }
84
86 { return _pimpl->identIsAutoInstalled(); }
87
88 bool Selectable::identicalAvailable( const PoolItem & rhs ) const
89 { return _pimpl->identicalAvailable( rhs ); }
90
91 bool Selectable::identicalInstalled( const PoolItem & rhs ) const
92 { return _pimpl->identicalInstalled( rhs ); }
93
95 { return _pimpl->identicalAvailableObj( rhs ); }
96
98 { return _pimpl->identicalInstalledObj( rhs ); }
99
101 { return _pimpl->setCandidate( newCandidate_r, causer_r ); }
102
104 { return _pimpl->setCandidate( PoolItem( newCandidate_r ), causer_r ); }
105
106 bool Selectable::setOnSystem( const PoolItem & newCandidate_r, ResStatus::TransactByValue causer_r )
107 {
108 if ( identicalInstalled( newCandidate_r ) )
109 return setFate( UNMODIFIED, causer_r );
110 return setCandidate( newCandidate_r, causer_r ) && setFate( TO_INSTALL, causer_r );
111 }
112
114 { return _pimpl->theObj(); }
115
117
119 { return _pimpl->availableEmpty(); }
120
122 { return _pimpl->availableSize(); }
123
125 { return _pimpl->availableBegin(); }
126
128 { return _pimpl->availableEnd(); }
129
131
133 { return _pimpl->installedEmpty(); }
134
136 { return _pimpl->installedSize(); }
137
139 { return _pimpl->installedBegin(); }
140
142 { return _pimpl->installedEnd(); }
143
145
147 { return _pimpl->picklistEmpty(); }
148
150 { return _pimpl->picklistSize(); }
151
153 { return _pimpl->picklistBegin(); }
154
156 { return _pimpl->picklistEnd(); }
157
159 { return picklistPos( pi_r.satSolvable() ); }
160
162 {
164 for ( const auto & pi : picklist() )
165 {
166 if ( pi == solv_r )
167 return idx;
168 ++idx;
169 }
170 return picklistNoPos;
171 }
172
174
176 { return _pimpl->hasBlacklisted(); }
177
179 { return _pimpl->hasBlacklistedInstalled(); }
180
182 { return _pimpl->hasRetracted(); }
183
185 { return _pimpl->hasRetractedInstalled(); }
186
188 { return _pimpl->hasPtf(); }
189
191 { return _pimpl->hasPtfInstalled(); }
192
193
195 { return _pimpl->isUnmaintained(); }
196
198 { return _pimpl->multiversionInstall(); }
199
200 bool Selectable::pickInstall( const PoolItem & pi_r, ResStatus::TransactByValue causer_r, bool yesno_r )
201 { return _pimpl->pickInstall( pi_r, causer_r, yesno_r ); }
202
203 bool Selectable::pickDelete( const PoolItem & pi_r, ResStatus::TransactByValue causer_r, bool yesno_r )
204 { return _pimpl->pickDelete( pi_r, causer_r, yesno_r ); }
205
207 { return _pimpl->pickStatus( pi_r ); }
208
210 { return _pimpl->setPickStatus( pi_r, state_r, causer_r ); }
211
213
215 { return _pimpl->isUndetermined(); }
216
218 { return _pimpl->isRelevant(); }
219
221 { return _pimpl->isSatisfied(); }
222
224 { return _pimpl->isBroken(); }
225
227 {
228 return fate() == TO_INSTALL || ( ! locked() && isBroken() );
229 }
230
232 {
233 return locked() && isBroken() ;
234 }
235
237 { return _pimpl->modifiedBy(); }
238
240 { return _pimpl->hasLicenceConfirmed(); }
241
243 { _pimpl->setLicenceConfirmed( val_r ); }
244
246 { return _pimpl->hasLocks(); }
247
249 {
250 switch ( status() ) {
251 case S_Update:
252 case S_Install:
253 case S_AutoUpdate:
254 case S_AutoInstall:
255 return TO_INSTALL;
256 break;
257
258 case S_Del:
259 case S_AutoDel:
260 return TO_DELETE;
261 break;
262
263 case S_Protected:
264 case S_Taboo:
265 case S_KeepInstalled:
266 case S_NoInst:
267 break;
268 }
269 return UNMODIFIED;
270 };
271
273 {
274 switch ( fate_r )
275 {
276 case TO_INSTALL:
277 return setStatus( hasInstalledObj() ? S_Update : S_Install, causer_r );
278 break;
279
280 case TO_DELETE:
281 return setStatus( S_Del, causer_r );
282 break;
283
284 case UNMODIFIED:
285 switch ( status() ) {
286 case S_Protected:
287 case S_Taboo:
288 return true;
289 break;
290 default:
291 return setStatus( hasInstalledObj() ? S_KeepInstalled : S_NoInst, causer_r );
292 break;
293 }
294 break;
295 }
296 return false;
297 }
298
300 {
301 return( hasInstalledObj() || setStatus( S_Install, causer_r ) );
302 }
303
305 {
306 if ( ! hasInstalledObj() )
307 return setStatus( S_Install, causer_r );
308
309 PoolItem cand( candidateObj() );
310 if ( ! cand )
311 return true;
312
313 return( installedObj()->edition() >= cand->edition()
314 || setStatus( S_Update, causer_r ) );
315 }
316
318 {
319 return( ! hasInstalledObj() || setStatus( S_Del, causer_r ) );
320 }
321
322 /******************************************************************
323 **
324 ** FUNCTION NAME : operator<<
325 ** FUNCTION TYPE : std::ostream &
326 */
327 std::ostream & operator<<( std::ostream & str, const Selectable & obj )
328 { return str << *(obj._pimpl); }
329
330 std::ostream & dumpOn( std::ostream & str, const Selectable & obj )
331 { return dumpOn( str, *(obj._pimpl) ); }
332
334 } // namespace ui
337} // namespace zypp
Access to the sat-pools string space.
Definition: IdString.h:43
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:51
Resolvable kinds.
Definition: ResKind.h:33
TraitsType::constPtrType constPtr
Definition: ResObject.h:43
ui::Selectable::Ptr lookup(const pool::ByIdent &ident_r) const
static ResPool instance()
Singleton ctor.
Definition: ResPool.cc:37
ResPoolProxy proxy() const
preliminary
Definition: ResPool.cc:58
Main filter selecting PoolItems by name and kind.
Definition: ByIdent.h:27
A Solvable object within the sat Pool.
Definition: Solvable.h:54
Collects PoolItems of same kind and name.
Definition: Selectable.h:52
bool hasRetractedInstalled() const
True if this Selectable contains an installed retracted item.
Definition: Selectable.cc:184
bool setStatus(Status state_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Try to set a new Status.
Definition: Selectable.cc:67
available_iterator availableEnd() const
Definition: Selectable.cc:127
bool hasPtfInstalled() const
True if this Selectable contains an installed ptf item.
Definition: Selectable.cc:190
SelectableTraits::available_size_type available_size_type
Definition: Selectable.h:62
installed_size_type installedSize() const
Definition: Selectable.cc:135
SelectableTraits::picklist_iterator picklist_iterator
Definition: Selectable.h:67
picklist_iterator picklistBegin() const
Definition: Selectable.cc:152
bool multiversionInstall() const
Whether at least one of the available packages has multiversionInstall set.
Definition: Selectable.cc:197
Iterable< picklist_iterator > picklist() const
Definition: Selectable.h:284
Status pickStatus(const PoolItem &pi_r) const
Compute the ui::Status for an individual PoolItem.
Definition: Selectable.cc:206
bool isUnmaintained() const
True if this package has no replacement from the available repositories.
Definition: Selectable.cc:194
picklist_size_type picklistSize() const
Definition: Selectable.cc:149
bool setDeleted(ResStatus::TransactByValue causer_r=ResStatus::USER)
Take care the item gets deleted if it is installed.
Definition: Selectable.cc:317
bool isSatisfied() const
Whether a relevant patchs requirements are met.
Definition: Selectable.cc:220
static Ptr get(const pool::ByIdent &ident_r)
Get the Selctable.
Definition: Selectable.cc:28
installed_iterator installedBegin() const
Definition: Selectable.cc:138
bool locked() const
True if locked (subclass of unmodified).
Definition: Selectable.h:471
available_size_type availableSize() const
Definition: Selectable.cc:121
intrusive_ptr< Selectable > Ptr
Definition: Selectable.h:57
static constexpr const picklist_size_type picklistNoPos
Returned by picklistPos if the Item does not belong to the picklist.
Definition: Selectable.h:288
void setLicenceConfirmed(bool val_r=true)
Set LicenceConfirmed bit.
Definition: Selectable.cc:242
ResStatus::TransactByValue modifiedBy() const
Return who caused the modification.
Definition: Selectable.cc:236
SelectableTraits::installed_size_type installed_size_type
Definition: Selectable.h:65
PoolItem installedObj() const
The last Installed object.
Definition: Selectable.cc:70
PoolItem highestAvailableVersionObj() const
Simply the highest available version, ignoring priorities and policies.
Definition: Selectable.cc:82
bool hasLocks() const
True if it includes locked items (don't mix this with the locked status).
Definition: Selectable.cc:245
bool hasRetracted() const
True if this Selectable contains available retracted items.
Definition: Selectable.cc:181
bool hasBlacklistedInstalled() const
True if this Selectable contains an installed blacklisted item (retracted,ptf,...).
Definition: Selectable.cc:178
picklist_iterator picklistEnd() const
Definition: Selectable.cc:155
bool setInstalled(ResStatus::TransactByValue causer_r=ResStatus::USER)
Take care the item gets installed if it is not.
Definition: Selectable.cc:299
bool hasBlacklisted() const
True if this Selectable contains available blacklisted items (retracted,ptf,...).
Definition: Selectable.cc:175
Selectable(Impl_Ptr pimpl_r)
Default ctor.
Definition: Selectable.cc:36
RW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: Selectable.h:565
IdString ident() const
The identifier.
Definition: Selectable.cc:55
installed_iterator installedEnd() const
Definition: Selectable.cc:141
PoolItem updateCandidateObj() const
The best candidate for update, if there is one.
Definition: Selectable.cc:79
PoolItem candidateObjFrom(Repository repo_r) const
The best candidate provided by a specific Repository, if there is one.
Definition: Selectable.cc:76
bool setUpToDate(ResStatus::TransactByValue causer_r=ResStatus::USER)
Take care the item gets installed if it is not, or is older.
Definition: Selectable.cc:304
const std::string & name() const
The ResObjects name.
Definition: Selectable.cc:61
SelectableTraits::installed_iterator installed_iterator
Definition: Selectable.h:64
Fate fate() const
Definition: Selectable.cc:248
bool hasPtf() const
True if this Selectable contains available ptf items.
Definition: Selectable.cc:187
SelectableTraits::available_iterator available_iterator
Iterates over ResObject::constPtr.
Definition: Selectable.h:61
PoolItem theObj() const
An object you could use as pars pro toto.
Definition: Selectable.cc:113
bool availableEmpty() const
Definition: Selectable.cc:118
shared_ptr< Impl > Impl_Ptr
Definition: Selectable.h:556
bool identIsAutoInstalled() const
Whether this ident is flagged as AutoInstalled.
Definition: Selectable.cc:85
available_iterator availableBegin() const
Definition: Selectable.cc:124
bool pickInstall(const PoolItem &pi_r, ResStatus::TransactByValue causer_r=ResStatus::USER, bool yesno_r=true)
Select a specific available item for installation.
Definition: Selectable.cc:200
bool setOnSystem(const PoolItem &newCandidate_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Arrange the specified candidate (out of available objects) to be on system after commit.
Definition: Selectable.cc:106
PoolItem setCandidate(const PoolItem &newCandidate_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Set a candidate (out of available objects).
Definition: Selectable.cc:100
bool isRelevant() const
Returns true if the patch is relevant which means that at least one package of the patch is installed...
Definition: Selectable.cc:217
bool isUnwanted() const
Broken (needed) but locked patches.
Definition: Selectable.cc:231
PoolItem candidateObj() const
The 'best' or 'most interesting' among all available objects.
Definition: Selectable.cc:73
bool identicalAvailable(const PoolItem &rhs) const
True if rhs is installed and one with the same content is available.
Definition: Selectable.cc:88
bool isBroken() const
Whether a relevant patchs requirements are broken.
Definition: Selectable.cc:223
bool hasInstalledObj() const
True if installed object is present.
Definition: Selectable.h:311
bool setPickStatus(const PoolItem &pi_r, Status state_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Assign a new status to a specific item.
Definition: Selectable.cc:209
Status status() const
Return the current Status.
Definition: Selectable.cc:64
bool hasLicenceConfirmed() const
Return value of LicenceConfirmed bit.
Definition: Selectable.cc:239
bool identicalInstalled(const PoolItem &rhs) const
True if rhs has the same content as an installed one.
Definition: Selectable.cc:91
PoolItem identicalAvailableObj(const PoolItem &rhs) const
Return an available Object with the same content as rhs.
Definition: Selectable.cc:94
bool isUndetermined() const
Returns true for packages, because packages are not classified by the solver.
Definition: Selectable.cc:214
ResKind kind() const
The ResObjects kind.
Definition: Selectable.cc:58
bool setFate(Fate fate_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Definition: Selectable.cc:272
bool pickDelete(const PoolItem &pi_r, ResStatus::TransactByValue causer_r=ResStatus::USER, bool yesno_r=true)
Select a specific installed item for deletion.
Definition: Selectable.cc:203
bool isNeeded() const
This includes unlocked broken patches, as well as those already selected to be installed.
Definition: Selectable.cc:226
bool picklistEmpty() const
Definition: Selectable.cc:146
SelectableTraits::picklist_size_type picklist_size_type
Definition: Selectable.h:68
PoolItem identicalInstalledObj(const PoolItem &rhs) const
\Return an installed Object with the same content as rhs.
Definition: Selectable.cc:97
bool installedEmpty() const
Definition: Selectable.cc:132
picklist_size_type picklistPos(const PoolItem &pi_r) const
Return the position of pi_r in the piclist or picklistNoPos.
Definition: Selectable.cc:158
String related utilities and Regular expression matching.
Status
UI status Status values calculated by Selectable.
Definition: Status.h:35
@ S_AutoUpdate
Definition: Status.h:44
@ S_Taboo
Definition: Status.h:37
@ S_AutoInstall
Definition: Status.h:45
@ S_Install
Definition: Status.h:41
@ S_AutoDel
Definition: Status.h:43
@ S_NoInst
Definition: Status.h:48
@ S_Protected
Definition: Status.h:36
@ S_KeepInstalled
Definition: Status.h:47
@ S_Del
Definition: Status.h:39
@ S_Update
Definition: Status.h:40
IMPL_PTR_TYPE(Selectable)
std::ostream & operator<<(std::ostream &str, const Selectable &obj)
Definition: Selectable.cc:327
std::ostream & dumpOn(std::ostream &str, const Selectable &obj)
Definition: Selectable.cc:330
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
Solvable satSolvable() const
Return the corresponding sat::Solvable.
Definition: SolvableType.h:57
Edition edition() const
Definition: SolvableType.h:71