More touch ups

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

diff --git a/apt-pkg/pkgcache.cc b/apt-pkg/pkgcache.cc
index 2fbdc717fb050b22e8468ca125e20ef0ddbfd7fa..2a10928aa2d9fbe5321c50edc1306a2ee75a90b1 100644 (file)
--- a/apt-pkg/pkgcache.cc
+++ b/apt-pkg/pkgcache.cc
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/

-// $Id: pkgcache.cc,v 1.17 1998/11/23 07:03:05 jgg Exp $
+// $Id: pkgcache.cc,v 1.29 1999/10/02 03:11:50 jgg Exp $

 /* ######################################################################
    
    Package Cache - Accessor code for the cache
 /* ######################################################################
    
    Package Cache - Accessor code for the cache


@@ -43,8 +43,8 @@ pkgCache::Header::Header()
    
    /* Whenever the structures change the major version should be bumped,
       whenever the generator changes the minor version should be bumped. */
    
    /* Whenever the structures change the major version should be bumped,
       whenever the generator changes the minor version should be bumped. */

-   MajorVersion = 2;
-   MinorVersion = 2;
+   MajorVersion = 3;
+   MinorVersion = 4;

    Dirty = true;
    
    HeaderSz = sizeof(pkgCache::Header);
    Dirty = true;
    
    HeaderSz = sizeof(pkgCache::Header);


@@ -59,6 +59,8 @@ pkgCache::Header::Header()
    VersionCount = 0;
    DependsCount = 0;
    PackageFileCount = 0;
    VersionCount = 0;
    DependsCount = 0;
    PackageFileCount = 0;

+   VerFileCount = 0;
+   ProvidesCount = 0;

    MaxVerFileSize = 0;
    
    FileList = 0;
    MaxVerFileSize = 0;
    
    FileList = 0;


@@ -130,23 +132,20 @@ bool pkgCache::ReMap()
 /* This is used to generate the hash entries for the HashTable. With my
    package list from bo this function gets 94% table usage on a 512 item
    table (480 used items) */
 /* This is used to generate the hash entries for the HashTable. With my
    package list from bo this function gets 94% table usage on a 512 item
    table (480 used items) */

-unsigned long pkgCache::sHash(string Str)
+unsigned long pkgCache::sHash(string Str) const

 {
    unsigned long Hash = 0;
    for (const char *I = Str.begin(); I != Str.end(); I++)
 {
    unsigned long Hash = 0;
    for (const char *I = Str.begin(); I != Str.end(); I++)

-      Hash += *I * ((Str.end() - I + 1));
-   Header H;
-   return Hash % _count(H.HashTable);
+      Hash = 5*Hash + *I;
+   return Hash % _count(HeaderP->HashTable);

 }
 
 }
 

-unsigned long pkgCache::sHash(const char *Str)
+unsigned long pkgCache::sHash(const char *Str) const

 {
    unsigned long Hash = 0;
 {
    unsigned long Hash = 0;

-   const char *End = Str + strlen(Str);
-   for (const char *I = Str; I != End; I++)
-      Hash += *I * ((End - I + 1));
-   Header H;
-   return Hash % _count(H.HashTable);
+   for (const char *I = Str; *I != 0; I++)
+      Hash = 5*Hash + *I;
+   return Hash % _count(HeaderP->HashTable);

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


@@ -159,8 +158,10 @@ pkgCache::PkgIterator pkgCache::FindPkg(string Name)
    Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)];
    for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)
    {
    Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)];
    for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)
    {

-      if (Pkg->Name != 0 && StrP + Pkg->Name == Name)
+      if (Pkg->Name != 0 && StrP[Pkg->Name] == Name[0] &&
+         StrP + Pkg->Name == Name)

         return PkgIterator(*this,Pkg);
         return PkgIterator(*this,Pkg);

+//      cout << "b" << flush;

    }
    return PkgIterator(*this,0);
 }
    }
    return PkgIterator(*this,0);
 }


@@ -176,6 +177,43 @@ const char *pkgCache::Priority(unsigned char Prio)
    return 0;
 }
                                                                        /*}}}*/
    return 0;
 }
                                                                        /*}}}*/

