12 #ifndef ZYPP_RESSTATUS_H 13 #define ZYPP_RESSTATUS_H 25 class UserLockQueryManip;
171 {
return _bitfield; }
176 {
return fieldValueIs<LicenceConfirmedField>( LICENCE_CONFIRMED ); }
179 { fieldValueAssign<LicenceConfirmedField>( toVal_r ? LICENCE_CONFIRMED : LICENCE_UNCONFIRMED ); }
183 {
return _bitfield.test( RECOMMENDED ); }
186 {
return _bitfield.test( SUGGESTED ); }
189 {
return _bitfield.test( ORPHANED ); }
192 {
return _bitfield.test( UNNEEDED ); }
195 {
return ! fieldValueIs<WeakField>( NO_WEAK ); }
198 {
return fieldValueAssign<WeakField>( NO_WEAK ); }
201 { _bitfield.set( RECOMMENDED, toVal_r ); }
204 { _bitfield.set( SUGGESTED, toVal_r ); }
207 { _bitfield.set( ORPHANED, toVal_r ); }
210 { _bitfield.set( UNNEEDED, toVal_r ); }
217 {
return fieldValueIs<ValidateField>( UNDETERMINED ); }
220 {
return fieldValueIs<ValidateField>( SATISFIED ); }
223 {
return fieldValueIs<ValidateField>( BROKEN ); }
226 {
return fieldValueIs<ValidateField>( NONRELEVANT ); }
232 {
return fieldValueIs<StateField>( INSTALLED ); }
235 {
return fieldValueIs<StateField>( UNINSTALLED ); }
240 {
return isInstalled() && !transacts(); }
245 {
return isUninstalled() && transacts(); }
248 {
return isUninstalled() && !transacts(); }
253 {
return isInstalled() && transacts(); }
256 {
return fieldValueIs<TransactField>( LOCKED ); }
259 {
return isLocked() && isByUser(); }
262 {
return isKept() && ( isByApplLow() || isByUser() ); }
265 {
return fieldValueIs<TransactField>( KEEP_STATE ); }
268 {
return fieldValueIs<TransactField>( TRANSACT ); }
275 {
return( isInstalled() != transacts() ); }
279 {
return ! onSystem(); }
282 {
return fieldValueIs<TransactByField>( SOLVER ); }
285 {
return fieldValueIs<TransactByField>( APPL_LOW ); }
288 {
return fieldValueIs<TransactByField>( APPL_HIGH ); }
291 {
return fieldValueIs<TransactByField>( USER ); }
298 if ( isLessThan<TransactByField>( causer ) ) {
299 fieldValueAssign<TransactByField>( causer );
307 {
return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_OBSOLETE ); }
310 {
return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_UPGRADE ); }
313 {
return isToBeInstalled() && fieldValueIs<TransactDetailField>( SOFT_INSTALL ); }
316 {
return isToBeInstalled() && !fieldValueIs<TransactDetailField>( SOFT_INSTALL ); }
319 {
return isToBeUninstalled() && fieldValueIs<TransactDetailField>( SOFT_REMOVE ); }
328 {
return fieldValueIs<UserLockQueryField>( USERLOCK_MATCH ); }
331 { fieldValueAssign<UserLockQueryField>( match_r ? USERLOCK_MATCH : USERLOCK_NOMATCH ); }
354 return setTransact(
false, causer_r );
357 return setLock(
true, causer_r );
360 return setTransact(
true, causer_r );
369 bool ret = setTransactValue( newVal_r, causer_r );
370 _bitfield = savBitfield;
381 if ( toLock_r == isLocked() )
385 if ( isLocked() && isLessThan<TransactByField>( causer_r ) )
386 fieldValueAssign<TransactByField>( causer_r );
390 if ( causer_r != USER && causer_r != APPL_HIGH )
396 if ( ! setTransact(
false, causer_r ) )
398 fieldValueAssign<TransactField>( LOCKED );
399 fieldValueAssign<TransactByField>( causer_r );
402 if ( isGreaterThan<TransactByField>( causer_r ) )
404 fieldValueAssign<TransactField>( KEEP_STATE );
405 fieldValueAssign<TransactByField>( SOLVER );
414 bool ret = setLock( to_r, causer_r );
415 _bitfield = savBitfield;
426 if ( toTansact_r == transacts() )
430 if ( transacts() && isLessThan<TransactByField>( causer_r ) )
431 fieldValueAssign<TransactByField>( causer_r );
433 fieldValueAssign<TransactDetailField>( NO_DETAIL );
437 if ( ! fieldValueIs<TransactField>( KEEP_STATE )
438 && isGreaterThan<TransactByField>( causer_r ) ) {
444 fieldValueAssign<TransactField>( TRANSACT );
448 fieldValueAssign<TransactField>( KEEP_STATE );
450 fieldValueAssign<TransactDetailField>( NO_DETAIL );
451 fieldValueAssign<TransactByField>( causer_r );
458 bool ret = setTransact (val_r, causer);
459 _bitfield = savBitfield;
466 if ( ! setTransact(
false, causer_r ) )
468 if ( fieldValueIs<TransactField>( KEEP_STATE )
469 && isLessThan<TransactByField>( causer_r ) )
470 fieldValueAssign<TransactByField>( causer_r );
478 if ( ! setTransact(
false, causer_r ) )
480 if ( fieldValueIs<TransactField>( KEEP_STATE ) )
481 fieldValueAssign<TransactByField>( SOLVER );
497 if ( fieldValueIs<TransactField>( KEEP_STATE )
498 && toTansact_r != transacts()
499 && isGreaterThan<TransactByField>( causerLimit_r ) )
504 return setTransact( toTansact_r, causer_r );
508 {
return setSoftTransact( toTansact_r, causer_r, causer_r ); }
514 bool ret = setSoftTransact( val_r, causer, causerLimit_r );
515 _bitfield = savBitfield;
520 {
return maySetSoftTransact( val_r, causer, causer ); }
524 if (isInstalled())
return false;
525 return setTransact (
true, causer);
531 bool ret = setToBeInstalled (causer);
532 _bitfield = savBitfield;
538 if (!isInstalled())
return false;
539 return setTransact (
true, causer);
545 bool ret = setToBeUninstalled (causer);
546 _bitfield = savBitfield;
555 if (!setToBeUninstalled (SOLVER))
return false;
556 fieldValueAssign<TransactDetailField>(DUE_TO_OBSOLETE);
562 if (!setToBeUninstalled (causer))
return false;
563 fieldValueAssign<TransactDetailField>(DUE_TO_UPGRADE);
570 || !setSoftTransact (
true, SOLVER))
573 fieldValueAssign<TransactDetailField>(SOFT_INSTALL);
580 || !setSoftTransact (
true, SOLVER))
583 fieldValueAssign<TransactDetailField>(SOFT_REMOVE);
590 bool ret = setToBeUninstalledSoft ();
591 _bitfield = savBitfield;
596 return fieldValueIs<TransactDetailField> (SOFT_INSTALL);
600 return fieldValueIs<TransactDetailField> (SOFT_REMOVE);
604 fieldValueAssign<TransactDetailField>(flag?SOFT_INSTALL:0);
609 fieldValueAssign<TransactDetailField>(flag?SOFT_REMOVE:0);
615 fieldValueAssign<ValidateField>(UNDETERMINED);
621 fieldValueAssign<ValidateField>(SATISFIED);
627 fieldValueAssign<ValidateField>(BROKEN);
633 fieldValueAssign<ValidateField>(NONRELEVANT);
640 if ( _bitfield.value<StateField>() != newStatus_r.
_bitfield.
value<StateField>() )
669 template<
class TField>
671 {
return _bitfield.isEqual<TField>( val_r ); }
675 template<
class TField>
677 { _bitfield.assign<TField>( val_r ); }
681 template<
class TField>
683 {
return _bitfield.value<TField>() > val_r; }
685 template<
class TField>
687 {
return _bitfield.value<TField>() < val_r; }
710 {
return ! (lhs == rhs); }
724 : _status( &status_r )
725 , _bitfield( _status->_bitfield )
729 {
if ( _status ) _status->_bitfield = _bitfield; }
740 #endif // ZYPP_RESSTATUS_H bool setSoftInstall(bool flag)
bool setTransactByValue(TransactByValue causer)
StatusBackup(ResStatus &status_r)
bit::BitField< FieldType > BitFieldType
bool staysUninstalled() const
TransactValue getTransactValue() const
bool isToBeUninstalledDueToUpgrade() const
ResStatus::BitFieldType _bitfield
bool isToBeUninstalled() const
bool setSoftUninstall(bool flag)
bool isNonRelevant() const
bool isToBeInstalledSoft() const
bit::Range< FieldType, LicenceConfirmedField::end, 4 > WeakField
bool isToBeUninstalledSoft() const
static const ResStatus toBeInstalled
bool wasUninstalled() const
bool operator==(const ResStatus &lhs, const ResStatus &rhs)
bool isUninstalled() const
String related utilities and Regular expression matching.
bool isGreaterThan(FieldType val_r)
compare two values.
void setOrphaned(bool toVal_r=true)
ValidateValue validate() const
Manipulator for ResStatus::UserLockQueryField.
bool maySetLock(bool to_r, TransactByValue causer_r)
bool resetTransact(TransactByValue causer_r)
Not the same as setTransact( false ).
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
bit::Range< FieldType, WeakField::end, 1 > UserLockQueryField
void setLicenceConfirmed(bool toVal_r=true)
bool setToBeUninstalledDueToUpgrade(TransactByValue causer)
bool onSystem() const
True if would be on system after commit.
static const ResStatus toBeUninstalledDueToUpgrade
bool setSoftLock(TransactByValue causer_r)
bool maySetToBeInstalled(TransactByValue causer)
bool isLessThan(FieldType val_r)
bool setSoftTransact(bool toTansact_r, TransactByValue causer_r, TransactByValue causerLimit_r)
Soft toggle between TRANSACT and KEEP_STATE.
BitFieldType bitfield() const
Debug helper returning the bitfield.
std::ostream & operator<<(std::ostream &str, const Exception &obj)
bit::Range< FieldType, TransactField::end, 2 > TransactByField
bit::Range< FieldType, ValidateField::end, 2 > TransactField
bool setTransactValue(TransactValue newVal_r, TransactByValue causer_r)
Set TransactValue.
bool maySetTransact(bool val_r, TransactByValue causer)
bool maySetTransactValue(TransactValue newVal_r, TransactByValue causer_r)
bit::Range< FieldType, TransactDetailField::end, 1 > LicenceConfirmedField
static const ResStatus toBeUninstalledDueToObsolete
bit::Range< FieldType, StateField::end, 2 > ValidateField
bit::Range< FieldType, 0, 1 > StateField
bool isUserLocked() const
bool setLock(bool toLock_r, TransactByValue causer_r)
Apply a lock (prevent transaction).
bool isByApplHigh() const
bool maySetToBeUninstalledSoft()
bool isLicenceConfirmed() const
bool setToBeUninstalled(TransactByValue causer)
bool setTransact(bool toTansact_r, TransactByValue causer_r)
Toggle between TRANSACT and KEEP_STATE.
bool isUndetermined() const
void setUserLockQueryMatch(bool match_r)
bool maySetSoftTransact(bool val_r, TransactByValue causer, TransactByValue causerLimit_r)
TInt value() const
Return the value.
bit::Range< FieldType, TransactByField::end, 2 > TransactDetailField
void setRecommended(bool toVal_r=true)
bool fieldValueIs(FieldType val_r) const
Return whether the corresponding Field has value val_r.
bool isToBeInstalled() const
bool setStatus(ResStatus newStatus_r)
bool wasInstalled() const
bool maySetSoftTransact(bool val_r, TransactByValue causer)
bool setToBeUninstalledSoft()
bool maySetToBeUninstalled(TransactByValue causer)
bool isToBeUninstalledDueToObsolete() const
bool setToBeInstalled(TransactByValue causer)
bool setSoftTransact(bool toTansact_r, TransactByValue causer_r)
bool isSoftLocked() const
void fieldValueAssign(FieldType val_r)
Set the corresponding Field to value val_r.
bool setToBeInstalledSoft()
void setUnneeded(bool toVal_r=true)
Easy-to use interface to the ZYPP dependency resolver.
bool isToBeInstalledNotSoft() const
Range of bits starting at bit _begin with length _size.
static const ResStatus toBeUninstalled
bool setToBeUninstalledDueToObsolete()
bool offSystem() const
True if would be off system after commit.
bool isUserLockQueryMatch() const
TransactByValue getTransactByValue() const
bool staysInstalled() const
bool isRecommended() const
void setSuggested(bool toVal_r=true)
bool operator!=(const ResStatus &lhs, const ResStatus &rhs)