run update post-invokes even on (partial) failures

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

diff --git a/apt-pkg/orderlist.cc b/apt-pkg/orderlist.cc
index edbdd09ab4088c1b5812416a723d661c21459825..bfdc50e6cc2265bfebca0e3f07f6d8c3ce9dc4c2 100644 (file)
--- a/apt-pkg/orderlist.cc
+++ b/apt-pkg/orderlist.cc
@@ -68,21 +68,18 @@
 #include <apt-pkg/orderlist.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/orderlist.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/error.h>

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

 #include <apt-pkg/configuration.h>
 #include <apt-pkg/cacheiterators.h>
 #include <apt-pkg/pkgcache.h>
 
 #include <stdlib.h>
 #include <string.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/cacheiterators.h>
 #include <apt-pkg/pkgcache.h>
 
 #include <stdlib.h>
 #include <string.h>

-#include <string>
+#include <algorithm>

 #include <iostream>
                                                                        /*}}}*/
 
 using namespace std;
 
 #include <iostream>
                                                                        /*}}}*/
 
 using namespace std;
 

-pkgOrderList *pkgOrderList::Me = 0;
-

 // OrderList::pkgOrderList - Constructor                               /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // OrderList::pkgOrderList - Constructor                               /*{{{*/
 // ---------------------------------------------------------------------
 /* */


@@ -142,9 +139,9 @@ bool pkgOrderList::DoRun()
 {   
    // Temp list
    unsigned long Size = Cache.Head().PackageCount;
 {   
    // Temp list
    unsigned long Size = Cache.Head().PackageCount;

-   SPtrArray<Package *> NList = new Package *[Size];
-   SPtrArray<Package *> AfterList = new Package *[Size];
-   AfterEnd = AfterList;
+   std::unique_ptr<Package *[]> NList(new Package *[Size]);
+   std::unique_ptr<Package *[]> AfterList(new Package *[Size]);
+   AfterEnd = AfterList.get();

    
    Depth = 0;
    WipeFlags(Added | AddPending | Loop | InList);
    
    Depth = 0;
    WipeFlags(Added | AddPending | Loop | InList);


@@ -154,7 +151,7 @@ bool pkgOrderList::DoRun()
 
    // Rebuild the main list into the temp list.
    iterator OldEnd = End;
 
    // Rebuild the main list into the temp list.
    iterator OldEnd = End;

-   End = NList;
+   End = NList.get();

    for (iterator I = List; I != OldEnd; ++I)
       if (VisitNode(PkgIterator(Cache,*I), "DoRun") == false)
       {
    for (iterator I = List; I != OldEnd; ++I)
       if (VisitNode(PkgIterator(Cache,*I), "DoRun") == false)
       {


@@ -163,12 +160,12 @@ bool pkgOrderList::DoRun()
       }
    
    // Copy the after list to the end of the main list
       }
    
    // Copy the after list to the end of the main list

-   for (Package **I = AfterList; I != AfterEnd; I++)
+   for (Package **I = AfterList.get(); I != AfterEnd; I++)

       *End++ = *I;
    
    // Swap the main list to the new list
    delete [] List;
       *End++ = *I;
    
    // Swap the main list to the new list
    delete [] List;

-   List = NList.UnGuard();
+   List = NList.release();

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -188,8 +185,7 @@ bool pkgOrderList::OrderCritical()
    LoopCount = 0;
 
    // Sort
    LoopCount = 0;
 
    // Sort

-   Me = this;
-   qsort(List,End - List,sizeof(*List),&OrderCompareB);
+   std::sort(List,End, [this](Package *a, Package *b) { return OrderCompareB(a, b) < 0; } );

 
    if (DoRun() == false)
       return false;
 
    if (DoRun() == false)
       return false;


@@ -241,8 +237,7 @@ bool pkgOrderList::OrderUnpack(string *FileList)
    LoopCount = -1;
 
    // Sort
    LoopCount = -1;
 
    // Sort

-   Me = this;
-   qsort(List,End - List,sizeof(*List),&OrderCompareA);
+   std::sort(List,End, [this](Package *a, Package *b) { return OrderCompareA(a, b) < 0; });

 
    if (Debug == true)
       clog << "** Pass A" << endl;
 
    if (Debug == true)
       clog << "** Pass A" << endl;


@@ -259,7 +254,7 @@ bool pkgOrderList::OrderUnpack(string *FileList)
       clog << "** Pass C" << endl;
    LoopCount = 0;
    RevDepends = 0;
       clog << "** Pass C" << endl;
    LoopCount = 0;
    RevDepends = 0;

-   Remove = 0;             // Otherwise the libreadline remove problem occures
+   Remove = 0;             // Otherwise the libreadline remove problem occurs

    if (DoRun() == false)
       return false;
 
    if (DoRun() == false)
       return false;
 


@@ -333,7 +328,7 @@ int pkgOrderList::Score(PkgIterator Pkg)
         break;
       }
 
         break;
       }
 

