00001
00002
00003
00004
00005
00006
00007
00008
00012 #ifndef ZYPP_RESSTATUS_H
00013 #define ZYPP_RESSTATUS_H
00014
00015 #include <iosfwd>
00016
00017 #include "zypp/Bit.h"
00018
00020 namespace zypp
00021 {
00022
00024
00025
00026
00047 class ResStatus
00048 {
00049 friend std::ostream & operator<<( std::ostream & str, const ResStatus & obj );
00050 friend bool operator==( const ResStatus & lhs, const ResStatus & rhs );
00051
00052 public:
00059 typedef uint16_t FieldType;
00060 typedef bit::BitField<FieldType> BitFieldType;
00061
00062 typedef bit::Range<FieldType,0, 1> StateField;
00063 typedef bit::Range<FieldType,StateField::end, 2> EstablishField;
00064 typedef bit::Range<FieldType,EstablishField::end, 2> TransactField;
00065 typedef bit::Range<FieldType,TransactField::end, 2> TransactByField;
00066 typedef bit::Range<FieldType,TransactByField::end, 3> TransactDetailField;
00067 typedef bit::Range<FieldType,TransactDetailField::end, 2> SolverStateField;
00068 typedef bit::Range<FieldType,SolverStateField::end, 1> LicenceConfirmedField;
00069
00070
00072 public:
00073
00081 enum StateValue
00082 {
00083 UNINSTALLED = bit::RangeValue<StateField,0>::value,
00084 INSTALLED = bit::RangeValue<StateField,1>::value
00085 };
00086 enum EstablishValue
00087 {
00088 UNDETERMINED = bit::RangeValue<EstablishField,0>::value,
00089 UNNEEDED = bit::RangeValue<EstablishField,1>::value,
00090 SATISFIED = bit::RangeValue<EstablishField,2>::value,
00091 INCOMPLETE = bit::RangeValue<EstablishField,3>::value
00092 };
00093 enum TransactValue
00094 {
00095 KEEP_STATE = bit::RangeValue<TransactField,0>::value,
00096 LOCKED = bit::RangeValue<TransactField,1>::value,
00097 TRANSACT = bit::RangeValue<TransactField,2>::value
00098 };
00099 enum TransactByValue
00100 {
00101 SOLVER = bit::RangeValue<TransactByField,0>::value,
00102 APPL_LOW = bit::RangeValue<TransactByField,1>::value,
00103 APPL_HIGH = bit::RangeValue<TransactByField,2>::value,
00104 USER = bit::RangeValue<TransactByField,3>::value
00105 };
00106
00107 enum DetailValue
00108 {
00110 NO_DETAIL = bit::RangeValue<TransactDetailField,0>::value,
00111 };
00112
00113 enum InstallDetailValue
00114 {
00115 EXPLICIT_INSTALL = bit::RangeValue<TransactDetailField,0>::value,
00116 SOFT_INSTALL = bit::RangeValue<TransactDetailField,1>::value
00117 };
00118 enum RemoveDetailValue
00119 {
00120 EXPLICIT_REMOVE = bit::RangeValue<TransactDetailField,0>::value,
00121 SOFT_REMOVE = bit::RangeValue<TransactDetailField,1>::value,
00122 DUE_TO_OBSOLETE = bit::RangeValue<TransactDetailField,2>::value,
00123 DUE_TO_UNLINK = bit::RangeValue<TransactDetailField,3>::value,
00124 DUE_TO_UPGRADE = bit::RangeValue<TransactDetailField,4>::value
00125 };
00126 enum SolverStateValue
00127 {
00128 NORMAL = bit::RangeValue<SolverStateField,0>::value,
00129 SEEN = bit::RangeValue<SolverStateField,1>::value,
00130 IMPOSSIBLE = bit::RangeValue<SolverStateField,2>::value
00131 };
00132
00133 enum LicenceConfirmedValue
00134 {
00135 LICENCE_UNCONFIRMED = bit::RangeValue<LicenceConfirmedField,0>::value,
00136 LICENCE_CONFIRMED = bit::RangeValue<LicenceConfirmedField,1>::value
00137 };
00139
00140 public:
00141
00143 ResStatus();
00144
00146 ResStatus( bool isInstalled_r );
00147
00149 ~ResStatus();
00150
00156 BitFieldType bitfield() const
00157 { return _bitfield; }
00158
00159 public:
00160
00161 bool isLicenceConfirmed() const
00162 { return fieldValueIs<LicenceConfirmedField>( LICENCE_CONFIRMED ); }
00163
00164 void setLicenceConfirmed( bool toVal_r = true )
00165 { fieldValueAssign<LicenceConfirmedField>( toVal_r ? LICENCE_CONFIRMED : LICENCE_UNCONFIRMED ); }
00166
00167 public:
00168
00169
00170 bool isInstalled() const
00171 { return fieldValueIs<StateField>( INSTALLED ); }
00172
00173 bool isUninstalled() const
00174 { return fieldValueIs<StateField>( UNINSTALLED ); }
00175
00176 public:
00177
00178 bool staysInstalled() const
00179 { return isInstalled() && !transacts(); }
00180
00181 bool wasInstalled() const { return staysInstalled(); }
00182
00183 bool isToBeInstalled() const
00184 { return isUninstalled() && transacts(); }
00185
00186 bool staysUninstalled() const
00187 { return isUninstalled() && !transacts(); }
00188
00189 bool wasUninstalled() const { return staysUninstalled(); }
00190
00191 bool isToBeUninstalled() const
00192 { return isInstalled() && transacts(); }
00193
00194 bool isUndetermined() const
00195 { return fieldValueIs<EstablishField>( UNDETERMINED ); }
00196
00197 bool isEstablishedUneeded() const
00198 { return fieldValueIs<EstablishField>( UNNEEDED ); }
00199
00200 bool isEstablishedSatisfied() const
00201 { return fieldValueIs<EstablishField>( SATISFIED ); }
00202
00203 bool isEstablishedIncomplete() const
00204 { return fieldValueIs<EstablishField>( INCOMPLETE ); }
00205
00206 bool isUnneeded() const
00207 { return isUninstalled() && fieldValueIs<EstablishField>( UNNEEDED ); }
00208
00209 bool isSatisfied() const
00210 { return isUninstalled() && fieldValueIs<EstablishField>( SATISFIED ); }
00211
00212 bool isComplete () const
00213 { return isInstalled() && fieldValueIs<EstablishField>( SATISFIED ); }
00214
00215 bool isIncomplete() const
00216 { return isInstalled() && fieldValueIs<EstablishField>( INCOMPLETE ); }
00217
00218 bool isNeeded() const
00219 { return isUninstalled() && fieldValueIs<EstablishField>( INCOMPLETE ); }
00220
00221 bool isLocked() const
00222 { return fieldValueIs<TransactField>( LOCKED ); }
00223
00224 bool transacts() const
00225 { return fieldValueIs<TransactField>( TRANSACT ); }
00226
00227 TransactValue getTransactValue() const
00228 { return (TransactValue)_bitfield.value<TransactField>(); }
00229
00230 bool isBySolver() const
00231 { return fieldValueIs<TransactByField>( SOLVER ); }
00232
00233 bool isByApplLow() const
00234 { return fieldValueIs<TransactByField>( APPL_LOW ); }
00235
00236 bool isByApplHigh() const
00237 { return fieldValueIs<TransactByField>( APPL_HIGH ); }
00238
00239 bool isByUser() const
00240 { return fieldValueIs<TransactByField>( USER ); }
00241
00242 TransactByValue getTransactByValue() const
00243 { return (TransactByValue)_bitfield.value<TransactByField>(); }
00244
00245 bool isToBeUninstalledDueToObsolete () const
00246 { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_OBSOLETE ); }
00247
00248 bool isToBeUninstalledDueToUnlink() const
00249 { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_UNLINK ); }
00250
00251 bool isToBeUninstalledDueToUpgrade() const
00252 { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_UPGRADE ); }
00253
00254 bool isToBeInstalledSoft () const
00255 { return isToBeInstalled() && fieldValueIs<TransactDetailField>( SOFT_INSTALL ); }
00256
00257 bool isToBeUninstalledSoft () const
00258 { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( SOFT_REMOVE ); }
00259
00260 public:
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00275 bool setTransactValue( TransactValue newVal_r, TransactByValue causer_r )
00276 {
00277 switch ( newVal_r )
00278 {
00279 case KEEP_STATE:
00280 return setTransact( false, causer_r );
00281 break;
00282 case LOCKED:
00283 return setLock( true, causer_r );
00284 break;
00285 case TRANSACT:
00286 return setTransact( true, causer_r );
00287 break;
00288 }
00289 return false;
00290 }
00291
00292 bool maySetTransactValue( TransactValue newVal_r, TransactByValue causer_r )
00293 {
00294 bit::BitField<FieldType> savBitfield = _bitfield;
00295 bool ret = setTransactValue( newVal_r, causer_r );
00296 _bitfield = savBitfield;
00297 return ret;
00298 }
00299
00305 bool setLock( bool toLock_r, TransactByValue causer_r )
00306 {
00307 if ( toLock_r == isLocked() )
00308 {
00309
00310
00311 if ( isLocked() && isLessThan<TransactByField>( causer_r ) )
00312 fieldValueAssign<TransactByField>( causer_r );
00313 return true;
00314 }
00315
00316 if ( causer_r != USER )
00317 return false;
00318
00319
00320 if ( ! setTransact( false, causer_r ) )
00321 return false;
00322 if ( toLock_r ) {
00323 fieldValueAssign<TransactField>( LOCKED );
00324 fieldValueAssign<TransactByField>( causer_r );
00325 } else
00326 fieldValueAssign<TransactField>( KEEP_STATE );
00327 return true;
00328 }
00329
00330 bool maySetLock( bool to_r, TransactByValue causer_r )
00331 {
00332 bit::BitField<FieldType> savBitfield = _bitfield;
00333 bool ret = setLock( to_r, causer_r );
00334 _bitfield = savBitfield;
00335 return ret;
00336 }
00337
00343 bool setTransact( bool toTansact_r, TransactByValue causer_r )
00344 {
00345 if ( toTansact_r == transacts() )
00346 {
00347
00348
00349 if ( transacts() && isLessThan<TransactByField>( causer_r ) )
00350 {
00351 fieldValueAssign<TransactByField>( causer_r );
00352
00353 }
00354 return true;
00355 }
00356
00357 if ( ! fieldValueIs<TransactField>( KEEP_STATE )
00358 && isGreaterThan<TransactByField>( causer_r ) )
00359 return false;
00360
00361 if ( toTansact_r )
00362 {
00363 fieldValueAssign<TransactField>( TRANSACT );
00364
00365 }
00366 else
00367 {
00368 fieldValueAssign<TransactField>( KEEP_STATE );
00369 fieldValueAssign<TransactDetailField>( NO_DETAIL );
00370 }
00371 fieldValueAssign<TransactByField>( causer_r );
00372 return true;
00373 }
00374
00375 bool maySetTransact( bool val_r, TransactByValue causer )
00376 {
00377 bit::BitField<FieldType> savBitfield = _bitfield;
00378 bool ret = setTransact (val_r, causer);
00379 _bitfield = savBitfield;
00380 return ret;
00381 }
00382
00384 bool setSoftLock( TransactByValue causer_r )
00385 {
00386 if ( ! setTransact( false, causer_r ) )
00387 return false;
00388 if ( fieldValueIs<TransactField>( KEEP_STATE )
00389 && isLessThan<TransactByField>( causer_r ) )
00390 fieldValueAssign<TransactByField>( causer_r );
00391 return true;
00392 }
00393
00396 bool resetTransact( TransactByValue causer_r )
00397 {
00398 if ( ! setTransact( false, causer_r ) )
00399 return false;
00400 if ( fieldValueIs<TransactField>( KEEP_STATE ) )
00401 fieldValueAssign<TransactByField>( SOLVER );
00402 return true;
00403 }
00404
00414 bool setSoftTransact( bool toTansact_r, TransactByValue causer_r,
00415 TransactByValue causerLimit_r )
00416 {
00417 if ( fieldValueIs<TransactField>( KEEP_STATE )
00418 && toTansact_r != transacts()
00419 && isGreaterThan<TransactByField>( causerLimit_r ) )
00420 {
00421
00422 return false;
00423 }
00424 return setTransact( toTansact_r, causer_r );
00425 }
00426
00427 bool setSoftTransact( bool toTansact_r, TransactByValue causer_r )
00428 { return setSoftTransact( toTansact_r, causer_r, causer_r ); }
00429
00430 bool maySetSoftTransact( bool val_r, TransactByValue causer,
00431 TransactByValue causerLimit_r )
00432 {
00433 bit::BitField<FieldType> savBitfield = _bitfield;
00434 bool ret = setSoftTransact( val_r, causer, causerLimit_r );
00435 _bitfield = savBitfield;
00436 return ret;
00437 }
00438
00439 bool maySetSoftTransact( bool val_r, TransactByValue causer )
00440 { return maySetSoftTransact( val_r, causer, causer ); }
00441
00442 bool setToBeInstalled (TransactByValue causer)
00443 {
00444 if (isInstalled()) return false;
00445 return setTransact (true, causer);
00446 }
00447
00448 bool maySetToBeInstalled (TransactByValue causer)
00449 {
00450 bit::BitField<FieldType> savBitfield = _bitfield;
00451 bool ret = setToBeInstalled (causer);
00452 _bitfield = savBitfield;
00453 return ret;
00454 }
00455
00456 bool setToBeUninstalled (TransactByValue causer)
00457 {
00458 if (!isInstalled()) return false;
00459 return setTransact (true, causer);
00460 }
00461
00462 bool maySetToBeUninstalled (TransactByValue causer)
00463 {
00464 bit::BitField<FieldType> savBitfield = _bitfield;
00465 bool ret = setToBeUninstalled (causer);
00466 _bitfield = savBitfield;
00467 return ret;
00468 }
00469
00470
00471
00472
00473 bool setToBeUninstalledDueToUnlink ( )
00474 {
00475 if (!setToBeUninstalled (SOLVER)) return false;
00476 fieldValueAssign<TransactDetailField>(DUE_TO_UNLINK);
00477 return true;
00478 }
00479
00480 bool setToBeUninstalledDueToObsolete ( )
00481 {
00482 if (!setToBeUninstalled (SOLVER)) return false;
00483 fieldValueAssign<TransactDetailField>(DUE_TO_OBSOLETE);
00484 return true;
00485 }
00486
00487 bool setToBeUninstalledDueToUpgrade ( TransactByValue causer )
00488 {
00489 if (!setToBeUninstalled (causer)) return false;
00490 fieldValueAssign<TransactDetailField>(DUE_TO_UPGRADE);
00491 return true;
00492 }
00493
00494 bool setToBeInstalledSoft ( )
00495 {
00496 if (!setToBeInstalled(SOLVER)) return false;
00497 fieldValueAssign<TransactDetailField>(SOFT_INSTALL);
00498 return true;
00499 }
00500
00501 bool setToBeUninstalledSoft ( )
00502 {
00503 if (!setToBeUninstalled(SOLVER)) return false;
00504 fieldValueAssign<TransactDetailField>(SOFT_REMOVE);
00505 return true;
00506 }
00507
00508 bool isSoftInstall () {
00509 return fieldValueIs<TransactDetailField> (SOFT_INSTALL);
00510 }
00511
00512 bool isSoftUninstall () {
00513 return fieldValueIs<TransactDetailField> (SOFT_REMOVE);
00514 }
00515
00516 bool setSoftInstall (bool flag) {
00517 fieldValueAssign<TransactDetailField>(flag?SOFT_INSTALL:0);
00518 return true;
00519 }
00520
00521 bool setSoftUninstall (bool flag) {
00522 fieldValueAssign<TransactDetailField>(flag?SOFT_REMOVE:0);
00523 return true;
00524 }
00525
00526 bool setUndetermined ()
00527 {
00528 fieldValueAssign<EstablishField>(UNDETERMINED);
00529 return true;
00530 }
00531
00532 bool setUnneeded ()
00533 {
00534 fieldValueAssign<EstablishField>(UNNEEDED);
00535 return true;
00536 }
00537
00538 bool setSatisfied ()
00539 {
00540 fieldValueAssign<EstablishField>(SATISFIED);
00541 return true;
00542 }
00543
00544 bool setIncomplete ()
00545 {
00546 fieldValueAssign<EstablishField>(INCOMPLETE);
00547 return true;
00548 }
00549
00550 bool isSeen () const
00551 { return fieldValueIs<SolverStateField>( SEEN ); }
00552
00553 bool isImpossible () const
00554 { return fieldValueIs<SolverStateField>( IMPOSSIBLE ); }
00555
00556 bool setSeen (bool value)
00557 {
00558 fieldValueAssign<SolverStateField>( value ? SEEN : NORMAL );
00559 return true;
00560 }
00561
00562 bool setImpossible (bool value)
00563 {
00564 fieldValueAssign<SolverStateField>( value ? IMPOSSIBLE : NORMAL );
00565 return true;
00566 }
00567
00568 bool setStatus( ResStatus newStatus_r )
00569 {
00570
00571 if ( _bitfield.value<StateField>() != newStatus_r._bitfield.value<StateField>() )
00572 return false;
00573
00574 if ( ! setTransactValue( newStatus_r.getTransactValue(), newStatus_r.getTransactByValue() ) )
00575 return false;
00576
00577
00578 _bitfield = newStatus_r._bitfield;
00579 return true;
00580 }
00581
00584 static const ResStatus toBeInstalled;
00585 static const ResStatus toBeInstalledSoft;
00586 static const ResStatus toBeUninstalled;
00587 static const ResStatus toBeUninstalledSoft;
00588 static const ResStatus toBeUninstalledDueToUnlink;
00589 static const ResStatus toBeUninstalledDueToObsolete;
00590 static const ResStatus toBeUninstalledDueToUpgrade;
00591 static const ResStatus installed;
00592 static const ResStatus uninstalled;
00593 static const ResStatus satisfied;
00594 static const ResStatus complete;
00595 static const ResStatus unneeded;
00596 static const ResStatus needed;
00597 static const ResStatus incomplete;
00598 static const ResStatus impossible;
00600
00601 private:
00603 ResStatus( StateValue s,
00604 EstablishValue e = UNDETERMINED,
00605 TransactValue t = KEEP_STATE,
00606 InstallDetailValue i = EXPLICIT_INSTALL,
00607 RemoveDetailValue r = EXPLICIT_REMOVE,
00608 SolverStateValue ssv = NORMAL );
00609
00612 template<class _Field>
00613 bool fieldValueIs( FieldType val_r ) const
00614 { return _bitfield.isEqual<_Field>( val_r ); }
00615
00618 template<class _Field>
00619 void fieldValueAssign( FieldType val_r )
00620 { _bitfield.assign<_Field>( val_r ); }
00621
00624 template<class _Field>
00625 bool isGreaterThan( FieldType val_r )
00626 { return _bitfield.value<_Field>() > val_r; }
00627
00628 template<class _Field>
00629 bool isLessThan( FieldType val_r )
00630 { return _bitfield.value<_Field>() < val_r; }
00631
00632 private:
00633 BitFieldType _bitfield;
00634 };
00636
00638 std::ostream & operator<<( std::ostream & str, const ResStatus & obj );
00639
00641 inline bool operator==( const ResStatus & lhs, const ResStatus & rhs )
00642 { return lhs._bitfield == rhs._bitfield; }
00643
00645 inline bool operator!=( const ResStatus & lhs, const ResStatus & rhs )
00646 { return ! (lhs == rhs); }
00647
00649 }
00651 #endif // ZYPP_RESSTATUS_H