libzypp  17.31.31
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>
16 #include <zypp/ui/SelectableImpl.h>
17 #include <zypp/ResPool.h>
18 
20 namespace zypp
21 {
22  namespace ui
24  {
25 
26  IMPL_PTR_TYPE(Selectable);
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 
187  bool Selectable::hasPtf() const
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 
206  Status Selectable::pickStatus( const PoolItem & pi_r ) const
207  { return _pimpl->pickStatus( pi_r ); }
208 
209  bool Selectable::setPickStatus( const PoolItem & pi_r, Status state_r, ResStatus::TransactByValue causer_r )
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 
223  bool Selectable::isBroken() const
224  { return _pimpl->isBroken(); }
225 
226  bool Selectable::isNeeded() const
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 
245  bool Selectable::hasLocks() const
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
bool locked() const
True if locked (subclass of unmodified).
Definition: Selectable.h:471
bool hasLicenceConfirmed() const
Return value of LicenceConfirmed bit.
Status pickStatus(const PoolItem &pi_r) const
ResStatus::TransactByValue modifiedBy() const
Return who caused the modification.
Definition: Selectable.cc:236
A Solvable object within the sat Pool.
Definition: Solvable.h:53
ResPoolProxy proxy() const
preliminary
Definition: ResPool.cc:58
Status
UI status Status values calculated by Selectable.
Definition: Status.h:34
bool hasRetractedInstalled() const
True if this Selectable contains an installed retracted item.
Definition: Selectable.cc:184
ResStatus::TransactByValue modifiedBy() const
Return who caused the modification.
bool hasLocks() const
True if it includes locked items (don&#39;t mix this with the locked status).
Definition: Selectable.cc:245
Collects PoolItems of same kind and name.
Definition: Selectable.h:51
PoolItem setCandidate(const PoolItem &newCandidate_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Set a candidate (out of available objects).
Definition: Selectable.cc:100
intrusive_ptr< Selectable > Ptr
Definition: Selectable.h:57
SelectableTraits::installed_iterator installed_iterator
Definition: Selectable.h:64
picklist_iterator picklistEnd() const
bool isBroken() const
Whether a relevant patchs requirements are broken.
Definition: Selectable.cc:223
bool hasBlacklistedInstalled() const
PoolItem identicalAvailableObj(const PoolItem &rhs) const
Return an available Object with the same content as rhs.
Definition: Selectable.cc:94
bool hasBlacklistedInstalled() const
True if this Selectable contains an installed blacklisted item (retracted,ptf,...).
Definition: Selectable.cc:178
available_iterator availableEnd() const
Definition: Selectable.cc:127
bool installedEmpty() const
Definition: Selectable.cc:132
bool hasPtfInstalled() const
True if this Selectable contains an installed ptf item.
Definition: Selectable.cc:190
bool setStatus(Status state_r, ResStatus::TransactByValue causer_r)
bool identicalInstalled(const PoolItem &rhs) const
True if rhs has the same content as an installed one.
PoolItem identicalInstalledObj(const PoolItem &rhs) const
an installed Object with the same content as rhs.
Definition: Selectable.cc:97
String related utilities and Regular expression matching.
Access to the sat-pools string space.
Definition: IdString.h:42
PoolItem updateCandidateObj() const
The best candidate for update, if there is one.
Definition: Selectable.cc:79
Edition edition() const
Definition: SolvableType.h:71
static constexpr const picklist_size_type picklistNoPos
Returned by picklistPos if the Item does not belong to the picklist.
Definition: Selectable.h:288
TraitsType::constPtrType constPtr
Definition: ResObject.h:43
bool hasRetracted() const
True if this Selectable contains available retracted items.
Definition: Selectable.cc:181
IdString ident() const
The identifier.
Definition: Selectable.cc:55
bool hasRetractedInstalled() const
picklist_size_type picklistPos(const PoolItem &pi_r) const
Return the position of pi_r in the piclist or picklistNoPos.
Definition: Selectable.cc:158
PoolItem setCandidate(const PoolItem &newCandidate_r, ResStatus::TransactByValue causer_r)
Set a userCandidate (out of available objects).
PoolItem theObj() const
Best among all objects.
bool setStatus(Status state_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Try to set a new Status.
Definition: Selectable.cc:67
available_size_type availableSize() const
void setLicenceConfirmed(bool val_r=true)
Set LicenceConfirmed bit.
Definition: Selectable.cc:242
Fate fate() const
Definition: Selectable.cc:248
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 candidateObj() const
The &#39;best&#39; or &#39;most interesting&#39; among all available objects.
Definition: Selectable.cc:73
bool setInstalled(ResStatus::TransactByValue causer_r=ResStatus::USER)
Take care the item gets installed if it is not.
Definition: Selectable.cc:299
picklist_iterator picklistBegin() const
PoolItem identicalInstalledObj(const PoolItem &rhs) const
an installed Object with the same content as rhs.
installed_size_type installedSize() const
bool isSatisfied() const
Whether a relevant patchs requirements are met.
Definition: Selectable.cc:220
std::ostream & operator<<(std::ostream &str, const Selectable &obj)
Definition: Selectable.cc:327
bool hasLocks() const
True if it includes locked items (don&#39;t mix this with the locked status).
bool isUndetermined() const
Returns true for packages, because packages are not classified by the solver.
Definition: Selectable.cc:214
installed_iterator installedEnd() const
PoolItem candidateObj() const
Best among available objects.
std::ostream & dumpOn(std::ostream &str, const Selectable &obj)
Definition: Selectable.cc:330
PoolItem theObj() const
An object you could use as pars pro toto.
Definition: Selectable.cc:113
bool identicalAvailable(const PoolItem &rhs) const
True if rhs is installed and one with the same content is available.
Definition: Selectable.cc:88
available_iterator availableBegin() const
const std::string & name() const
PoolItem updateCandidateObj() const
The best candidate for update, if there is one.
bool setDeleted(ResStatus::TransactByValue causer_r=ResStatus::USER)
Take care the item gets deleted if it is installed.
Definition: Selectable.cc:317
picklist_iterator picklistBegin() const
Definition: Selectable.cc:152
PoolItem highestAvailableVersionObj() const
Simply the highest available version, ignoring priorities and policies.
Definition: Selectable.cc:82
shared_ptr< Impl > Impl_Ptr
Definition: Selectable.h:556
picklist_size_type picklistSize() const
bool identicalAvailable(const PoolItem &rhs) const
True if rhs is installed and one with the same content is available.
SelectableTraits::available_iterator available_iterator
Iterates over ResObject::constPtr.
Definition: Selectable.h:61
ResKind kind() const
The ResObjects kind.
Definition: Selectable.cc:58
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
bool identIsAutoInstalled() const
Whether this ident is flagged as AutoInstalled.
Definition: Selectable.cc:85
PoolItem identicalAvailableObj(const PoolItem &rhs) const
Return an available Object with the same content as rhs.
bool identicalInstalled(const PoolItem &rhs) const
True if rhs has the same content as an installed one.
Definition: Selectable.cc:91
installed_size_type installedSize() const
Definition: Selectable.cc:135
bool isNeeded() const
This includes unlocked broken patches, as well as those already selected to be installed.
Definition: Selectable.cc:226
available_iterator availableBegin() const
Definition: Selectable.cc:124
picklist_iterator picklistEnd() const
Definition: Selectable.cc:155
available_size_type availableSize() const
Definition: Selectable.cc:121
Status pickStatus(const PoolItem &pi_r) const
Compute the ui::Status for an individual PoolItem.
Definition: Selectable.cc:206
static Ptr get(const pool::ByIdent &ident_r)
Get the Selctable.
Definition: Selectable.cc:28
Status status() const
Return the current Status.
Definition: Selectable.cc:64
IMPL_PTR_TYPE(Selectable)
bool hasBlacklisted() const
True if this Selectable contains available blacklisted items (retracted,ptf,...). ...
Definition: Selectable.cc:175
bool isUnwanted() const
Broken (needed) but locked patches.
Definition: Selectable.cc:231
bool multiversionInstall() const
Whether at least one of the available packages has multiversionInstall set.
Definition: Selectable.cc:197
PoolItem highestAvailableVersionObj() const
Simply the highest available version, ignoring priorities and policies.
available_iterator availableEnd() const
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
Selectable(Impl_Ptr pimpl_r)
Default ctor.
Definition: Selectable.cc:36
void setLicenceConfirmed(bool val_r)
Set LicenceConfirmed bit.
installed_iterator installedBegin() const
Iterable< picklist_iterator > picklist() const
Definition: Selectable.h:284
bool hasPtf() const
True if this Selectable contains available ptf items.
Definition: Selectable.cc:187
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
SelectableTraits::picklist_iterator picklist_iterator
Definition: Selectable.h:67
bool picklistEmpty() const
Definition: Selectable.cc:146
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:50
bool setFate(Fate fate_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Definition: Selectable.cc:272
bool setPickStatus(const PoolItem &pi_r, Status state_r, ResStatus::TransactByValue causer_r)
installed_iterator installedEnd() const
Definition: Selectable.cc:141
bool pickInstall(const PoolItem &pi_r, ResStatus::TransactByValue causer_r, bool yesno_r)
ui::Selectable::Ptr lookup(const pool::ByIdent &ident_r) const
bool hasLicenceConfirmed() const
Return value of LicenceConfirmed bit.
Definition: Selectable.cc:239
bool identIsAutoInstalled() const
Whether this ident is flagged as AutoInstalled.
Resolvable kinds.
Definition: ResKind.h:32
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
bool availableEmpty() const
Definition: Selectable.cc:118
PoolItem candidateObjFrom(Repository repo_r) const
The best candidate provided by a specific Repository, if there is one.
Definition: Selectable.cc:76
SelectableTraits::picklist_size_type picklist_size_type
Definition: Selectable.h:68
PoolItem candidateObjFrom(Repository repo_r) const
The best candidate provided by a specific Repository, if there is one.
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
Solvable satSolvable() const
Return the corresponding sat::Solvable.
Definition: SolvableType.h:57
PoolItem installedObj() const
The last Installed object.
Definition: Selectable.cc:70
installed_iterator installedBegin() const
Definition: Selectable.cc:138
bool hasInstalledObj() const
True if installed object is present.
Definition: Selectable.h:311
SelectableTraits::installed_size_type installed_size_type
Definition: Selectable.h:65
bool pickDelete(const PoolItem &pi_r, ResStatus::TransactByValue causer_r, bool yesno_r)
Main filter selecting PoolItems by name and kind.
Definition: ByIdent.h:26
RW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: Selectable.h:565
PoolItem installedObj() const
Installed object (transacting ot highest version).
SelectableTraits::available_size_type available_size_type
Definition: Selectable.h:62
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
picklist_size_type picklistSize() const
Definition: Selectable.cc:149
static ResPool instance()
Singleton ctor.
Definition: ResPool.cc:37
bool isUnmaintained() const
True if this package has no replacement from the available repositories.
Definition: Selectable.cc:194
const std::string & name() const
The ResObjects name.
Definition: Selectable.cc:61