rred: If there were I/O errors, fail

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

diff --git a/apt-pkg/algorithms.cc b/apt-pkg/algorithms.cc
index 71b5ac2c1607087668229fe49678bed00cfbde91..4b84b83240ca0cd85acd8287ca43515644167d9c 100644 (file)
--- a/apt-pkg/algorithms.cc
+++ b/apt-pkg/algorithms.cc
@@ -19,9 +19,7 @@
 #include <apt-pkg/algorithms.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/algorithms.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/configuration.h>

-#include <apt-pkg/sptr.h>

 #include <apt-pkg/edsp.h>
 #include <apt-pkg/edsp.h>

-#include <apt-pkg/progress.h>

 #include <apt-pkg/depcache.h>
 #include <apt-pkg/packagemanager.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/packagemanager.h>
 #include <apt-pkg/pkgcache.h>


@@ -36,14 +34,12 @@
                                                                        /*}}}*/
 using namespace std;
 
                                                                        /*}}}*/
 using namespace std;
 

-pkgProblemResolver *pkgProblemResolver::This = 0;
-

 // Simulate::Simulate - Constructor                                    /*{{{*/
 // ---------------------------------------------------------------------
 /* The legacy translations here of input Pkg iterators is obsolete, 
    this is not necessary since the pkgCaches are fully shared now. */
 pkgSimulate::pkgSimulate(pkgDepCache *Cache) : pkgPackageManager(Cache),
 // Simulate::Simulate - Constructor                                    /*{{{*/
 // ---------------------------------------------------------------------
 /* The legacy translations here of input Pkg iterators is obsolete, 
    this is not necessary since the pkgCaches are fully shared now. */
 pkgSimulate::pkgSimulate(pkgDepCache *Cache) : pkgPackageManager(Cache),

-                           iPolicy(Cache),
+                           d(NULL), iPolicy(Cache),

                            Sim(&Cache->GetCache(),&iPolicy),
                            group(Sim)
 {
                            Sim(&Cache->GetCache(),&iPolicy),
                            group(Sim)
 {


@@ -362,13 +358,11 @@ pkgProblemResolver::~pkgProblemResolver()
 // ProblemResolver::ScoreSort - Sort the list by score                 /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // ProblemResolver::ScoreSort - Sort the list by score                 /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-int pkgProblemResolver::ScoreSort(const void *a,const void *b)
+int pkgProblemResolver::ScoreSort(Package const *A,Package const *B)

 {
 {

-   Package const **A = (Package const **)a;
-   Package const **B = (Package const **)b;
-   if (This->Scores[(*A)->ID] > This->Scores[(*B)->ID])
+   if (Scores[A->ID] > Scores[B->ID])

       return -1;
       return -1;

-   if (This->Scores[(*A)->ID] < This->Scores[(*B)->ID])
+   if (Scores[A->ID] < Scores[B->ID])

       return 1;
    return 0;
 }
       return 1;
    return 0;
 }


@@ -468,7 +462,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];


@@ -476,8 +470,8 @@ void pkgProblemResolver::MakeScores()
    }
 
    // Copy the scores to advoid additive looping
    }
 
    // Copy the scores to advoid additive looping

-   SPtrArray<int> OldScores = new int[Size];
-   memcpy(OldScores,Scores,sizeof(*Scores)*Size);
+   std::unique_ptr<int[]> OldScores(new int[Size]);
+   memcpy(OldScores.get(),Scores,sizeof(*Scores)*Size);

       
    /* Now we cause 1 level of dependency inheritance, that is we add the 
       score of the packages that depend on the target Package. This 
       
    /* Now we cause 1 level of dependency inheritance, that is we add the 
       score of the packages that depend on the target Package. This 


@@ -638,8 +632,6 @@ bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg)
 }
                                                                        /*}}}*/
 // ProblemResolver::Resolve - calls a resolver to fix the situation    /*{{{*/
 }
                                                                        /*}}}*/
 // ProblemResolver::Resolve - calls a resolver to fix the situation    /*{{{*/

