libzypp  17.36.1
ResStatus.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_RESSTATUS_H
13 #define ZYPP_RESSTATUS_H
14 
15 #include <inttypes.h>
16 #include <iosfwd>
17 #include <zypp/Bit.h>
18 #include <zypp/Globals.h>
19 
21 namespace zypp
22 {
23 
24  namespace resstatus
25  {
26  struct UserLockQueryManip;
27  class StatusBackup;
28  }
29 
31  //
32  // CLASS NAME : ResStatus
33  //
55  {
56  friend std::ostream & operator<<( std::ostream & str, const ResStatus & obj );
57  friend bool operator==( const ResStatus & lhs, const ResStatus & rhs );
58 
59  public:
66  using FieldType = uint16_t;
68  // Bit Ranges within FieldType defined by 1st bit and size:
77  // enlarge FieldType if more bits are needed. It's not yet
78  // checked by the compiler.
80  public:
81 
90  {
93  };
95  {
100  };
102  {
104  LOCKED = bit::RangeValue<TransactField,1>::value, // locked, must not transact
105  TRANSACT = bit::RangeValue<TransactField,2>::value // transact according to state
106  };
108  {
113  };
114 
116  {
119  };
121  {
124  };
126  {
131  };
132 
134  {
137  };
138 
139  enum WeakValue // Unlike the other fields those are BITS that may be or'ed!
140  {
146  };
147 
148  enum UserLockQuery // internal
149  {
152  };
154 
155  public:
156 
158  ResStatus();
159 
161  ResStatus( bool isInstalled_r );
162 
164  ~ResStatus();
165 
166  ResStatus(const ResStatus &) = default;
167  ResStatus(ResStatus &&) noexcept = default;
168  ResStatus &operator=(const ResStatus &) = default;
169  ResStatus &operator=(ResStatus &&) noexcept = default;
170 
176  BitFieldType bitfield() const
177  { return _bitfield; }
178 
179  public:
180 
181  bool isLicenceConfirmed() const
182  { return fieldValueIs<LicenceConfirmedField>( LICENCE_CONFIRMED ); }
183 
184  void setLicenceConfirmed( bool toVal_r = true )
185  { fieldValueAssign<LicenceConfirmedField>( toVal_r ? LICENCE_CONFIRMED : LICENCE_UNCONFIRMED ); }
186 
187  public:
188  bool isRecommended() const
189  { return _bitfield.test( RECOMMENDED ); }
190 
191  bool isSuggested() const
192  { return _bitfield.test( SUGGESTED ); }
193 
194  bool isOrphaned() const
195  { return _bitfield.test( ORPHANED ); }
196 
197  bool isUnneeded() const
198  { return _bitfield.test( UNNEEDED ); }
199 
200  bool hasWeak() const
201  { return ! fieldValueIs<WeakField>( NO_WEAK ); }
202 
203  void resetWeak()
204  { return fieldValueAssign<WeakField>( NO_WEAK ); }
205 
206  void setRecommended( bool toVal_r = true )
207  { _bitfield.set( RECOMMENDED, toVal_r ); }
208 
209  void setSuggested( bool toVal_r = true )
210  { _bitfield.set( SUGGESTED, toVal_r ); }
211 
212  void setOrphaned( bool toVal_r = true )
213  { _bitfield.set( ORPHANED, toVal_r ); }
214 
215  void setUnneeded( bool toVal_r = true )
216  { _bitfield.set( UNNEEDED, toVal_r ); }
217 
218  public:
220  { return (ValidateValue)_bitfield.value<ValidateField>(); }
221 
222  bool isUndetermined() const
223  { return fieldValueIs<ValidateField>( UNDETERMINED ); }
224 
225  bool isSatisfied() const
226  { return fieldValueIs<ValidateField>( SATISFIED ); }
227 
228  bool isBroken() const
229  { return fieldValueIs<ValidateField>( BROKEN ); }
230 
231  bool isNonRelevant() const
232  { return fieldValueIs<ValidateField>( NONRELEVANT ); }
233 
234  std::string validateValueAsString() const
235  { return validateValueAsString( validate() ); }
236 
238  static std::string validateValueAsString( ValidateValue val_r );
239 
241  static ValidateValue stringToValidateValue( const std::string & str_r );
242 
243  public:
244  // These two are IMMUTABLE!
245 
246  bool isInstalled() const
247  { return fieldValueIs<StateField>( INSTALLED ); }
248 
249  bool isUninstalled() const
250  { return fieldValueIs<StateField>( UNINSTALLED ); }
251 
252  public:
253 
254  bool staysInstalled() const
255  { return isInstalled() && !transacts(); }
256 
257  bool wasInstalled() const { return staysInstalled(); } //for old status
258 
259  bool isToBeInstalled() const
260  { return isUninstalled() && transacts(); }
261 
262  bool staysUninstalled() const
263  { return isUninstalled() && !transacts(); }
264 
265  bool wasUninstalled() const { return staysUninstalled(); } // for old status
266 
267  bool isToBeUninstalled() const
268  { return isInstalled() && transacts(); }
269 
270  bool isLocked() const
271  { return fieldValueIs<TransactField>( LOCKED ); }
272 
273  bool isUserLocked() const
274  { return isLocked() && isByUser(); }
275 
276  bool isSoftLocked() const
277  { return isKept() && ( isByApplLow() || isByUser() ); }
278 
279  bool isKept() const
280  { return fieldValueIs<TransactField>( KEEP_STATE ); }
281 
282  bool transacts() const
283  { return fieldValueIs<TransactField>( TRANSACT ); }
284 
286  { return (TransactValue)_bitfield.value<TransactField>(); }
287 
289  bool onSystem() const
290  { return( isInstalled() != transacts() ); }
291 
293  bool offSystem() const
294  { return ! onSystem(); }
295 
296  bool isBySolver() const
297  { return fieldValueIs<TransactByField>( SOLVER ); }
298 
299  bool isByApplLow() const
300  { return fieldValueIs<TransactByField>( APPL_LOW ); }
301 
302  bool isByApplHigh() const
303  { return fieldValueIs<TransactByField>( APPL_HIGH ); }
304 
305  bool isByUser() const
306  { return fieldValueIs<TransactByField>( USER ); }
307 
309  { return (TransactByValue)_bitfield.value<TransactByField>(); }
310 
312  {
313  if ( isLessThan<TransactByField>( causer ) ) {
314  fieldValueAssign<TransactByField>( causer );
315  return true;
316  } else {
317  return false;
318  }
319  }
320 
322  { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_OBSOLETE ); }
323 
325  { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_UPGRADE ); }
326 
327  bool isToBeInstalledSoft () const
328  { return isToBeInstalled() && fieldValueIs<TransactDetailField>( SOFT_INSTALL ); }
329 
331  { return isToBeInstalled() && !fieldValueIs<TransactDetailField>( SOFT_INSTALL ); }
332 
333  bool isToBeUninstalledSoft () const
334  { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( SOFT_REMOVE ); }
335 
336  private:
340 
341  void setUserLockQueryMatch( bool match_r )
342  { fieldValueAssign<UserLockQueryField>( match_r ? USERLOCK_MATCH : USERLOCK_NOMATCH ); }
344  public:
345  bool isUserLockQueryMatch() const
346  { return fieldValueIs<UserLockQueryField>( USERLOCK_MATCH ); }
347 
348  public:
349 
350  //------------------------------------------------------------------------
351  // get/set functions, returning \c true if requested status change
352  // was successful (i.e. leading to the desired transaction).
353  // If a lower level (e.g.SOLVER) wants to transact, but it's
354  // already set by a higher level, \c true should be returned.
355  // Removing a higher levels transaction bit should fail.
356  //
357  // The may functions checks only, if the action would return true
358  // if it is called.
359 
363  bool setTransactValue( TransactValue newVal_r, TransactByValue causer_r )
364  {
365  switch ( newVal_r )
366  {
367  case KEEP_STATE:
368  return setTransact( false, causer_r );
369  break;
370  case LOCKED:
371  return setLock( true, causer_r );
372  break;
373  case TRANSACT:
374  return setTransact( true, causer_r );
375  break;
376  }
377  return false;
378  }
379 
381  {
382  bit::BitField<FieldType> savBitfield = _bitfield;
383  bool ret = setTransactValue( newVal_r, causer_r );
384  _bitfield = savBitfield;
385  return ret;
386  }
387 
393  bool setLock( bool toLock_r, TransactByValue causer_r )
394  {
395  if ( toLock_r == isLocked() )
396  {
397  // we're already in the desired state, but in case of
398  // LOCKED, remember a superior causer.
399  if ( isLocked() && isLessThan<TransactByField>( causer_r ) )
400  fieldValueAssign<TransactByField>( causer_r );
401  return true;
402  }
403  // Here: Lock status is to be changed:
404  if ( causer_r != USER && causer_r != APPL_HIGH )
405  return false;
406  if ( toLock_r ) {
407  // We're in unlocked state, which includes TRANSACT.
408  // Causer must be allowed to reset this. But from
409  // KEEP_STATE every causer is allowed to set the lock.
410  if ( ! setTransact( false, causer_r ) )
411  return false;
412  fieldValueAssign<TransactField>( LOCKED );
413  fieldValueAssign<TransactByField>( causer_r );
414  } else {
415  // To leave Locked state it needs a superior causer.
416  if ( isGreaterThan<TransactByField>( causer_r ) )
417  return false;
418  fieldValueAssign<TransactField>( KEEP_STATE );
419  fieldValueAssign<TransactByField>( SOLVER ); // reset to lowest causer
420  // in order to distinguish from keep_state_by_user
421  }
422  return true;
423  }
424 
425  bool maySetLock( bool to_r, TransactByValue causer_r )
426  {
427  bit::BitField<FieldType> savBitfield = _bitfield;
428  bool ret = setLock( to_r, causer_r );
429  _bitfield = savBitfield;
430  return ret;
431  }
432 
438  bool setTransact( bool toTansact_r, TransactByValue causer_r )
439  {
440  if ( toTansact_r == transacts() )
441  {
442  // we're already in the desired state, but in case of
443  // TRANSACT, remember a superior causer.
444  if ( transacts() && isLessThan<TransactByField>( causer_r ) )
445  fieldValueAssign<TransactByField>( causer_r );
446 
447  fieldValueAssign<TransactDetailField>( NO_DETAIL ); // Details has to be set again
448  return true;
449  }
450  // Here: transact status is to be changed:
451  if ( ! fieldValueIs<TransactField>( KEEP_STATE )
452  && isGreaterThan<TransactByField>( causer_r ) ) {
453  return false;
454  }
455 
456  if ( toTansact_r )
457  {
458  fieldValueAssign<TransactField>( TRANSACT );
459  }
460  else
461  {
462  fieldValueAssign<TransactField>( KEEP_STATE );
463  }
464  fieldValueAssign<TransactDetailField>( NO_DETAIL ); // Details has to be set again
465  fieldValueAssign<TransactByField>( causer_r );
466  return true;
467  }
468 
469  bool maySetTransact( bool val_r, TransactByValue causer )
470  {
471  bit::BitField<FieldType> savBitfield = _bitfield;
472  bool ret = setTransact (val_r, causer);
473  _bitfield = savBitfield;
474  return ret;
475  }
476 
478  bool setSoftLock( TransactByValue causer_r )
479  {
480  if ( ! setTransact( false, causer_r ) )
481  return false;
482  if ( fieldValueIs<TransactField>( KEEP_STATE )
483  && isLessThan<TransactByField>( causer_r ) )
484  fieldValueAssign<TransactByField>( causer_r );
485  return true;
486  }
487 
491  {
492  if ( ! setTransact( false, causer_r ) )
493  return false;
494  if ( fieldValueIs<TransactField>( KEEP_STATE ) )
495  fieldValueAssign<TransactByField>( SOLVER );
496  return true;
497  }
498 
508  bool setSoftTransact( bool toTansact_r, TransactByValue causer_r,
509  TransactByValue causerLimit_r )
510  {
511  if ( fieldValueIs<TransactField>( KEEP_STATE )
512  && toTansact_r != transacts()
513  && isGreaterThan<TransactByField>( causerLimit_r ) )
514  {
515  // any transact status change requires a superior causer.
516  return false;
517  }
518  return setTransact( toTansact_r, causer_r );
519  }
520 
521  bool setSoftTransact( bool toTansact_r, TransactByValue causer_r )
522  { return setSoftTransact( toTansact_r, causer_r, causer_r ); }
523 
524  bool maySetSoftTransact( bool val_r, TransactByValue causer,
525  TransactByValue causerLimit_r )
526  {
527  bit::BitField<FieldType> savBitfield = _bitfield;
528  bool ret = setSoftTransact( val_r, causer, causerLimit_r );
529  _bitfield = savBitfield;
530  return ret;
531  }
532 
533  bool maySetSoftTransact( bool val_r, TransactByValue causer )
534  { return maySetSoftTransact( val_r, causer, causer ); }
535 
537  {
538  if (isInstalled()) return false;
539  return setTransact (true, causer);
540  }
541 
543  {
544  bit::BitField<FieldType> savBitfield = _bitfield;
545  bool ret = setToBeInstalled (causer);
546  _bitfield = savBitfield;
547  return ret;
548  }
549 
551  {
552  if (!isInstalled()) return false;
553  return setTransact (true, causer);
554  }
555 
557  {
558  bit::BitField<FieldType> savBitfield = _bitfield;
559  bool ret = setToBeUninstalled (causer);
560  _bitfield = savBitfield;
561  return ret;
562  }
563 
564  //------------------------------------------------------------------------
565  // *** These are only for the Resolver ***
566 
568  {
569  if (!setToBeUninstalled (SOLVER)) return false;
570  fieldValueAssign<TransactDetailField>(DUE_TO_OBSOLETE);
571  return true;
572  }
573 
575  {
576  if (!setToBeUninstalled (causer)) return false;
577  fieldValueAssign<TransactDetailField>(DUE_TO_UPGRADE);
578  return true;
579  }
580 
582  {
583  if (isInstalled()
584  || !setSoftTransact (true, SOLVER))
585  return false;
586 
587  fieldValueAssign<TransactDetailField>(SOFT_INSTALL);
588  return true;
589  }
590 
592  {
593  if (!isInstalled()
594  || !setSoftTransact (true, SOLVER))
595  return false;
596 
597  fieldValueAssign<TransactDetailField>(SOFT_REMOVE);
598  return true;
599  }
600 
602  {
603  bit::BitField<FieldType> savBitfield = _bitfield;
604  bool ret = setToBeUninstalledSoft ();
605  _bitfield = savBitfield;
606  return ret;
607  }
608 
609  bool isSoftInstall () {
610  return fieldValueIs<TransactDetailField> (SOFT_INSTALL);
611  }
612 
613  bool isSoftUninstall () {
614  return fieldValueIs<TransactDetailField> (SOFT_REMOVE);
615  }
616 
617  bool setSoftInstall (bool flag) {
618  fieldValueAssign<TransactDetailField>(flag?SOFT_INSTALL:0);
619  return true;
620  }
621 
622  bool setSoftUninstall (bool flag) {
623  fieldValueAssign<TransactDetailField>(flag?SOFT_REMOVE:0);
624  return true;
625  }
626 
628  {
629  fieldValueAssign<ValidateField>(UNDETERMINED);
630  return true;
631  }
632 
633  bool setSatisfied ()
634  {
635  fieldValueAssign<ValidateField>(SATISFIED);
636  return true;
637  }
638 
639  bool setBroken ()
640  {
641  fieldValueAssign<ValidateField>(BROKEN);
642  return true;
643  }
644 
646  {
647  fieldValueAssign<ValidateField>(NONRELEVANT);
648  return true;
649  }
650 
651  bool setStatus( const ResStatus& newStatus_r )
652  {
653  // State field is immutable!
654  if ( _bitfield.value<StateField>() != newStatus_r._bitfield.value<StateField>() )
655  return false;
656  // Transaction state change allowed?
657  if ( ! setTransactValue( newStatus_r.getTransactValue(), newStatus_r.getTransactByValue() ) )
658  return false;
659 
660  // Ok, we take it all..
661  _bitfield = newStatus_r._bitfield;
662  return true;
663  }
664 
667  static const ResStatus toBeInstalled;
672 
673  private:
676  ValidateValue v = UNDETERMINED,
677  TransactValue t = KEEP_STATE,
678  InstallDetailValue i = EXPLICIT_INSTALL,
679  RemoveDetailValue r = EXPLICIT_REMOVE );
680 
683  template<class TField>
684  bool fieldValueIs( FieldType val_r ) const
685  { return _bitfield.isEqual<TField>( val_r ); }
686 
689  template<class TField>
691  { _bitfield.assign<TField>( val_r ); }
692 
695  template<class TField>
696  bool isGreaterThan( FieldType val_r )
697  { return _bitfield.value<TField>() > val_r; }
698 
699  template<class TField>
700  bool isLessThan( FieldType val_r )
701  { return _bitfield.value<TField>() < val_r; }
702 
703  private:
706  };
708 
710  std::ostream & operator<<( std::ostream & str, const ResStatus & obj ) ZYPP_API;
711 
713  std::ostream & operator<<( std::ostream & str, ResStatus::TransactValue obj ) ZYPP_API;
714 
716  std::ostream & operator<<( std::ostream & str, ResStatus::TransactByValue obj ) ZYPP_API;
717 
719  inline bool operator==( const ResStatus & lhs, const ResStatus & rhs )
720  { return lhs._bitfield == rhs._bitfield; }
721 
723  inline bool operator!=( const ResStatus & lhs, const ResStatus & rhs )
724  { return ! (lhs == rhs); }
725 
727 
728  namespace resstatus
729  {
731  {
732  public:
734  : _status( 0 )
735  {}
736 
737  StatusBackup( ResStatus & status_r )
738  : _status( &status_r )
740  {}
741 
742  void replay()
743  { if ( _status ) _status->_bitfield = _bitfield; }
744 
745  private:
748  };
749  }
750 
752 } // namespace zypp
754 #endif // ZYPP_RESSTATUS_H
bool setSoftInstall(bool flag)
Definition: ResStatus.h:617
bool setTransactByValue(TransactByValue causer)
Definition: ResStatus.h:311
bool isUnneeded() const
Definition: ResStatus.h:197
StatusBackup(ResStatus &status_r)
Definition: ResStatus.h:737
bool setStatus(const ResStatus &newStatus_r)
Definition: ResStatus.h:651
bool transacts() const
Definition: ResStatus.h:282
bool setUndetermined()
Definition: ResStatus.h:627
bool isByApplHigh() const
Definition: ResStatus.h:302
ResStatus::BitFieldType _bitfield
Definition: ResStatus.h:747
bool isToBeInstalled() const
Definition: ResStatus.h:259
bool setSoftUninstall(bool flag)
Definition: ResStatus.h:622
bool fieldValueIs(FieldType val_r) const
Return whether the corresponding Field has value val_r.
Definition: ResStatus.h:684
bool isNonRelevant() const
Definition: ResStatus.h:231
bool isInstalled() const
Definition: ResStatus.h:246
TInt value() const
Return the value.
Definition: Bit.h:179
static const ResStatus toBeInstalled
Definition: ResStatus.h:667
bool operator==(const ResStatus &lhs, const ResStatus &rhs)
Definition: ResStatus.h:719
ValidateValue validate() const
Definition: ResStatus.h:219
String related utilities and Regular expression matching.
bool isGreaterThan(FieldType val_r)
compare two values.
Definition: ResStatus.h:696
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
Definition: SerialNumber.cc:52
void setOrphaned(bool toVal_r=true)
Definition: ResStatus.h:212
bool isBroken() const
Definition: ResStatus.h:228
TransactValue getTransactValue() const
Definition: ResStatus.h:285
bool isRecommended() const
Definition: ResStatus.h:188
Manipulator for ResStatus::UserLockQueryField.
Definition: PoolImpl.h:43
bool maySetLock(bool to_r, TransactByValue causer_r)
Definition: ResStatus.h:425
bool resetTransact(TransactByValue causer_r)
Not the same as setTransact( false ).
Definition: ResStatus.h:490
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
void setLicenceConfirmed(bool toVal_r=true)
Definition: ResStatus.h:184
bool setToBeUninstalledDueToUpgrade(TransactByValue causer)
Definition: ResStatus.h:574
bool staysUninstalled() const
Definition: ResStatus.h:262
bool wasUninstalled() const
Definition: ResStatus.h:265
static const ResStatus toBeUninstalledDueToUpgrade
Definition: ResStatus.h:669
bool setSoftLock(TransactByValue causer_r)
Definition: ResStatus.h:478
bool maySetToBeInstalled(TransactByValue causer)
Definition: ResStatus.h:542
bool isToBeUninstalledDueToObsolete() const
Definition: ResStatus.h:321
std::string validateValueAsString() const
Definition: ResStatus.h:234
BitFieldType _bitfield
Definition: ResStatus.h:705
bool isLessThan(FieldType val_r)
Definition: ResStatus.h:700
bool setSoftTransact(bool toTansact_r, TransactByValue causer_r, TransactByValue causerLimit_r)
Soft toggle between TRANSACT and KEEP_STATE.
Definition: ResStatus.h:508
bool wasInstalled() const
Definition: ResStatus.h:257
bool isSoftUninstall()
Definition: ResStatus.h:613
bool hasWeak() const
Definition: ResStatus.h:200
bool isUserLockQueryMatch() const
Definition: ResStatus.h:345
const Arch Arch_armv7hnl Arch_armv7nhl ZYPP_API
Definition: ResTraits.h:93
bool setTransactValue(TransactValue newVal_r, TransactByValue causer_r)
Set TransactValue.
Definition: ResStatus.h:363
bool maySetTransact(bool val_r, TransactByValue causer)
Definition: ResStatus.h:469
bool maySetTransactValue(TransactValue newVal_r, TransactByValue causer_r)
Definition: ResStatus.h:380
static const ResStatus toBeUninstalledDueToObsolete
Definition: ResStatus.h:670
bool setBroken()
Definition: ResStatus.h:639
bool isSatisfied() const
Definition: ResStatus.h:225
bool isOrphaned() const
Definition: ResStatus.h:194
bool setLock(bool toLock_r, TransactByValue causer_r)
Apply a lock (prevent transaction).
Definition: ResStatus.h:393
bool setNonRelevant()
Definition: ResStatus.h:645
bool isToBeInstalledNotSoft() const
Definition: ResStatus.h:330
bool maySetToBeUninstalledSoft()
Definition: ResStatus.h:601
bool setToBeUninstalled(TransactByValue causer)
Definition: ResStatus.h:550
bool setTransact(bool toTansact_r, TransactByValue causer_r)
Toggle between TRANSACT and KEEP_STATE.
Definition: ResStatus.h:438
void setUserLockQueryMatch(bool match_r)
Definition: ResStatus.h:341
uint16_t FieldType
Definition: ResStatus.h:66
bool isByUser() const
Definition: ResStatus.h:305
bool maySetSoftTransact(bool val_r, TransactByValue causer, TransactByValue causerLimit_r)
Definition: ResStatus.h:524
bool isLicenceConfirmed() const
Definition: ResStatus.h:181
bool isUndetermined() const
Definition: ResStatus.h:222
void setRecommended(bool toVal_r=true)
Definition: ResStatus.h:206
bool isSuggested() const
Definition: ResStatus.h:191
bool isByApplLow() const
Definition: ResStatus.h:299
bool isToBeUninstalled() const
Definition: ResStatus.h:267
bool isLocked() const
Definition: ResStatus.h:270
bool isKept() const
Definition: ResStatus.h:279
bool isToBeUninstalledSoft() const
Definition: ResStatus.h:333
bool isToBeInstalledSoft() const
Definition: ResStatus.h:327
bool maySetSoftTransact(bool val_r, TransactByValue causer)
Definition: ResStatus.h:533
bool setToBeUninstalledSoft()
Definition: ResStatus.h:591
bool maySetToBeUninstalled(TransactByValue causer)
Definition: ResStatus.h:556
bool isUninstalled() const
Definition: ResStatus.h:249
bool isSoftLocked() const
Definition: ResStatus.h:276
bool setToBeInstalled(TransactByValue causer)
Definition: ResStatus.h:536
Status bitfield.
Definition: ResStatus.h:54
bool offSystem() const
True if would be off system after commit.
Definition: ResStatus.h:293
bool staysInstalled() const
Definition: ResStatus.h:254
bool setSoftTransact(bool toTansact_r, TransactByValue causer_r)
Definition: ResStatus.h:521
bool isUserLocked() const
Definition: ResStatus.h:273
void fieldValueAssign(FieldType val_r)
Set the corresponding Field to value val_r.
Definition: ResStatus.h:690
void resetWeak()
Definition: ResStatus.h:203
bool setToBeInstalledSoft()
Definition: ResStatus.h:581
bool onSystem() const
True if would be on system after commit.
Definition: ResStatus.h:289
void setUnneeded(bool toVal_r=true)
Definition: ResStatus.h:215
Easy-to use interface to the ZYPP dependency resolver.
Definition: Application.cc:19
bool setSatisfied()
Definition: ResStatus.h:633
TransactByValue getTransactByValue() const
Definition: ResStatus.h:308
Range of bits starting at bit _begin with length _size.
Definition: Bit.h:81
static const ResStatus toBeUninstalled
Definition: ResStatus.h:668
bool setToBeUninstalledDueToObsolete()
Definition: ResStatus.h:567
bool isSoftInstall()
Definition: ResStatus.h:609
bool isBySolver() const
Definition: ResStatus.h:296
bool isToBeUninstalledDueToUpgrade() const
Definition: ResStatus.h:324
void setSuggested(bool toVal_r=true)
Definition: ResStatus.h:209
bool operator!=(const ResStatus &lhs, const ResStatus &rhs)
Definition: ResStatus.h:723
A value with in a Range.
Definition: Bit.h:110