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); }
bool staysUninstalled() const
bool isLessThan(FieldType val_r)
bool isLicenceConfirmed() const
bool isSoftLocked() const
static const ResStatus toBeInstalled
ValidateValue validate() const
void setUserLockQueryMatch(bool match_r)
bool isGreaterThan(FieldType val_r)
compare two values.
bool isToBeInstalledSoft() const
bool onSystem() const
True if would be on system after commit.
bool setToBeUninstalled(TransactByValue causer)
bool setToBeUninstalledDueToObsolete()
static const ResStatus toBeUninstalledDueToObsolete
void setLicenceConfirmed(bool toVal_r=true)
bool setSoftInstall(bool flag)
void setRecommended(bool toVal_r=true)
bool maySetSoftTransact(bool val_r, TransactByValue causer)
bool maySetTransactValue(TransactValue newVal_r, TransactByValue causer_r)
bool setTransactValue(TransactValue newVal_r, TransactByValue causer_r)
Set TransactValue.
bool isUndetermined() const
bool fieldValueIs(FieldType val_r) const
Return whether the corresponding Field has value val_r.
bool setTransact(bool toTansact_r, TransactByValue causer_r)
Toggle between TRANSACT and KEEP_STATE.
bool isToBeInstalled() const
bool offSystem() const
True if would be off system after commit.
bool isByApplHigh() const
void setOrphaned(bool toVal_r=true)
bool isNonRelevant() const
bool setToBeInstalled(TransactByValue causer)
bool setStatus(const ResStatus &newStatus_r)
void setUnneeded(bool toVal_r=true)
bool isUserLockQueryMatch() const
ResStatus(ResStatus &&) noexcept=default
bool wasInstalled() const
bool setToBeUninstalledSoft()
bool maySetToBeUninstalled(TransactByValue causer)
bool setSoftLock(TransactByValue causer_r)
bool setLock(bool toLock_r, TransactByValue causer_r)
Apply a lock (prevent transaction).
TransactValue getTransactValue() const
bool staysInstalled() const
static const ResStatus toBeUninstalledDueToUpgrade
bool maySetToBeInstalled(TransactByValue causer)
bool isToBeUninstalledDueToObsolete() const
bool setSoftTransact(bool toTansact_r, TransactByValue causer_r, TransactByValue causerLimit_r)
Soft toggle between TRANSACT and KEEP_STATE.
bool setSoftTransact(bool toTansact_r, TransactByValue causer_r)
bool setToBeInstalledSoft()
static const ResStatus toBeUninstalled
bool isUserLocked() const
bool wasUninstalled() const
bool maySetToBeUninstalledSoft()
bool isRecommended() const
bool maySetTransact(bool val_r, TransactByValue causer)
bool operator!=(const ResStatus &lhs, const ResStatus &rhs)
bool isToBeUninstalled() const
std::string validateValueAsString() const
bool isToBeUninstalledDueToUpgrade() const
TransactByValue getTransactByValue() const
ResStatus(const ResStatus &)=default
bool resetTransact(TransactByValue causer_r)
Not the same as setTransact( false ).
void setSuggested(bool toVal_r=true)
bool setSoftUninstall(bool flag)
bool maySetSoftTransact(bool val_r, TransactByValue causer, TransactByValue causerLimit_r)
bool setTransactByValue(TransactByValue causer)
bool maySetLock(bool to_r, TransactByValue causer_r)
bool isToBeInstalledNotSoft() const
void fieldValueAssign(FieldType val_r)
Set the corresponding Field to value val_r.
bool setToBeUninstalledDueToUpgrade(TransactByValue causer)
bool isToBeUninstalledSoft() const
bool isUninstalled() const
friend bool operator==(const ResStatus &lhs, const ResStatus &rhs)
TInt value() const
Return the value.
StatusBackup(ResStatus &status_r)
ResStatus::BitFieldType _bitfield
String related utilities and Regular expression matching.
Easy-to use interface to the ZYPP dependency resolver.
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
const Arch Arch_armv7hnl Arch_armv7nhl ZYPP_API
Range of bits starting at bit _begin with length _size.
Manipulator for ResStatus::UserLockQueryField.