-// ---------------------------------------------------------------------
-/* */

 bool pkgProblemResolver::Resolve(bool BrokenFix, OpProgress * const Progress)
 {
    std::string const solver = _config->Find("APT::Solver", "internal");
 bool pkgProblemResolver::Resolve(bool BrokenFix, OpProgress * const Progress)
 {
    std::string const solver = _config->Find("APT::Solver", "internal");


@@ -704,17 +696,17 @@ bool pkgProblemResolver::ResolveInternal(bool const BrokenFix)
       operates from highest score to lowest. This prevents problems when
       high score packages cause the removal of lower score packages that
       would cause the removal of even lower score packages. */
       operates from highest score to lowest. This prevents problems when
       high score packages cause the removal of lower score packages that
       would cause the removal of even lower score packages. */

-   SPtrArray<pkgCache::Package *> PList = new pkgCache::Package *[Size];
-   pkgCache::Package **PEnd = PList;
+   std::unique_ptr<pkgCache::Package *[]> PList(new pkgCache::Package *[Size]);
+   pkgCache::Package **PEnd = PList.get();

    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       *PEnd++ = I;
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       *PEnd++ = I;

-   This = this;
-   qsort(PList,PEnd - PList,sizeof(*PList),&ScoreSort);
+
+   std::sort(PList.get(), PEnd, [this](Package *a, Package *b) { return ScoreSort(a, b) < 0; });

 
    if (_config->FindB("Debug::pkgProblemResolver::ShowScores",false) == true)
    {
       clog << "Show Scores" << endl;
 
    if (_config->FindB("Debug::pkgProblemResolver::ShowScores",false) == true)
    {
       clog << "Show Scores" << endl;

-      for (pkgCache::Package **K = PList; K != PEnd; K++)
+      for (pkgCache::Package **K = PList.get(); K != PEnd; K++)

          if (Scores[(*K)->ID] != 0)
          {
            pkgCache::PkgIterator Pkg(Cache,*K);
          if (Scores[(*K)->ID] != 0)
          {
            pkgCache::PkgIterator Pkg(Cache,*K);


@@ -736,7 +728,7 @@ bool pkgProblemResolver::ResolveInternal(bool const BrokenFix)
    for (int Counter = 0; Counter != 10 && Change == true; Counter++)
    {
       Change = false;
    for (int Counter = 0; Counter != 10 && Change == true; Counter++)
    {
       Change = false;

-      for (pkgCache::Package **K = PList; K != PEnd; K++)
+      for (pkgCache::Package **K = PList.get(); K != PEnd; K++)

       {
         pkgCache::PkgIterator I(Cache,*K);
 
       {
         pkgCache::PkgIterator I(Cache,*K);
 


@@ -847,8 +839,8 @@ bool pkgProblemResolver::ResolveInternal(bool const BrokenFix)
            /* Look across the version list. If there are no possible
               targets then we keep the package and bail. This is necessary
               if a package has a dep on another package that can't be found */
            /* Look across the version list. If there are no possible
               targets then we keep the package and bail. This is necessary
               if a package has a dep on another package that can't be found */

-           SPtrArray<pkgCache::Version *> VList = Start.AllTargets();
-           if (*VList == 0 && (Flags[I->ID] & Protected) != Protected &&
+           std::unique_ptr<pkgCache::Version *[]> VList(Start.AllTargets());
+           if (VList[0] == 0 && (Flags[I->ID] & Protected) != Protected &&

                Start.IsNegative() == false &&
                Cache[I].NowBroken() == false)
            {          
                Start.IsNegative() == false &&
                Cache[I].NowBroken() == false)
            {          


@@ -865,7 +857,7 @@ bool pkgProblemResolver::ResolveInternal(bool const BrokenFix)
            }
            
            bool Done = false;
            }
            
            bool Done = false;

-           for (pkgCache::Version **V = VList; *V != 0; V++)
+           for (pkgCache::Version **V = VList.get(); *V != 0; V++)

            {
               pkgCache::VerIterator Ver(Cache,*V);
               pkgCache::PkgIterator Pkg = Ver.ParentPkg();
            {
               pkgCache::VerIterator Ver(Cache,*V);
               pkgCache::PkgIterator Pkg = Ver.ParentPkg();


@@ -941,7 +933,7 @@ bool pkgProblemResolver::ResolveInternal(bool const BrokenFix)
                                 Start.TargetPkg()->CurrentVer == 0 &&
                                 Cache[Start.TargetPkg()].Delete() == false &&
                                 (Flags[Start.TargetPkg()->ID] & ToRemove) != ToRemove &&
                                 Start.TargetPkg()->CurrentVer == 0 &&
                                 Cache[Start.TargetPkg()].Delete() == false &&
                                 (Flags[Start.TargetPkg()->ID] & ToRemove) != ToRemove &&

-                                Cache.GetCandidateVer(Start.TargetPkg()).end() == false)
+                                Cache.GetCandidateVersion(Start.TargetPkg()).end() == false)

                        {
                           /* Before removing or keeping the package with the broken dependency
                              try instead to install the first not previously installed package
                        {
                           /* Before removing or keeping the package with the broken dependency
                              try instead to install the first not previously installed package


@@ -1167,8 +1159,9 @@ bool pkgProblemResolver::ResolveByKeepInternal()
    pkgCache::Package **PEnd = PList;
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       *PEnd++ = I;
    pkgCache::Package **PEnd = PList;
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       *PEnd++ = I;

-   This = this;
-   qsort(PList,PEnd - PList,sizeof(*PList),&ScoreSort);
+
+   std::sort(PList,PEnd,[this](Package *a, Package *b) { return ScoreSort(a, b) < 0; });
+

 
    if (_config->FindB("Debug::pkgProblemResolver::ShowScores",false) == true)
    {
 
    if (_config->FindB("Debug::pkgProblemResolver::ShowScores",false) == true)
    {


@@ -1235,8 +1228,8 @@ bool pkgProblemResolver::ResolveByKeepInternal()
               clog << "Package " << I.FullName(false) << " " << Start << endl;
 
            // Look at all the possible provides on this package
               clog << "Package " << I.FullName(false) << " " << Start << endl;
 
            // Look at all the possible provides on this package

-           SPtrArray<pkgCache::Version *> VList = Start.AllTargets();
-           for (pkgCache::Version **V = VList; *V != 0; V++)
+           std::unique_ptr<pkgCache::Version *[]> VList(Start.AllTargets());
+           for (pkgCache::Version **V = VList.get(); *V != 0; V++)

            {
               pkgCache::VerIterator Ver(Cache,*V);
               pkgCache::PkgIterator Pkg = Ver.ParentPkg();
            {
               pkgCache::VerIterator Ver(Cache,*V);
               pkgCache::PkgIterator Pkg = Ver.ParentPkg();


@@ -1318,36 +1311,46 @@ void pkgProblemResolver::InstallProtect()
 // ---------------------------------------------------------------------
 /* This is ment to be used in conjunction with AllTargets to get a list 
    of versions ordered by preference. */
 // ---------------------------------------------------------------------
 /* This is ment to be used in conjunction with AllTargets to get a list 
    of versions ordered by preference. */

-static pkgCache *PrioCache;
-static int PrioComp(const void *A,const void *B)
-{
-   pkgCache::VerIterator L(*PrioCache,*(pkgCache::Version **)A);
-   pkgCache::VerIterator R(*PrioCache,*(pkgCache::Version **)B);
-   
-   if ((L.ParentPkg()->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential &&
-       (R.ParentPkg()->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential)
-     return 1;
-   if ((L.ParentPkg()->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential &&
-       (R.ParentPkg()->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
-     return -1;
-
-   if ((L.ParentPkg()->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important &&
-       (R.ParentPkg()->Flags & pkgCache::Flag::Important) != pkgCache::Flag::Important)
-     return 1;
-   if ((L.ParentPkg()->Flags & pkgCache::Flag::Important) != pkgCache::Flag::Important &&
-       (R.ParentPkg()->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important)
-     return -1;
-   
-   if (L->Priority != R->Priority)
-      return R->Priority - L->Priority;
-   return strcmp(L.ParentPkg().Name(),R.ParentPkg().Name());
-}
+
+struct PrioComp {
+   pkgCache &PrioCache;
+
+   explicit PrioComp(pkgCache &PrioCache) : PrioCache(PrioCache) {
+   }
+
+   bool operator() (pkgCache::Version * const &A, pkgCache::Version * const &B) {
+      return compare(A, B) < 0;
+   }
+
+   int compare(pkgCache::Version * const &A, pkgCache::Version * const &B) {
+      pkgCache::VerIterator L(PrioCache,A);
+      pkgCache::VerIterator R(PrioCache,B);
+
+      if ((L.ParentPkg()->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential &&
+         (R.ParentPkg()->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential)
+       return 1;
+      if ((L.ParentPkg()->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential &&
+         (R.ParentPkg()->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
+       return -1;
+
+      if ((L.ParentPkg()->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important &&
+         (R.ParentPkg()->Flags & pkgCache::Flag::Important) != pkgCache::Flag::Important)
+       return 1;
+      if ((L.ParentPkg()->Flags & pkgCache::Flag::Important) != pkgCache::Flag::Important &&
+         (R.ParentPkg()->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important)
+       return -1;
+
+      if (L->Priority != R->Priority)
+        return R->Priority - L->Priority;
+      return strcmp(L.ParentPkg().Name(),R.ParentPkg().Name());
+   }
+};
+

 void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List)
 {
    unsigned long Count = 0;
 void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List)
 {
    unsigned long Count = 0;

-   PrioCache = &Cache;

    for (pkgCache::Version **I = List; *I != 0; I++)
       Count++;
    for (pkgCache::Version **I = List; *I != 0; I++)
       Count++;

-   qsort(List,Count,sizeof(*List),PrioComp);
+   std::sort(List,List+Count,PrioComp(Cache));

 }
                                                                        /*}}}*/
 }
                                                                        /*}}}*/