+// Cache::GetCandidateVer - Returns the Candidate install version      /*{{{*/
+// ---------------------------------------------------------------------
+/* The default just returns the highest available version that is not
+   a source and automatic */
+pkgCache::VerIterator pkgCache::GetCandidateVer(PkgIterator Pkg,
+                                               bool AllowCurrent)
+{
+   /* Not source/not automatic versions cannot be a candidate version 
+      unless they are already installed */
+   VerIterator Last(*this,0);
+   
+   for (VerIterator I = Pkg.VersionList(); I.end() == false; I++)
+   {
+      if (Pkg.CurrentVer() == I && AllowCurrent == true)
+        return I;
+      
+      for (VerFileIterator J = I.FileList(); J.end() == false; J++)
+      {
+        if ((J.File()->Flags & Flag::NotSource) != 0)
+           continue;
+
+        /* Stash the highest version of a not-automatic source, we use it
+           if there is nothing better */
+        if ((J.File()->Flags & Flag::NotAutomatic) != 0)
+        {
+           if (Last.end() == true)
+              Last = I;
+           continue;
+        }
+        
+        return I;
+      }   
+   }
+   
+   return Last;
+}
+                                                                       /*}}}*/

 
 // Bases for iterator classes                                          /*{{{*/
 void pkgCache::VerIterator::_dummy() {}
 
 // Bases for iterator classes                                          /*{{{*/
 void pkgCache::VerIterator::_dummy() {}


@@ -212,8 +250,7 @@ pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
        Pkg->CurrentState == pkgCache::State::HalfConfigured)
       return NeedsConfigure;
    
        Pkg->CurrentState == pkgCache::State::HalfConfigured)
       return NeedsConfigure;
    

-   if (Pkg->CurrentState == pkgCache::State::UnInstalled ||
-       Pkg->CurrentState == pkgCache::State::HalfInstalled ||
+   if (Pkg->CurrentState == pkgCache::State::HalfInstalled ||

        Pkg->InstState != pkgCache::State::Ok)
       return NeedsUnpack;
       
        Pkg->InstState != pkgCache::State::Ok)
       return NeedsUnpack;
       


@@ -379,9 +416,10 @@ void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
    // Compute a single dependency element (glob or)
    Start = *this;
    End = *this;
    // Compute a single dependency element (glob or)
    Start = *this;
    End = *this;

-   for (bool LastOR = true; end() == false && LastOR == true; (*this)++)
+   for (bool LastOR = true; end() == false && LastOR == true;)

    {
       LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
    {
       LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;

+      (*this)++;

       if (LastOR == true)
         End = (*this);
    }
       if (LastOR == true)
         End = (*this);
    }


@@ -422,6 +460,48 @@ bool pkgCache::VerIterator::Downloadable() const
    return false;
 }
                                                                        /*}}}*/
    return false;
 }
                                                                        /*}}}*/

+// VerIterator::PriorityType - Return a string describing the priority /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+const char *pkgCache::VerIterator::PriorityType()
+{
+   const char *Types[] = {"","Important","Required","Standard",
+                          "Optional","Extra"};
+   if (Ver->Priority < 6)
+      return Types[Ver->Priority];
+   return "";
+}
+                                                                       /*}}}*/
+// VerIterator::Automatic - Check if this version is 'automatic'       /*{{{*/
+// ---------------------------------------------------------------------
+/* This checks to see if any of the versions files are not NotAutomatic. 
+   True if this version is selectable for automatic installation. */
+bool pkgCache::VerIterator::Automatic() const
+{
+   VerFileIterator Files = FileList();
+   for (; Files.end() == false; Files++)
+      if ((Files.File()->Flags & pkgCache::Flag::NotAutomatic) != pkgCache::Flag::NotAutomatic)
+        return true;
+   return false;
+}
+                                                                       /*}}}*/
+// VerIterator::NewestFile - Return the newest file version relation   /*{{{*/
+// ---------------------------------------------------------------------
+/* This looks at the version numbers associated with all of the sources
+   this version is in and returns the highest.*/
+pkgCache::VerFileIterator pkgCache::VerIterator::NewestFile() const
+{
+   VerFileIterator Files = FileList();
+   VerFileIterator Highest = Files;
+   for (; Files.end() == false; Files++)
+   {
+      if (pkgVersionCompare(Files.File().Version(),Highest.File().Version()) > 0)
+        Highest = Files;
+   }
+   
+   return Highest;
+}
+                                                                       /*}}}*/

 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file        /*{{{*/
 // ---------------------------------------------------------------------
 /* This stats the file and compares its stats with the ones that were
 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file        /*{{{*/
 // ---------------------------------------------------------------------
 /* This stats the file and compares its stats with the ones that were