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