Determine the candidate based on per-version pins, instead of old code

[apt.git] / apt-pkg / algorithms.cc

diff --git a/apt-pkg/algorithms.cc b/apt-pkg/algorithms.cc
index a7b676660379b37cb71bc52abc9219fd92ed339a..adbec82f71a9d2eddf72d0f1b65e11f5e2c11350 100644 (file)
--- a/apt-pkg/algorithms.cc
+++ b/apt-pkg/algorithms.cc
@@ -445,19 +445,22 @@ void pkgProblemResolver::MakeScores()
          || (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important)
         Score += PrioEssentials;
 
          || (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important)
         Score += PrioEssentials;
 

-      // We transform the priority
-      if (Cache[I].InstVerIter(Cache)->Priority <= 5)
-        Score += PrioMap[Cache[I].InstVerIter(Cache)->Priority];
-      
+      pkgCache::VerIterator const InstVer = Cache[I].InstVerIter(Cache);
+      // We apply priorities only to downloadable packages, all others are prio:extra
+      // as an obsolete prio:standard package can't be that standard anymore…
+      if (InstVer->Priority <= pkgCache::State::Extra && InstVer.Downloadable() == true)
+        Score += PrioMap[InstVer->Priority];
+      else
+        Score += PrioMap[pkgCache::State::Extra];
+

       /* This helps to fix oddball problems with conflicting packages
       /* This helps to fix oddball problems with conflicting packages

-         on the same level. We enhance the score of installed packages 
-        if those are not obsolete
-      */
+        on the same level. We enhance the score of installed packages
+        if those are not obsolete */

       if (I->CurrentVer != 0 && Cache[I].CandidateVer != 0 && Cache[I].CandidateVerIter(Cache).Downloadable())
         Score += PrioInstalledAndNotObsolete;
 
       // propagate score points along dependencies
       if (I->CurrentVer != 0 && Cache[I].CandidateVer != 0 && Cache[I].CandidateVerIter(Cache).Downloadable())
         Score += PrioInstalledAndNotObsolete;
 
       // propagate score points along dependencies

-      for (pkgCache::DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); D.end() == false; ++D)
+      for (pkgCache::DepIterator D = InstVer.DependsList(); D.end() == false; ++D)

       {
         if (DepMap[D->Type] == 0)
            continue;
       {
         if (DepMap[D->Type] == 0)
            continue;


@@ -465,7 +468,7 @@ void pkgProblemResolver::MakeScores()
         if (D->Version != 0)
         {
            pkgCache::VerIterator const IV = Cache[T].InstVerIter(Cache);
         if (D->Version != 0)
         {
            pkgCache::VerIterator const IV = Cache[T].InstVerIter(Cache);

-           if (IV.end() == true || D.IsSatisfied(IV) != D.IsNegative())
+           if (IV.end() == true || D.IsSatisfied(IV) == false)

               continue;
         }
         Scores[T->ID] += DepMap[D->Type];
               continue;
         }
         Scores[T->ID] += DepMap[D->Type];


@@ -637,13 +640,17 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg)
 // ProblemResolver::Resolve - calls a resolver to fix the situation    /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // ProblemResolver::Resolve - calls a resolver to fix the situation    /*{{{*/
 // ---------------------------------------------------------------------
 /* */

+#if APT_PKG_ABI < 413

 bool pkgProblemResolver::Resolve(bool BrokenFix)
 bool pkgProblemResolver::Resolve(bool BrokenFix)

+{
+   return Resolve(BrokenFix, NULL);
+}
+#endif
+bool pkgProblemResolver::Resolve(bool BrokenFix, OpProgress * const Progress)

 {
    std::string const solver = _config->Find("APT::Solver", "internal");
 {
    std::string const solver = _config->Find("APT::Solver", "internal");

-   if (solver != "internal") {
-      OpTextProgress Prog(*_config);
-      return EDSP::ResolveExternal(solver.c_str(), Cache, false, false, false, &Prog);
-   }
+   if (solver != "internal")
+      return EDSP::ResolveExternal(solver.c_str(), Cache, false, false, false, Progress);

    return ResolveInternal(BrokenFix);
 }
                                                                        /*}}}*/
    return ResolveInternal(BrokenFix);
 }
                                                                        /*}}}*/


@@ -1137,13 +1144,17 @@ bool pkgProblemResolver::InstOrNewPolicyBroken(pkgCache::PkgIterator I)
 /* This is the work horse of the soft upgrade routine. It is very gental 
    in that it does not install or remove any packages. It is assumed that the
    system was non-broken previously. */
 /* This is the work horse of the soft upgrade routine. It is very gental 
    in that it does not install or remove any packages. It is assumed that the
    system was non-broken previously. */

+#if APT_PKG_ABI < 413

 bool pkgProblemResolver::ResolveByKeep()
 bool pkgProblemResolver::ResolveByKeep()

+{
+   return ResolveByKeep(NULL);
+}
+#endif
+bool pkgProblemResolver::ResolveByKeep(OpProgress * const Progress)

 {
    std::string const solver = _config->Find("APT::Solver", "internal");
 {
    std::string const solver = _config->Find("APT::Solver", "internal");

-   if (solver != "internal") {
-      OpTextProgress Prog(*_config);
-      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, &Prog);
-   }
+   if (solver != "internal")
+      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, Progress);

    return ResolveByKeepInternal();
 }
                                                                        /*}}}*/
    return ResolveByKeepInternal();
 }
                                                                        /*}}}*/