12 #ifndef ZYPP_RESSTATUS_H 13 #define ZYPP_RESSTATUS_H 26 struct UserLockQueryManip;
177 {
return _bitfield; }
182 {
return fieldValueIs<LicenceConfirmedField>( LICENCE_CONFIRMED ); }
185 { fieldValueAssign<LicenceConfirmedField>( toVal_r ? LICENCE_CONFIRMED : LICENCE_UNCONFIRMED ); }
189 {
return _bitfield.test( RECOMMENDED ); }
192 {
return _bitfield.test( SUGGESTED ); }
195 {
return _bitfield.test( ORPHANED ); }
198 {
return _bitfield.test( UNNEEDED ); }
201 {
return ! fieldValueIs<WeakField>( NO_WEAK ); }
204 {
return fieldValueAssign<WeakField>( NO_WEAK ); }
207 { _bitfield.set( RECOMMENDED, toVal_r ); }
210 { _bitfield.set( SUGGESTED, toVal_r ); }
213 { _bitfield.set( ORPHANED, toVal_r ); }
216 { _bitfield.set( UNNEEDED, toVal_r ); }
223 {
return fieldValueIs<ValidateField>( UNDETERMINED ); }
226 {
return fieldValueIs<ValidateField>( SATISFIED ); }
229 {
return fieldValueIs<ValidateField>( BROKEN ); }
232 {
return fieldValueIs<ValidateField>( NONRELEVANT ); }
235 {
return validateValueAsString( validate() ); }
238 static std::string validateValueAsString( ValidateValue val_r );
241 static ValidateValue stringToValidateValue(
const std::string & str_r );
247 {
return fieldValueIs<StateField>( INSTALLED ); }
250 {
return fieldValueIs<StateField>( UNINSTALLED ); }
255 {
return isInstalled() && !transacts(); }
260 {
return isUninstalled() && transacts(); }
263 {
return isUninstalled() && !transacts(); }
268 {
return isInstalled() && transacts(); }
271 {
return fieldValueIs<TransactField>( LOCKED ); }
274 {
return isLocked() && isByUser(); }
277 {
return isKept() && ( isByApplLow() || isByUser() ); }
280 {
return fieldValueIs<TransactField>( KEEP_STATE ); }
283 {
return fieldValueIs<TransactField>( TRANSACT ); }
290 {
return( isInstalled() != transacts() ); }
294 {
return ! onSystem(); }
297 {
return fieldValueIs<TransactByField>( SOLVER ); }
300 {
return fieldValueIs<TransactByField>( APPL_LOW ); }
303 {
return fieldValueIs<TransactByField>( APPL_HIGH ); }
306 {
return fieldValueIs<TransactByField>( USER ); }
313 if ( isLessThan<TransactByField>( causer ) ) {
314 fieldValueAssign<TransactByField>( causer );
322 {
return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_OBSOLETE ); }
325 {
return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_UPGRADE ); }
328 {
return isToBeInstalled() && fieldValueIs<TransactDetailField>( SOFT_INSTALL ); }
331 {
return isToBeInstalled() && !fieldValueIs<TransactDetailField>( SOFT_INSTALL ); }
334 {
return isToBeUninstalled() && fieldValueIs<TransactDetailField>( SOFT_REMOVE ); }
342 { fieldValueAssign<UserLockQueryField>( match_r ? USERLOCK_MATCH : USERLOCK_NOMATCH ); }
346 {
return fieldValueIs<UserLockQueryField>( USERLOCK_MATCH ); }
368 return setTransact(
false, causer_r );
371 return setLock(
true, causer_r );
374 return setTransact(
true, causer_r );
383 bool ret = setTransactValue( newVal_r, causer_r );
384 _bitfield = savBitfield;
395 if ( toLock_r == isLocked() )
399 if ( isLocked() && isLessThan<TransactByField>( causer_r ) )
400 fieldValueAssign<TransactByField>( causer_r );
404 if ( causer_r != USER && causer_r != APPL_HIGH )
410 if ( ! setTransact(
false, causer_r ) )
412 fieldValueAssign<TransactField>( LOCKED );
413 fieldValueAssign<TransactByField>( causer_r );
416 if ( isGreaterThan<TransactByField>( causer_r ) )
418 fieldValueAssign<TransactField>( KEEP_STATE );
419 fieldValueAssign<TransactByField>( SOLVER );
428 bool ret = setLock( to_r, causer_r );
429 _bitfield = savBitfield;
440 if ( toTansact_r == transacts() )
444 if ( transacts() && isLessThan<TransactByField>( causer_r ) )
445 fieldValueAssign<TransactByField>( causer_r );
447 fieldValueAssign<TransactDetailField>( NO_DETAIL );
451 if ( ! fieldValueIs<TransactField>( KEEP_STATE )
452 && isGreaterThan<TransactByField>( causer_r ) ) {
458 fieldValueAssign<TransactField>( TRANSACT );
462 fieldValueAssign<TransactField>( KEEP_STATE );
464 fieldValueAssign<TransactDetailField>( NO_DETAIL );
465 fieldValueAssign<TransactByField>( causer_r );
472 bool ret = setTransact (val_r, causer);
473 _bitfield = savBitfield;
480 if ( ! setTransact(
false, causer_r ) )
482 if ( fieldValueIs<TransactField>( KEEP_STATE )
483 && isLessThan<TransactByField>( causer_r ) )
484 fieldValueAssign<TransactByField>( causer_r );
492 if ( ! setTransact(
false, causer_r ) )
494 if ( fieldValueIs<TransactField>( KEEP_STATE ) )
495 fieldValueAssign<TransactByField>( SOLVER );
511 if ( fieldValueIs<TransactField>( KEEP_STATE )
512 && toTansact_r != transacts()
513 && isGreaterThan<TransactByField>( causerLimit_r ) )
518 return setTransact( toTansact_r, causer_r );
522 {
return setSoftTransact( toTansact_r, causer_r, causer_r ); }
528 bool ret = setSoftTransact( val_r, causer, causerLimit_r );
529 _bitfield = savBitfield;
534 {
return maySetSoftTransact( val_r, causer, causer ); }
538 if (isInstalled())
return false;
539 return setTransact (
true, causer);
545 bool ret = setToBeInstalled (causer);
546 _bitfield = savBitfield;
552 if (!isInstalled())
return false;
553 return setTransact (
true, causer);
559 bool ret = setToBeUninstalled (causer);
560 _bitfield = savBitfield;
569 if (!setToBeUninstalled (SOLVER))
return false;
570 fieldValueAssign<TransactDetailField>(DUE_TO_OBSOLETE);
576 if (!setToBeUninstalled (causer))
return false;
577 fieldValueAssign<TransactDetailField>(DUE_TO_UPGRADE);
584 || !setSoftTransact (
true, SOLVER))
587 fieldValueAssign<TransactDetailField>(SOFT_INSTALL);
594 || !setSoftTransact (
true, SOLVER))
597 fieldValueAssign<TransactDetailField>(SOFT_REMOVE);
604 bool ret = setToBeUninstalledSoft ();
605 _bitfield = savBitfield;
610 return fieldValueIs<TransactDetailField> (SOFT_INSTALL);
614 return fieldValueIs<TransactDetailField> (SOFT_REMOVE);
618 fieldValueAssign<TransactDetailField>(flag?SOFT_INSTALL:0);
623 fieldValueAssign<TransactDetailField>(flag?SOFT_REMOVE:0);
629 fieldValueAssign<ValidateField>(UNDETERMINED);
635 fieldValueAssign<ValidateField>(SATISFIED);
641 fieldValueAssign<ValidateField>(BROKEN);
647 fieldValueAssign<ValidateField>(NONRELEVANT);
683 template<
class TField>
685 {
return _bitfield.isEqual<TField>( val_r ); }
689 template<
class TField>
691 { _bitfield.assign<TField>( val_r ); }
695 template<
class TField>
697 {
return _bitfield.value<TField>() > val_r; }
699 template<
class TField>
701 {
return _bitfield.value<TField>() < val_r; }
724 {
return ! (lhs == rhs); }
754 #endif // ZYPP_RESSTATUS_H bool setSoftInstall(bool flag)
bool setTransactByValue(TransactByValue causer)
StatusBackup(ResStatus &status_r)
bool setStatus(const ResStatus &newStatus_r)
bool isByApplHigh() const
ResStatus::BitFieldType _bitfield
bool isToBeInstalled() const
bool setSoftUninstall(bool flag)
bool fieldValueIs(FieldType val_r) const
Return whether the corresponding Field has value val_r.
bool isNonRelevant() const
TInt value() const
Return the value.
static const ResStatus toBeInstalled
bool operator==(const ResStatus &lhs, const ResStatus &rhs)
ValidateValue validate() const
String related utilities and Regular expression matching.
bool isGreaterThan(FieldType val_r)
compare two values.
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
void setOrphaned(bool toVal_r=true)
TransactValue getTransactValue() const
bool isRecommended() 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)
void setLicenceConfirmed(bool toVal_r=true)
bool setToBeUninstalledDueToUpgrade(TransactByValue causer)
bool staysUninstalled() const
bool wasUninstalled() const
static const ResStatus toBeUninstalledDueToUpgrade
bool setSoftLock(TransactByValue causer_r)
bool maySetToBeInstalled(TransactByValue causer)
bool isToBeUninstalledDueToObsolete() const
std::string validateValueAsString() const
bool isLessThan(FieldType val_r)
bool setSoftTransact(bool toTansact_r, TransactByValue causer_r, TransactByValue causerLimit_r)
Soft toggle between TRANSACT and KEEP_STATE.
bool wasInstalled() const
bool isUserLockQueryMatch() const
const Arch Arch_armv7hnl Arch_armv7nhl ZYPP_API
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)
static const ResStatus toBeUninstalledDueToObsolete
bool setLock(bool toLock_r, TransactByValue causer_r)
Apply a lock (prevent transaction).
bool isToBeInstalledNotSoft() const
bool maySetToBeUninstalledSoft()
bool setToBeUninstalled(TransactByValue causer)
bool setTransact(bool toTansact_r, TransactByValue causer_r)
Toggle between TRANSACT and KEEP_STATE.
void setUserLockQueryMatch(bool match_r)
bool maySetSoftTransact(bool val_r, TransactByValue causer, TransactByValue causerLimit_r)
bool isLicenceConfirmed() const
bool isUndetermined() const
void setRecommended(bool toVal_r=true)
bool isToBeUninstalled() const
bool isToBeUninstalledSoft() const
bool isToBeInstalledSoft() const
bool maySetSoftTransact(bool val_r, TransactByValue causer)
bool setToBeUninstalledSoft()
bool maySetToBeUninstalled(TransactByValue causer)
bool isUninstalled() const
bool isSoftLocked() const
bool setToBeInstalled(TransactByValue causer)
bool offSystem() const
True if would be off system after commit.
bool staysInstalled() const
bool setSoftTransact(bool toTansact_r, TransactByValue causer_r)
bool isUserLocked() const
void fieldValueAssign(FieldType val_r)
Set the corresponding Field to value val_r.
bool setToBeInstalledSoft()
bool onSystem() const
True if would be on system after commit.
void setUnneeded(bool toVal_r=true)
Easy-to use interface to the ZYPP dependency resolver.
TransactByValue getTransactByValue() const
Range of bits starting at bit _begin with length _size.
static const ResStatus toBeUninstalled
bool setToBeUninstalledDueToObsolete()
bool isToBeUninstalledDueToUpgrade() const
void setSuggested(bool toVal_r=true)
bool operator!=(const ResStatus &lhs, const ResStatus &rhs)