-   // Important Required Standard Optional Extra
+   // Required Important Standard Optional Extra

    if (Cache[Pkg].InstVerIter(Cache)->Priority <= 5)
    {
       signed short PrioMap[] = {0,5,4,3,1,0};
    if (Cache[Pkg].InstVerIter(Cache)->Priority <= 5)
    {
       signed short PrioMap[] = {0,5,4,3,1,0};


@@ -384,21 +379,21 @@ static int BoolCompare(bool A,bool B)
 // ---------------------------------------------------------------------
 /* This provides a first-pass sort of the list and gives a decent starting
     point for further complete ordering. It is used by OrderUnpack only */
 // ---------------------------------------------------------------------
 /* This provides a first-pass sort of the list and gives a decent starting
     point for further complete ordering. It is used by OrderUnpack only */

-int pkgOrderList::OrderCompareA(const void *a, const void *b)
+int pkgOrderList::OrderCompareA(Package *a, Package *b)

 {
 {

-   PkgIterator A(Me->Cache,*(Package **)a);
-   PkgIterator B(Me->Cache,*(Package **)b);
+   PkgIterator A(Cache,a);
+   PkgIterator B(Cache,b);

 
    // We order packages with a set state toward the front
    int Res;
 
    // We order packages with a set state toward the front
    int Res;

-   if ((Res = BoolCompare(Me->IsNow(A),Me->IsNow(B))) != 0)
+   if ((Res = BoolCompare(IsNow(A),IsNow(B))) != 0)

       return -1*Res;
    
    // We order missing files to toward the end
       return -1*Res;
    
    // We order missing files to toward the end

-/*   if (Me->FileList != 0)
+/*   if (FileList != 0)

    {
    {

-      if ((Res = BoolCompare(Me->IsMissing(A),
-                            Me->IsMissing(B))) != 0)
+      if ((Res = BoolCompare(IsMissing(A),
+                            IsMissing(B))) != 0)

         return Res;
    }*/
    
         return Res;
    }*/
    


@@ -410,8 +405,8 @@ int pkgOrderList::OrderCompareA(const void *a, const void *b)
        B.State() != pkgCache::PkgIterator::NeedsNothing)
       return 1;
    
        B.State() != pkgCache::PkgIterator::NeedsNothing)
       return 1;
    

-   int ScoreA = Me->Score(A);
-   int ScoreB = Me->Score(B);
+   int ScoreA = Score(A);
+   int ScoreB = Score(B);

 
    if (ScoreA > ScoreB)
       return -1;
 
    if (ScoreA > ScoreB)
       return -1;


@@ -426,10 +421,10 @@ int pkgOrderList::OrderCompareA(const void *a, const void *b)
 // ---------------------------------------------------------------------
 /* This orders by installation source. This is useful to handle
    inter-source breaks */
 // ---------------------------------------------------------------------
 /* This orders by installation source. This is useful to handle
    inter-source breaks */

-int pkgOrderList::OrderCompareB(const void *a, const void *b)
+int pkgOrderList::OrderCompareB(Package *a, Package *b)

 {
 {

-   PkgIterator A(Me->Cache,*(Package **)a);
-   PkgIterator B(Me->Cache,*(Package **)b);
+   PkgIterator A(Cache,a);
+   PkgIterator B(Cache,b);

 
    if (A.State() != pkgCache::PkgIterator::NeedsNothing && 
        B.State() == pkgCache::PkgIterator::NeedsNothing)
 
    if (A.State() != pkgCache::PkgIterator::NeedsNothing && 
        B.State() == pkgCache::PkgIterator::NeedsNothing)


@@ -439,7 +434,7 @@ int pkgOrderList::OrderCompareB(const void *a, const void *b)
        B.State() != pkgCache::PkgIterator::NeedsNothing)
       return 1;
    
        B.State() != pkgCache::PkgIterator::NeedsNothing)
       return 1;
    

-   int F = Me->FileCmp(A,B);
+   int F = FileCmp(A,B);

    if (F != 0)
    {
       if (F > 0)
    if (F != 0)
    {
       if (F > 0)


@@ -447,8 +442,8 @@ int pkgOrderList::OrderCompareB(const void *a, const void *b)
       return 1;
    }
    
       return 1;
    }
    

-   int ScoreA = Me->Score(A);
-   int ScoreB = Me->Score(B);
+   int ScoreA = Score(A);
+   int ScoreB = Score(B);

 
    if (ScoreA > ScoreB)
       return -1;
 
    if (ScoreA > ScoreB)
       return -1;


@@ -512,8 +507,8 @@ bool pkgOrderList::VisitRProvides(DepFunc F,VerIterator Ver)
    against it! */
 bool pkgOrderList::VisitProvides(DepIterator D,bool Critical)
 {
    against it! */
 bool pkgOrderList::VisitProvides(DepIterator D,bool Critical)
 {

-   SPtrArray<Version *> List = D.AllTargets();
-   for (Version **I = List; *I != 0; ++I)
+   std::unique_ptr<Version *[]> List(D.AllTargets());
+   for (Version **I = List.get(); *I != 0; ++I)

    {
       VerIterator Ver(Cache,*I);
       PkgIterator Pkg = Ver.ParentPkg();
    {
       VerIterator Ver(Cache,*I);
       PkgIterator Pkg = Ver.ParentPkg();


@@ -541,7 +536,7 @@ bool pkgOrderList::VisitProvides(DepIterator D,bool Critical)
    }
    if (D.IsNegative() == false)
       return true;
    }
    if (D.IsNegative() == false)
       return true;

-   for (Version **I = List; *I != 0; ++I)
+   for (Version **I = List.get(); *I != 0; ++I)

    {
       VerIterator Ver(Cache,*I);
       PkgIterator Pkg = Ver.ParentPkg();
    {
       VerIterator Ver(Cache,*I);
       PkgIterator Pkg = Ver.ParentPkg();


@@ -1075,9 +1070,9 @@ void pkgOrderList::WipeFlags(unsigned long F)
    this fails to produce a suitable result. */
 bool pkgOrderList::CheckDep(DepIterator D)
 {
    this fails to produce a suitable result. */
 bool pkgOrderList::CheckDep(DepIterator D)
 {

-   SPtrArray<Version *> List = D.AllTargets();
+   std::unique_ptr<Version *[]> List(D.AllTargets());

    bool Hit = false;
    bool Hit = false;

-   for (Version **I = List; *I != 0; I++)
+   for (Version **I = List.get(); *I != 0; I++)

    {
       VerIterator Ver(Cache,*I);
       PkgIterator Pkg = Ver.ParentPkg();
    {
       VerIterator Ver(Cache,*I);
       PkgIterator Pkg = Ver.ParentPkg();