using TriBool instead of TriState

diff --git a/zypp/Resolver.cc b/zypp/Resolver.cc
index 372513d..4c48bf0 100644 (file)
--- a/zypp/Resolver.cc
+++ b/zypp/Resolver.cc
@@ -13,6 +13,7 @@
 
 #include "zypp/Resolver.h"
 #include "zypp/ZConfig.h"
+#include "zypp/TriBool.h"
 #include "zypp/UpgradeStatistics.h"
 #include "zypp/solver/detail/Resolver.h"
 #include "zypp/solver/detail/Testcase.h"
@@ -78,20 +79,15 @@ namespace zypp
   bool Resolver::forceResolve()
   { return _pimpl->forceResolve(); }
   void Resolver::setOnlyRequires( const bool onlyRequires )
-  { onlyRequires ? _pimpl->setOnlyRequires( TRUE ) : _pimpl->setOnlyRequires( FALSE ); }
+  { onlyRequires ? _pimpl->setOnlyRequires( true ) : _pimpl->setOnlyRequires( false ); }
   void Resolver::resetOnlyRequires()
-  { _pimpl->setOnlyRequires( DEFAULT ); }    
+  { _pimpl->setOnlyRequires( indeterminate ); }    
   bool Resolver::onlyRequires()
   {
-      switch (_pimpl->onlyRequires()) {
-         default: // to silence compiler warnings about no-value returns
-         case DEFAULT:
-             return ZConfig::instance().solver_onlyRequires();
-         case TRUE:
-             return true;
-         case FALSE:
-             return false;
-      };
+      if (_pimpl->onlyRequires() == indeterminate)
+         return ZConfig::instance().solver_onlyRequires();
+      else
+         return _pimpl->onlyRequires();
   }
   
   void Resolver::addRequire (const Capability & capability)

diff --git a/zypp/solver/detail/Resolver.cc b/zypp/solver/detail/Resolver.cc
index 47ae82f..9f56116 100644 (file)
--- a/zypp/solver/detail/Resolver.cc
+++ b/zypp/solver/detail/Resolver.cc
@@ -72,7 +72,7 @@ Resolver::Resolver (const ResPool & pool)
     , _forceResolve(false)
     , _upgradeMode(false)
     , _verifying(false)
-    , _onlyRequires(DEFAULT)
+    , _onlyRequires(indeterminate)
 
 {
     sat::Pool satPool( sat::Pool::instance() );
@@ -301,14 +301,12 @@ Resolver::resolvePool()
        if (_forceResolve)
            _satResolver->setAllowuninstall(true);
        
-       switch (_onlyRequires) {
-           case DEFAULT:
-               _satResolver->setOnlyRequires(ZConfig::instance().solver_onlyRequires());
-           case TRUE:
-               _satResolver->setOnlyRequires(true);
-           case FALSE:
-               _satResolver->setOnlyRequires(false);
-       }
+       if (_onlyRequires == indeterminate)
+           _satResolver->setOnlyRequires(ZConfig::instance().solver_onlyRequires());
+       else if (_onlyRequires)
+           _satResolver->setOnlyRequires(true);
+       else
+           _satResolver->setOnlyRequires(false);
 
        if (_verifying)
            _satResolver->setFixsystem(true);

diff --git a/zypp/solver/detail/Resolver.h b/zypp/solver/detail/Resolver.h
index a88ff7f..c266463 100644 (file)
--- a/zypp/solver/detail/Resolver.h
+++ b/zypp/solver/detail/Resolver.h
@@ -31,6 +31,7 @@
 #include "zypp/base/PtrTypes.h"
 
 #include "zypp/ResPool.h"
+#include "zypp/TriBool.h"
 #include "zypp/base/SerialNumber.h"
 
 #include "zypp/solver/detail/Types.h"
@@ -50,14 +51,6 @@ namespace zypp
   namespace solver
   { /////////////////////////////////////////////////////////////////////
     /////////////////////////////////////////////////////////////////////
-
-    enum TriState
-    {
-       FALSE,
-       TRUE,
-       DEFAULT
-    };
-      
     namespace detail
     { ///////////////////////////////////////////////////////////////////
 
@@ -108,7 +101,7 @@ class Resolver : public base::ReferenceCounted, private base::NonCopyable {
                                   // This behaviour is favourited by ZMD
     bool _upgradeMode;            // Resolver has been called with doUpgrade
     bool _verifying;              // The system will be checked
-    TriState _onlyRequires;      // do install required resolvables only
+    TriBool _onlyRequires;       // do install required resolvables only
                                   // no recommended resolvables, language
                                   // packages, hardware packages (modalias)  
 
@@ -157,9 +150,9 @@ class Resolver : public base::ReferenceCounted, private base::NonCopyable {
     void setForceResolve (const bool force) { _forceResolve = force; }
     bool forceResolve() { return _forceResolve; }
 
-    void setOnlyRequires (const TriState state)
+    void setOnlyRequires (const TriBool state)
        { _onlyRequires = state; }
-    TriState onlyRequires () { return _onlyRequires; }
+    TriBool onlyRequires () { return _onlyRequires; }
 
     bool verifySystem ();
     bool resolvePool();