Flag to fetch the source index

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

diff --git a/apt-pkg/pkgcache.cc b/apt-pkg/pkgcache.cc
index b8af6b5e43ace8317c84a3dec18fa4e4a63e96f8..017c4accbc54f0b2d9db6cde6177b4db217cfa2b 100644 (file)
--- a/apt-pkg/pkgcache.cc
+++ b/apt-pkg/pkgcache.cc
@@ -1,11 +1,11 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/

-// $Id: pkgcache.cc,v 1.6 1998/07/12 01:26:04 jgg Exp $
+// $Id: pkgcache.cc,v 1.23 1999/02/23 06:46:24 jgg Exp $

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

-   Please see doc/pkglib/cache.sgml for a more detailed description of 
+   Please see doc/apt-pkg/cache.sgml for a more detailed description of 

    this format. Also be sure to keep that file up-to-date!!
    
    This is the general utility functions for cache managment. They provide
    this format. Also be sure to keep that file up-to-date!!
    
    This is the general utility functions for cache managment. They provide


@@ -21,12 +21,12 @@
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
 #ifdef __GNUG__
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
 #ifdef __GNUG__

-#pragma implementation "pkglib/pkgcache.h"
-#pragma implementation "pkglib/cacheiterators.h"
+#pragma implementation "apt-pkg/pkgcache.h"
+#pragma implementation "apt-pkg/cacheiterators.h"

 #endif 
 #endif 

-#include <pkglib/pkgcache.h>
-#include <pkglib/version.h>
-#include <pkglib/error.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/version.h>
+#include <apt-pkg/error.h>

 #include <system.h>
 
 #include <string>
 #include <system.h>
 
 #include <string>


@@ -44,7 +44,7 @@ pkgCache::Header::Header()
    /* Whenever the structures change the major version should be bumped,
       whenever the generator changes the minor version should be bumped. */
    MajorVersion = 2;
    /* Whenever the structures change the major version should be bumped,
       whenever the generator changes the minor version should be bumped. */
    MajorVersion = 2;

-   MinorVersion = 0;
+   MinorVersion = 3;

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


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

+   VerFileCount = 0;
+   ProvidesCount = 0;
+   MaxVerFileSize = 0;

    
    FileList = 0;
    StringList = 0;
    
    FileList = 0;
    StringList = 0;


@@ -129,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);

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


@@ -158,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);
 }


@@ -202,14 +204,18 @@ void pkgCache::PkgIterator::operator ++(int)
 // ---------------------------------------------------------------------
 /* By this we mean if it is either cleanly installed or cleanly removed. */
 pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
 // ---------------------------------------------------------------------
 /* By this we mean if it is either cleanly installed or cleanly removed. */
 pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const

