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