edsp: ask policy engine for the pin of the version directly

[apt.git] / apt-private / private-cachefile.cc

diff --git a/apt-private/private-cachefile.cc b/apt-private/private-cachefile.cc
index c822b9badf9a3995c0298541ecf9b655ce89a692..32cad1c33fe0467a2e221b8bdff2ba586018b408 100644 (file)
--- a/apt-private/private-cachefile.cc
+++ b/apt-private/private-cachefile.cc
@@ -4,48 +4,57 @@
 #include <apt-pkg/algorithms.h>
 #include <apt-pkg/upgrade.h>
 #include <apt-pkg/error.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/depcache.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheset.h>
 
-#include <cstdlib>
+#include <apt-private/private-output.h>
+#include <apt-private/private-cachefile.h>
 
-#include "private-output.h"
-#include "private-cachefile.h"
+#include <string.h>
+#include <ostream>
+#include <cstdlib>
 
 #include <apti18n.h>
                                                                        /*}}}*/
 
 using namespace std;
 
-// CacheFile::NameComp - QSort compare by name                         /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-pkgCache *CacheFile::SortCache = 0;
-int CacheFile::NameComp(const void *a,const void *b)
+static bool SortPackagesByName(pkgCache * const Owner,
+      map_pointer_t const A, map_pointer_t const B)
 {
-   if (*(pkgCache::Package **)a == 0 || *(pkgCache::Package **)b == 0)
-      return *(pkgCache::Package **)a - *(pkgCache::Package **)b;
-   
-   const pkgCache::Package &A = **(pkgCache::Package **)a;
-   const pkgCache::Package &B = **(pkgCache::Package **)b;
-
-   return strcmp(SortCache->StrP + A.Name,SortCache->StrP + B.Name);
+   if (A == 0)
+      return false;
+   if (B == 0 || A == B)
+      return true;
+   pkgCache::Group const * const GA = Owner->GrpP + A;
+   pkgCache::Group const * const GB = Owner->GrpP + B;
+   return strcmp(Owner->StrP + GA->Name, Owner->StrP + GB->Name) <= 0;
 }
-                                                                       /*}}}*/
-// CacheFile::Sort - Sort by name                                      /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-void CacheFile::Sort()
+SortedPackageUniverse::SortedPackageUniverse(CacheFile &Cache) :
+      PackageUniverse{Cache}, List(Cache.UniverseList)
 {
-   delete [] List;
-   List = new pkgCache::Package *[Cache->Head().PackageCount];
-   memset(List,0,sizeof(*List)*Cache->Head().PackageCount);
-   pkgCache::PkgIterator I = Cache->PkgBegin();
-   for (;I.end() != true; ++I)
-      List[I->ID] = I;
-
-   SortCache = *this;
-   qsort(List,Cache->Head().PackageCount,sizeof(*List),NameComp);
 }
-                                                                       /*}}}*/
+void SortedPackageUniverse::LazyInit() const
+{
+   if (List.empty() == false)
+      return;
+   pkgCache * const Owner = data();
+   // In Multi-Arch systems Grps are easier to sort than Pkgs
+   std::vector<map_pointer_t> GrpList;
+   List.reserve(Owner->Head().GroupCount);
+   for (pkgCache::GrpIterator I{Owner->GrpBegin()}; I.end() != true; ++I)
+      GrpList.emplace_back(I - Owner->GrpP);
+   std::stable_sort(GrpList.begin(), GrpList.end(), std::bind( &SortPackagesByName, Owner, std::placeholders::_1, std::placeholders::_2 ));
+   List.reserve(Owner->Head().PackageCount);
+   for (auto G : GrpList)
+   {
+      pkgCache::GrpIterator const Grp(*Owner, Owner->GrpP + G);
+      for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
+        List.emplace_back(P - Owner->PkgP);
+   }
+}
 // CacheFile::CheckDeps - Open the cache file                          /*{{{*/
 // ---------------------------------------------------------------------
 /* This routine generates the caches and then opens the dependency cache