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