-{
-   if (Pkg->CurrentState == State::UnPacked ||
-       Pkg->CurrentState == State::HalfConfigured)
+{  
+   if (Pkg->InstState == pkgCache::State::ReInstReq ||
+       Pkg->InstState == pkgCache::State::HoldReInstReq)
+      return NeedsUnpack;
+   
+   if (Pkg->CurrentState == pkgCache::State::UnPacked ||
+       Pkg->CurrentState == pkgCache::State::HalfConfigured)

       return NeedsConfigure;
    
       return NeedsConfigure;
    

-   if (Pkg->CurrentState == State::UnInstalled ||
-       Pkg->CurrentState == State::HalfInstalled ||
-       Pkg->InstState != State::Ok)
+   if (Pkg->CurrentState == pkgCache::State::UnInstalled ||
+       Pkg->CurrentState == pkgCache::State::HalfInstalled ||
+       Pkg->InstState != pkgCache::State::Ok)

       return NeedsUnpack;
       
    return NeedsNothing;
       return NeedsUnpack;
       
    return NeedsNothing;


@@ -221,8 +227,9 @@ pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
    conflicts. */
 bool pkgCache::DepIterator::IsCritical()
 {
    conflicts. */
 bool pkgCache::DepIterator::IsCritical()
 {

-   if (Dep->Type == Dep::Conflicts || Dep->Type == Dep::Depends ||
-       Dep->Type == Dep::PreDepends)
+   if (Dep->Type == pkgCache::Dep::Conflicts || 
+       Dep->Type == pkgCache::Dep::Depends ||
+       Dep->Type == pkgCache::Dep::PreDepends)

       return true;
    return false;
 }
       return true;
    return false;
 }


@@ -281,7 +288,8 @@ bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
 // ---------------------------------------------------------------------
 /* This is a more usefull version of TargetPkg() that follows versioned
    provides. It includes every possible package-version that could satisfy
 // ---------------------------------------------------------------------
 /* This is a more usefull version of TargetPkg() that follows versioned
    provides. It includes every possible package-version that could satisfy

-   the dependency. The last item in the list has a 0. */
+   the dependency. The last item in the list has a 0. The resulting pointer
+   must be delete [] 'd */

 pkgCache::Version **pkgCache::DepIterator::AllTargets()
 {
    Version **Res = 0;
 pkgCache::Version **pkgCache::DepIterator::AllTargets()
 {
    Version **Res = 0;


@@ -297,7 +305,8 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
         if (pkgCheckDep(TargetVer(),I.VerStr(),Dep->CompareOp) == false)
            continue;
 
         if (pkgCheckDep(TargetVer(),I.VerStr(),Dep->CompareOp) == false)
            continue;
 

-        if (Dep->Type == Dep::Conflicts && ParentPkg() == I.ParentPkg())
+        if (Dep->Type == pkgCache::Dep::Conflicts && 
+            ParentPkg() == I.ParentPkg())

            continue;
         
         Size++;
            continue;
         
         Size++;


@@ -311,7 +320,8 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
         if (pkgCheckDep(TargetVer(),I.ProvideVersion(),Dep->CompareOp) == false)
            continue;
         
         if (pkgCheckDep(TargetVer(),I.ProvideVersion(),Dep->CompareOp) == false)
            continue;
         

-        if (Dep->Type == Dep::Conflicts && ParentPkg() == I.OwnerPkg())
+        if (Dep->Type == pkgCache::Dep::Conflicts && 
+            ParentPkg() == I.OwnerPkg())

            continue;
         
         Size++;
            continue;
         
         Size++;


@@ -335,6 +345,50 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
    return Res;
 }
                                                                        /*}}}*/
    return Res;
 }
                                                                        /*}}}*/

+// DepIterator::CompType - Return a string describing the compare type /*{{{*/
+// ---------------------------------------------------------------------
+/* This returns a string representation of the dependency compare 
+   type */
+const char *pkgCache::DepIterator::CompType()
+{
+   const char *Ops[] = {"","<=",">=","<",">","=","!="};
+   if ((unsigned)(Dep->CompareOp & 0xF) < 7)
+      return Ops[Dep->CompareOp & 0xF];
+   return "";   
+}
+                                                                       /*}}}*/
+// DepIterator::DepType - Return a string describing the dep type      /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+const char *pkgCache::DepIterator::DepType()
+{
+   const char *Types[] = {"","Depends","PreDepends","Suggests",
+                          "Recommends","Conflicts","Replaces"};
+   if (Dep->Type < 7)
+      return Types[Dep->Type];
+   return "";
+}
+                                                                       /*}}}*/
+// DepIterator::GlobOr - Compute an OR group                           /*{{{*/
+// ---------------------------------------------------------------------
+/* This Takes an iterator, iterates past the current dependency grouping
+   and returns Start and End so that so End is the final element
+   in the group, if End == Start then D is End++ and End is the
+   dependency D was pointing to. Use in loops to iterate sensibly. */
+void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
+{
+   // Compute a single dependency element (glob or)
+   Start = *this;
+   End = *this;
+   for (bool LastOR = true; end() == false && LastOR == true;)
+   {
+      LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
+      (*this)++;
+      if (LastOR == true)
+        End = (*this);
+   }
+}
+                                                                       /*}}}*/

 // VerIterator::CompareVer - Fast version compare for same pkgs                /*{{{*/
 // ---------------------------------------------------------------------
 /* This just looks over the version list to see if B is listed before A. In
 // VerIterator::CompareVer - Fast version compare for same pkgs                /*{{{*/
 // ---------------------------------------------------------------------
 /* This just looks over the version list to see if B is listed before A. In


@@ -365,11 +419,53 @@ bool pkgCache::VerIterator::Downloadable() const
 {
    VerFileIterator Files = FileList();
    for (; Files.end() == false; Files++)
 {
    VerFileIterator Files = FileList();
    for (; Files.end() == false; Files++)

-      if ((Files.File()->Flags & Flag::NotSource) != Flag::NotSource)
+      if ((Files.File()->Flags & pkgCache::Flag::NotSource) != pkgCache::Flag::NotSource)
+        return true;
+   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;
 }
                                                                        /*}}}*/
         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