libzypp  17.14.0
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->isUnmaintained(); }
177 
179  { return _pimpl->multiversionInstall(); }
180 
181  bool Selectable::pickInstall( const PoolItem & pi_r, ResStatus::TransactByValue causer_r, bool yesno_r )
182  { return _pimpl->pickInstall( pi_r, causer_r, yesno_r ); }
183 
184  bool Selectable::pickDelete( const PoolItem & pi_r, ResStatus::TransactByValue causer_r, bool yesno_r )
185  { return _pimpl->pickDelete( pi_r, causer_r, yesno_r ); }
186 
187  Status Selectable::pickStatus( const PoolItem & pi_r ) const
188  { return _pimpl->pickStatus( pi_r ); }
189 
190  bool Selectable::setPickStatus( const PoolItem & pi_r, Status state_r, ResStatus::TransactByValue causer_r )
191  { return _pimpl->setPickStatus( pi_r, state_r, causer_r ); }
192 
194 
196  { return _pimpl->isUndetermined(); }
197 
199  { return _pimpl->isRelevant(); }
200 
202  { return _pimpl->isSatisfied(); }
203 
204  bool Selectable::isBroken() const
205  { return _pimpl->isBroken(); }
206 
207  bool Selectable::isNeeded() const
208  {
209  return fate() == TO_INSTALL || ( ! locked() && isBroken() );
210  }
211 
213  {
214  return locked() && isBroken() ;
215  }
216 
218  { return _pimpl->modifiedBy(); }
219 
221  { return _pimpl->hasLicenceConfirmed(); }
222 
224  { _pimpl->setLicenceConfirmed( val_r ); }
225 
226  bool Selectable::hasLocks() const
227  { return _pimpl->hasLocks(); }
228 
230  {
231  switch ( status() ) {
232  case S_Update:
233  case S_Install:
234  case S_AutoUpdate:
235  case S_AutoInstall:
236  return TO_INSTALL;
237  break;
238 
239  case S_Del:
240  case S_AutoDel:
241  return TO_DELETE;
242  break;
243 
244  case S_Protected:
245  case S_Taboo:
246  case S_KeepInstalled:
247  case S_NoInst:
248  break;
249  }
250  return UNMODIFIED;
251  };
252 
254  {
255  switch ( fate_r )
256  {
257  case TO_INSTALL:
258  return setStatus( hasInstalledObj() ? S_Update : S_Install, causer_r );
259  break;
260 
261  case TO_DELETE:
262  return setStatus( S_Del, causer_r );
263  break;
264 
265  case UNMODIFIED:
266  switch ( status() ) {
267  case S_Protected:
268  case S_Taboo:
269  return true;
270  break;
271  default:
272  return setStatus( hasInstalledObj() ? S_KeepInstalled : S_NoInst, causer_r );
273  break;
274  }
275  break;
276  }
277  return false;
278  }
279 
281  {
282  return( hasInstalledObj() || setStatus( S_Install, causer_r ) );
283  }
284 
286  {
287  if ( ! hasInstalledObj() )
288  return setStatus( S_Install, causer_r );
289 
290  PoolItem cand( candidateObj() );
291  if ( ! cand )
292  return true;
293 
294  return( installedObj()->edition() >= cand->edition()
295  || setStatus( S_Update, causer_r ) );
296  }
297 
299  {
300  return( ! hasInstalledObj() || setStatus( S_Del, causer_r ) );
301  }
302 
303  /******************************************************************
304  **
305  ** FUNCTION NAME : operator<<
306  ** FUNCTION TYPE : std::ostream &
307  */
308  std::ostream & operator<<( std::ostream & str, const Selectable & obj )
309  { return str << *(obj._pimpl); }
310 
311  std::ostream & dumpOn( std::ostream & str, const Selectable & obj )
312  { return dumpOn( str, *(obj._pimpl) ); }
313 
315  } // namespace ui
318 } // namespace zypp
bool locked() const
True if locked (subclass of unmodified).
Definition: Selectable.h:446
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:217
A Solvable object within the sat Pool.
Definition: Solvable.h:53
ResPoolProxy proxy() const
preliminary
Definition: ResPool.cc:54
Status
UI status Status values calculated by Selectable.
Definition: Status.h:34
ResStatus::TransactByValue modifiedBy() const
Return who caused the modification.
bool hasLocks() const
True if it includes locked items (don't mix this with the locked status).
Definition: Selectable.cc:226
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:204
PoolItem identicalAvailableObj(const PoolItem &rhs) const
Return an available Object with the same content as rhs.
Definition: Selectable.cc:94
available_iterator availableEnd() const
Definition: Selectable.cc:127
bool installedEmpty() const
Definition: Selectable.cc:132
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
\Return 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:41
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:282
TraitsType::constPtrType constPtr
Definition: ResObject.h:43
IdString ident() const
The identifier.
Definition: Selectable.cc:55
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:223
Fate fate() const
Definition: Selectable.cc:229
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 'best' or 'most interesting' 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:280
picklist_iterator picklistBegin() const
PoolItem identicalInstalledObj(const PoolItem &rhs) const
\Return 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:201
std::ostream & operator<<(std::ostream &str, const Selectable &obj)
Definition: Selectable.cc:308
bool hasLocks() const
True if it includes locked items (don'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:195
installed_iterator installedEnd() const
PoolItem candidateObj() const
Best among available objects.
std::ostream & dumpOn(std::ostream &str, const Selectable &obj)
Definition: Selectable.cc:311
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:298
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:531
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:190
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:207
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:187
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 isUnwanted() const
Broken (needed) but locked patches.
Definition: Selectable.cc:212
bool multiversionInstall() const
Whether at least one of the available packages has multiversionInstall set.
Definition: Selectable.cc:178
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:181
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:278
bool setUpToDate(ResStatus::TransactByValue causer_r=ResStatus::USER)
Take care the item gets installed if it is not, or is older.
Definition: Selectable.cc:285
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:253
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:220
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:184
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:305
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:540
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:198
picklist_size_type picklistSize() const
Definition: Selectable.cc:149
static ResPool instance()
Singleton ctor.
Definition: ResPool.cc:33
bool isUnmaintained() const
True if this package has no replacement from the available repositories.
Definition: Selectable.cc:175
const std::string & name() const
The ResObjects name.
Definition: Selectable.cc:61