zypp/ResStatus.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/ResStatus.h
  10  *
  11 */
  12 #ifndef ZYPP_RESSTATUS_H
  13 #define ZYPP_RESSTATUS_H
  14
  15 #include <inttypes.h>
  16 #include <iosfwd>
  17 #include "zypp/Bit.h"
  18
  19 ///////////////////////////////////////////////////////////////////
  20 namespace zypp
  21 { /////////////////////////////////////////////////////////////////
  22
  23   namespace resstatus
  24   {
  25     class UserLockQueryManip;
  26     class StatusBackup;
  27   }
  28
  29   ///////////////////////////////////////////////////////////////////
  30   //
  31   //    CLASS NAME : ResStatus
  32   //
  33   /** Status bitfield.
  34    *
  35    * \li \c StateField Whether the resolvable is or uninstalled (available).
  36    * \li \c ValidateField Validate status computed by the solver as
  37    *        nonrelevant: it is unimportant for the user
  38    *        satisfied: it important nothing has to be done
  39    *        broken: it is incomplete. So e.g. an update is needed
  40    * \li \c TransactField Wheter to transact this resolvable
  41    *        (delete if installed install if uninstalled).
  42    *        In case the resolvable is locked, only USER may modify the
  43    *        transact bit.
  44    * \li \c TransactByField Who triggered the transaction. Transaction
  45    *        bit may be reset by higer levels only.
  46    * \li \c TransactDetailField Reason why the Resolvable transacts.
  47    *        Splitted into \c InstallDetailValue and \c RemoveDetailValue
  48    *        dependent on the kind of transaction.
  49    * \li \c WeakField The solvable will be recommended/suggested by
  50    *        a to be installed/deleted solvable.
  51    *
  52   */
  53   class ResStatus
  54   {
  55     friend std::ostream & operator<<( std::ostream & str, const ResStatus & obj );
  56     friend bool operator==( const ResStatus & lhs, const ResStatus & rhs );
  57
  58   public:
  59     /** \name BitField range definitions.
  60      *
  61      * \note Enlarge FieldType if more bit's needed. It's not yet
  62      * checked by the compiler.
  63      */
  64     //@{
  65     typedef uint16_t FieldType;
  66     typedef bit::BitField<FieldType> BitFieldType;
  67     // Bit Ranges within FieldType defined by 1st bit and size:
  68     typedef bit::Range<FieldType,0,                          1> StateField;
  69     typedef bit::Range<FieldType,StateField::end,            2> ValidateField;
  70     typedef bit::Range<FieldType,ValidateField::end,         2> TransactField;
  71     typedef bit::Range<FieldType,TransactField::end,         2> TransactByField;
  72     typedef bit::Range<FieldType,TransactByField::end,       2> TransactDetailField;
  73     typedef bit::Range<FieldType,TransactDetailField::end,   1> SolverStateField;
  74     typedef bit::Range<FieldType,SolverStateField::end,      1> LicenceConfirmedField;
  75     typedef bit::Range<FieldType,LicenceConfirmedField::end, 2> WeakField;
  76     typedef bit::Range<FieldType,WeakField::end,             1> UserLockQueryField; // internal
  77     // enlarge FieldType if more bit's needed. It's not yet
  78     // checked by the compiler.
  79     //@}
  80   public:
  81
  82     /** \name Status values.
  83      *
  84      * Each enum corresponds to a BitField range.
  85      * \note Take care that enumerator values actually fit into
  86      * the corresponding field. It's not yet checked by the compiler.
  87      */
  88     //@{
  89     enum StateValue
  90       {
  91         UNINSTALLED = bit::RangeValue<StateField,0>::value,
  92         INSTALLED   = bit::RangeValue<StateField,1>::value
  93       };
  94     enum ValidateValue
  95       {
  96         UNDETERMINED = bit::RangeValue<ValidateField,0>::value,
  97         BROKEN       = bit::RangeValue<ValidateField,1>::value,
  98         SATISFIED    = bit::RangeValue<ValidateField,2>::value,
  99         NONRELEVANT  = bit::RangeValue<ValidateField,3>::value
 100       };
 101     enum TransactValue
 102       {
 103         KEEP_STATE = bit::RangeValue<TransactField,0>::value,
 104         LOCKED     = bit::RangeValue<TransactField,1>::value, // locked, must not transact
 105         TRANSACT   = bit::RangeValue<TransactField,2>::value  // transact according to state
 106       };
 107     enum TransactByValue
 108       {
 109         SOLVER    = bit::RangeValue<TransactByField,0>::value,
 110         APPL_LOW  = bit::RangeValue<TransactByField,1>::value,
 111         APPL_HIGH = bit::RangeValue<TransactByField,2>::value,
 112         USER      = bit::RangeValue<TransactByField,3>::value
 113       };
 114
 115     enum DetailValue
 116       {
 117         /** Detail for no transact, i.e. reset any Install/RemoveDetailValue. */
 118         NO_DETAIL = bit::RangeValue<TransactDetailField,0>::value,
 119       };
 120
 121     enum InstallDetailValue
 122       {
 123         EXPLICIT_INSTALL = bit::RangeValue<TransactDetailField,0>::value,
 124         SOFT_INSTALL     = bit::RangeValue<TransactDetailField,1>::value
 125       };
 126     enum RemoveDetailValue
 127       {
 128         EXPLICIT_REMOVE = bit::RangeValue<TransactDetailField,0>::value,
 129         SOFT_REMOVE     = bit::RangeValue<TransactDetailField,1>::value,
 130         DUE_TO_UPGRADE  = bit::RangeValue<TransactDetailField,2>::value
 131       };
 132     enum SolverStateValue
 133       {
 134         NORMAL     = bit::RangeValue<SolverStateField,0>::value, // default, notthing special
 135         SEEN       = bit::RangeValue<SolverStateField,1>::value, // already seen during ResolverUpgrade
 136       };
 137
 138     enum LicenceConfirmedValue
 139       {
 140         LICENCE_UNCONFIRMED = bit::RangeValue<LicenceConfirmedField,0>::value,
 141         LICENCE_CONFIRMED   = bit::RangeValue<LicenceConfirmedField,1>::value
 142       };
 143
 144     enum WeakValue
 145       {
 146         NO_WEAK                 = bit::RangeValue<WeakField,0>::value,
 147         SUGGESTED               = bit::RangeValue<WeakField,1>::value,
 148         RECOMMENDED             = bit::RangeValue<WeakField,2>::value,
 149         SUGGESTED_AND_RECOMMENDED = bit::RangeValue<WeakField,3>::value
 150       };
 151
 152     enum UserLockQuery // internal
 153       {
 154         USERLOCK_NOMATCH        = bit::RangeValue<UserLockQueryField,0>::value,
 155         USERLOCK_MATCH          = bit::RangeValue<UserLockQueryField,1>::value
 156       };
 157     //@}
 158
 159   public:
 160
 161     /** Default ctor. */
 162     ResStatus();
 163
 164     /** Ctor setting the initial . */
 165     ResStatus( bool isInstalled_r );
 166
 167     /** Dtor. */
 168     ~ResStatus();
 169
 170     /** Debug helper returning the bitfield.
 171      * It's save to expose the bitfield, as it can't be used to
 172      * recreate a ResStatus. So it is not possible to bypass
 173      * transition rules.
 174     */
 175     BitFieldType bitfield() const
 176     { return _bitfield; }
 177
 178   public:
 179
 180     bool isLicenceConfirmed() const
 181     { return fieldValueIs<LicenceConfirmedField>( LICENCE_CONFIRMED ); }
 182
 183     void setLicenceConfirmed( bool toVal_r = true )
 184     { fieldValueAssign<LicenceConfirmedField>( toVal_r ? LICENCE_CONFIRMED : LICENCE_UNCONFIRMED ); }
 185
 186   public:
 187
 188     bool isRecommended() const
 189     { return fieldValueIs<WeakField>( RECOMMENDED ); }
 190
 191     bool isSuggested() const
 192     { return fieldValueIs<WeakField>( SUGGESTED ); }
 193
 194     bool resetWeak() const
 195     { return fieldValueIs<WeakField>( NO_WEAK ); }
 196
 197     void setRecommended( bool toVal_r = true )
 198     { if (isSuggested())
 199         fieldValueAssign<WeakField>( toVal_r ? SUGGESTED_AND_RECOMMENDED : SUGGESTED );
 200     else
 201         fieldValueAssign<WeakField>( toVal_r ? RECOMMENDED : NO_WEAK );
 202     }
 203
 204     void setSuggested( bool toVal_r = true )
 205     { if (isRecommended())
 206         fieldValueAssign<WeakField>( toVal_r ? SUGGESTED_AND_RECOMMENDED : RECOMMENDED );
 207     else
 208         fieldValueAssign<WeakField>( toVal_r ? SUGGESTED : NO_WEAK );
 209     }
 210
 211     ValidateValue validate() const
 212     { return (ValidateValue)_bitfield.value<ValidateField>(); }
 213
 214     bool isUndetermined() const
 215     { return fieldValueIs<ValidateField>( UNDETERMINED ); }
 216
 217     bool isSatisfied() const
 218     { return fieldValueIs<ValidateField>( SATISFIED ); }
 219
 220     bool isBroken() const
 221     { return fieldValueIs<ValidateField>( BROKEN ); }
 222
 223     bool isNonRelevant() const
 224     { return fieldValueIs<ValidateField>( NONRELEVANT ); }
 225
 226   public:
 227     // These two are IMMUTABLE!
 228
 229     bool isInstalled() const
 230     { return fieldValueIs<StateField>( INSTALLED ); }
 231
 232     bool isUninstalled() const
 233     { return fieldValueIs<StateField>( UNINSTALLED ); }
 234
 235   public:
 236
 237     bool staysInstalled() const
 238     { return isInstalled() && !transacts(); }
 239
 240     bool wasInstalled() const { return staysInstalled(); }      //for old status
 241
 242     bool isToBeInstalled() const
 243     { return isUninstalled() && transacts(); }
 244
 245     bool staysUninstalled() const
 246     { return isUninstalled() && !transacts(); }
 247
 248     bool wasUninstalled() const { return staysUninstalled(); }  // for old status
 249
 250     bool isToBeUninstalled() const
 251     { return isInstalled() && transacts(); }
 252
 253     bool isLocked() const
 254     { return fieldValueIs<TransactField>( LOCKED ); }
 255
 256     bool isUserLocked() const
 257     { return isLocked() && isByUser(); }
 258
 259     bool isSoftLocked( TransactByValue causer_r = USER ) const
 260     { return isKept() && fieldValueIs<TransactByField>( causer_r ); }
 261
 262     bool isKept() const
 263     { return fieldValueIs<TransactField>( KEEP_STATE ); }
 264
 265     bool transacts() const
 266     { return fieldValueIs<TransactField>( TRANSACT ); }
 267
 268     TransactValue getTransactValue() const
 269     { return (TransactValue)_bitfield.value<TransactField>(); }
 270
 271     /** True if would be on system after commit. */
 272     bool onSystem() const
 273     { return( isInstalled() != transacts() ); }
 274
 275     /** True if would be off system after commit. */
 276     bool offSystem() const
 277     { return ! onSystem(); }
 278
 279     bool isBySolver() const
 280     { return fieldValueIs<TransactByField>( SOLVER ); }
 281
 282     bool isByApplLow() const
 283     { return fieldValueIs<TransactByField>( APPL_LOW ); }
 284
 285     bool isByApplHigh() const
 286     { return fieldValueIs<TransactByField>( APPL_HIGH ); }
 287
 288     bool isByUser() const
 289     { return fieldValueIs<TransactByField>( USER ); }
 290
 291     TransactByValue getTransactByValue() const
 292     { return (TransactByValue)_bitfield.value<TransactByField>(); }
 293
 294     bool setTransactByValue(TransactByValue causer)
 295     {
 296         if ( isLessThan<TransactByField>( causer ) ) {
 297             fieldValueAssign<TransactByField>( causer );
 298             return true;
 299         } else {
 300             return false;
 301         }
 302     }
 303
 304     bool isToBeUninstalledDueToObsolete () const
 305     { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_OBSOLETE ); }
 306
 307     bool isToBeUninstalledDueToUpgrade() const
 308     { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( DUE_TO_UPGRADE ); }
 309
 310     bool isToBeInstalledSoft () const
 311     { return isToBeInstalled() && fieldValueIs<TransactDetailField>( SOFT_INSTALL ); }
 312
 313     bool isToBeInstalledNotSoft () const
 314     { return isToBeInstalled() && !fieldValueIs<TransactDetailField>( SOFT_INSTALL ); }
 315
 316     bool isToBeUninstalledSoft () const
 317     { return isToBeUninstalled() && fieldValueIs<TransactDetailField>( SOFT_REMOVE ); }
 318
 319   private:
 320
 321     /** \name Internal hard lock maintainance */
 322     //@{
 323     friend class resstatus::UserLockQueryManip;
 324
 325     bool isUserLockQueryMatch() const
 326     { return fieldValueIs<UserLockQueryField>( USERLOCK_MATCH ); }
 327
 328     void setUserLockQueryMatch( bool match_r )
 329     { fieldValueAssign<UserLockQueryField>( match_r ? USERLOCK_MATCH : USERLOCK_NOMATCH ); }
 330     //@}
 331
 332   public:
 333
 334     //------------------------------------------------------------------------
 335     // get/set functions, returnig \c true if requested status change
 336     // was successfull (i.e. leading to the desired transaction).
 337     // If a lower level (e.g.SOLVER) wants to transact, but it's
 338     // already set by a higher level, \c true should be returned.
 339     // Removing a higher levels transaction bit should fail.
 340     //
 341     // The may functions checks only, if the action would return true
 342     // if it is called.
 343
 344     /** Set TransactValue.
 345      * Convenience to set TransactValue from enum.
 346      */
 347     bool setTransactValue( TransactValue newVal_r, TransactByValue causer_r )
 348     {
 349       switch ( newVal_r )
 350         {
 351         case KEEP_STATE:
 352           return setTransact( false, causer_r );
 353           break;
 354         case LOCKED:
 355           return setLock( true, causer_r );
 356           break;
 357         case TRANSACT:
 358           return setTransact( true, causer_r );
 359           break;
 360         }
 361       return false;
 362     }
 363
 364     bool maySetTransactValue( TransactValue newVal_r, TransactByValue causer_r )
 365     {
 366         bit::BitField<FieldType> savBitfield = _bitfield;
 367         bool ret = setTransactValue( newVal_r, causer_r );
 368         _bitfield = savBitfield;
 369         return ret;
 370     }
 371
 372     /** Apply a lock (prevent transaction).
 373      * Currently by USER or APPL_HIGH only, but who knows...
 374      * Set LOCKED from KEEP_STATE to be shure all transaction
 375      * details were reset properly.
 376     */
 377     bool setLock( bool toLock_r, TransactByValue causer_r )
 378     {
 379       if ( toLock_r == isLocked() )
 380         {
 381           // we're already in the desired state, but in case of
 382           // LOCKED, remember a superior causer.
 383           if ( isLocked() && isLessThan<TransactByField>( causer_r ) )
 384             fieldValueAssign<TransactByField>( causer_r );
 385            return true;
 386         }
 387       // Here: Lock status is to be changed:
 388       if ( causer_r != USER && causer_r != APPL_HIGH )
 389         return false;
 390       if ( toLock_r ) {
 391         // We're in unlocked state, which includes TRANSACT.
 392         // Causer must be allowed to reset this. But from
 393         // KEEP_STATE every causer is allowed to set the lock.
 394         if ( ! setTransact( false, causer_r ) )
 395           return false;
 396         fieldValueAssign<TransactField>( LOCKED );
 397         fieldValueAssign<TransactByField>( causer_r );
 398       } else {
 399         // To leave Locked state it needs a superior causer.
 400         if ( isGreaterThan<TransactByField>( causer_r ) )
 401           return false;
 402         fieldValueAssign<TransactField>( KEEP_STATE );
 403         fieldValueAssign<TransactByField>( SOLVER ); // reset to lowest causer
 404                                                      // in order to distinguish from keep_state_by_user
 405       }
 406       return true;
 407     }
 408
 409     bool maySetLock( bool to_r, TransactByValue causer_r )
 410     {
 411         bit::BitField<FieldType> savBitfield = _bitfield;
 412         bool ret = setLock( to_r, causer_r );
 413         _bitfield = savBitfield;
 414         return ret;
 415     }
 416
 417     /** Toggle between TRANSACT and KEEP_STATE.
 418      * LOCKED state means KEEP_STATE. But in contrary to KEEP_STATE,
 419      * LOCKED state is immutable for \a causer_r less than TransactByValue.
 420      * KEEP_STATE may be canged by any \a causer_r.
 421     */
 422     bool setTransact( bool toTansact_r, TransactByValue causer_r )
 423     {
 424       if ( toTansact_r == transacts() )
 425         {
 426           // we're already in the desired state, but in case of
 427           // TRANSACT, remember a superior causer.
 428           if ( transacts() && isLessThan<TransactByField>( causer_r ) )
 429               fieldValueAssign<TransactByField>( causer_r );
 430
 431           fieldValueAssign<TransactDetailField>( NO_DETAIL ); // Details has to be set again
 432           return true;
 433         }
 434       // Here: transact status is to be changed:
 435       if (    ! fieldValueIs<TransactField>( KEEP_STATE )
 436               && isGreaterThan<TransactByField>( causer_r ) ) {
 437         return false;
 438       }
 439
 440       if ( toTansact_r )
 441       {
 442           fieldValueAssign<TransactField>( TRANSACT );
 443       }
 444       else
 445       {
 446           fieldValueAssign<TransactField>( KEEP_STATE );
 447       }
 448       fieldValueAssign<TransactDetailField>( NO_DETAIL ); // Details has to be set again
 449       fieldValueAssign<TransactByField>( causer_r );
 450       return true;
 451     }
 452
 453     bool maySetTransact( bool val_r, TransactByValue causer )
 454     {
 455         bit::BitField<FieldType> savBitfield = _bitfield;
 456         bool ret = setTransact (val_r, causer);
 457         _bitfield = savBitfield;
 458         return ret;
 459     }
 460
 461     /** */
 462     bool setSoftLock( TransactByValue causer_r )
 463     {
 464       if ( ! setTransact( false, causer_r ) )
 465         return false;
 466       if ( fieldValueIs<TransactField>( KEEP_STATE )
 467            && isLessThan<TransactByField>( causer_r ) )
 468         fieldValueAssign<TransactByField>( causer_r );
 469       return true;
 470     }
 471
 472     /** Not the same as setTransact( false ).
 473      */
 474     bool resetTransact( TransactByValue causer_r )
 475     {
 476       if ( ! setTransact( false, causer_r ) )
 477         return false;
 478       if ( fieldValueIs<TransactField>( KEEP_STATE ) )
 479         fieldValueAssign<TransactByField>( SOLVER );
 480       return true;
 481     }
 482
 483     /** Soft toggle between TRANSACT and KEEP_STATE.
 484      * Similar to setTransact, but leaving KEEP_STATE also requires
 485      * a superior \a causerLimit_r. So this is a kind of soft lock.
 486      * \code
 487      * // SOLVER wants to set TRANSACT, iff KEEP_STATE is
 488      * // not superior to APPL_LOW.
 489      * setSoftTransact( true, SOLVER, APPL_LOW );
 490      * \endcode
 491     */
 492     bool setSoftTransact( bool toTansact_r, TransactByValue causer_r,
 493                           TransactByValue causerLimit_r )
 494     {
 495       if ( fieldValueIs<TransactField>( KEEP_STATE )
 496            && toTansact_r != transacts()
 497            && isGreaterThan<TransactByField>( causerLimit_r ) )
 498         {
 499           // any transact status change requires a superior causer.
 500           return false;
 501         }
 502       return setTransact( toTansact_r, causer_r );
 503     }
 504
 505     bool setSoftTransact( bool toTansact_r, TransactByValue causer_r )
 506     { return setSoftTransact( toTansact_r, causer_r, causer_r ); }
 507
 508     bool maySetSoftTransact( bool val_r, TransactByValue causer,
 509                              TransactByValue causerLimit_r )
 510     {
 511         bit::BitField<FieldType> savBitfield = _bitfield;
 512         bool ret = setSoftTransact( val_r, causer, causerLimit_r );
 513         _bitfield = savBitfield;
 514         return ret;
 515     }
 516
 517     bool maySetSoftTransact( bool val_r, TransactByValue causer )
 518     { return maySetSoftTransact( val_r, causer, causer ); }
 519
 520     bool setToBeInstalled (TransactByValue causer)
 521     {
 522       if (isInstalled()) return false;
 523       return setTransact (true, causer);
 524     }
 525
 526     bool maySetToBeInstalled (TransactByValue causer)
 527     {
 528         bit::BitField<FieldType> savBitfield = _bitfield;
 529         bool ret = setToBeInstalled (causer);
 530         _bitfield = savBitfield;
 531         return ret;
 532     }
 533
 534     bool setToBeUninstalled (TransactByValue causer)
 535     {
 536       if (!isInstalled()) return false;
 537       return setTransact (true, causer);
 538     }
 539
 540     bool maySetToBeUninstalled (TransactByValue causer)
 541     {
 542         bit::BitField<FieldType> savBitfield = _bitfield;
 543         bool ret = setToBeUninstalled (causer);
 544         _bitfield = savBitfield;
 545         return ret;
 546     }
 547
 548     //------------------------------------------------------------------------
 549     // *** These are only for the Resolver ***
 550
 551     bool setToBeUninstalledDueToUpgrade ( TransactByValue causer )
 552     {
 553       if (!setToBeUninstalled (causer)) return false;
 554       fieldValueAssign<TransactDetailField>(DUE_TO_UPGRADE);
 555       return true;
 556     }
 557
 558     bool setToBeInstalledSoft ( )
 559     {
 560       if (isInstalled()
 561           || !setSoftTransact (true, SOLVER))
 562           return false;
 563
 564       fieldValueAssign<TransactDetailField>(SOFT_INSTALL);
 565       return true;
 566     }
 567
 568     bool setToBeUninstalledSoft ( )
 569     {
 570       if (!isInstalled()
 571           || !setSoftTransact (true, SOLVER))
 572           return false;
 573
 574       fieldValueAssign<TransactDetailField>(SOFT_REMOVE);
 575       return true;
 576     }
 577
 578     bool maySetToBeUninstalledSoft ()
 579     {
 580         bit::BitField<FieldType> savBitfield = _bitfield;
 581         bool ret = setToBeUninstalledSoft ();
 582         _bitfield = savBitfield;
 583         return ret;
 584     }
 585
 586     bool isSoftInstall () {
 587         return fieldValueIs<TransactDetailField> (SOFT_INSTALL);
 588     }
 589
 590     bool isSoftUninstall () {
 591         return fieldValueIs<TransactDetailField> (SOFT_REMOVE);
 592     }
 593
 594     bool setSoftInstall (bool flag) {
 595         fieldValueAssign<TransactDetailField>(flag?SOFT_INSTALL:0);
 596         return true;
 597     }
 598
 599     bool setSoftUninstall (bool flag) {
 600         fieldValueAssign<TransactDetailField>(flag?SOFT_REMOVE:0);
 601         return true;
 602     }
 603
 604     bool setUndetermined ()
 605     {
 606       fieldValueAssign<ValidateField>(UNDETERMINED);
 607       return true;
 608     }
 609
 610     bool setSatisfied ()
 611     {
 612       fieldValueAssign<ValidateField>(SATISFIED);
 613       return true;
 614     }
 615
 616     bool setBroken ()
 617     {
 618       fieldValueAssign<ValidateField>(BROKEN);
 619       return true;
 620     }
 621
 622     bool setNonRelevant ()
 623     {
 624       fieldValueAssign<ValidateField>(NONRELEVANT);
 625       return true;
 626     }
 627
 628     bool isSeen () const
 629     { return fieldValueIs<SolverStateField>( SEEN ); }
 630
 631     bool setSeen (bool value)
 632     {
 633       fieldValueAssign<SolverStateField>( value ? SEEN : NORMAL );
 634       return true;
 635     }
 636
 637     bool setStatus( ResStatus newStatus_r )
 638     {
 639       // State field is immutable!
 640       if ( _bitfield.value<StateField>() != newStatus_r._bitfield.value<StateField>() )
 641         return false;
 642       // Transaction state change allowed?
 643       if ( ! setTransactValue( newStatus_r.getTransactValue(), newStatus_r.getTransactByValue() ) )
 644         return false;
 645
 646       // Ok, we take it all..
 647       _bitfield = newStatus_r._bitfield;
 648       return true;
 649     }
 650
 651     /** \name Builtin ResStatus constants. */
 652     //@{
 653     static const ResStatus toBeInstalled;
 654     static const ResStatus toBeUninstalled;
 655     static const ResStatus toBeUninstalledDueToUpgrade;
 656     //@}
 657
 658   private:
 659     /** Ctor for intialization of builtin constants. */
 660     ResStatus( StateValue s,
 661                ValidateValue v      = UNDETERMINED,
 662                TransactValue t      = KEEP_STATE,
 663                InstallDetailValue i = EXPLICIT_INSTALL,
 664                RemoveDetailValue r  = EXPLICIT_REMOVE,
 665                SolverStateValue ssv = NORMAL );
 666
 667     /** Return whether the corresponding Field has value \a val_r.
 668     */
 669     template<class _Field>
 670       bool fieldValueIs( FieldType val_r ) const
 671       { return _bitfield.isEqual<_Field>( val_r ); }
 672
 673     /** Set the corresponding Field to value \a val_r.
 674     */
 675     template<class _Field>
 676       void fieldValueAssign( FieldType val_r )
 677       { _bitfield.assign<_Field>( val_r ); }
 678
 679     /** compare two values.
 680     */
 681     template<class _Field>
 682       bool isGreaterThan( FieldType val_r )
 683           { return _bitfield.value<_Field>() > val_r; }
 684
 685     template<class _Field>
 686       bool isLessThan( FieldType val_r )
 687           { return _bitfield.value<_Field>() < val_r; }
 688
 689   private:
 690     friend class resstatus::StatusBackup;
 691     BitFieldType _bitfield;
 692   };
 693   ///////////////////////////////////////////////////////////////////
 694
 695   /** \relates ResStatus Stream output */
 696   std::ostream & operator<<( std::ostream & str, const ResStatus & obj );
 697
 698   /** \relates ResStatus */
 699   inline bool operator==( const ResStatus & lhs, const ResStatus & rhs )
 700   { return lhs._bitfield == rhs._bitfield; }
 701
 702   /** \relates ResStatus */
 703   inline bool operator!=( const ResStatus & lhs, const ResStatus & rhs )
 704   { return ! (lhs == rhs); }
 705
 706   ///////////////////////////////////////////////////////////////////
 707
 708   namespace resstatus
 709   {
 710     class StatusBackup
 711     {
 712       public:
 713         StatusBackup()
 714         : _status( 0 )
 715         {}
 716
 717         StatusBackup( ResStatus & status_r )
 718         : _status( &status_r )
 719         , _bitfield( _status->_bitfield )
 720         {}
 721
 722         void replay()
 723         { if ( _status ) _status->_bitfield = _bitfield; }
 724
 725       private:
 726         ResStatus *             _status;
 727         ResStatus::BitFieldType _bitfield;
 728     };
 729   }
 730
 731  /////////////////////////////////////////////////////////////////
 732 } // namespace zypp
 733 ///////////////////////////////////////////////////////////////////
 734 #endif // ZYPP_RESSTATUS_H