ResStatus.h

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

Generated on Thu Jul 6 00:07:22 2006 for zypp by  doxygen 1.4.6