// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: pkgcache.cc,v 1.6 1998/07/12 01:26:04 jgg Exp $
+// $Id: pkgcache.cc,v 1.29 1999/10/02 03:11:50 jgg Exp $
/* ######################################################################
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
/*}}}*/
// 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
-#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>
/* Whenever the structures change the major version should be bumped,
whenever the generator changes the minor version should be bumped. */
- MajorVersion = 2;
- MinorVersion = 0;
+ MajorVersion = 3;
+ MinorVersion = 4;
Dirty = true;
HeaderSz = sizeof(pkgCache::Header);
VersionCount = 0;
DependsCount = 0;
PackageFileCount = 0;
+ VerFileCount = 0;
+ ProvidesCount = 0;
+ MaxVerFileSize = 0;
FileList = 0;
StringList = 0;
/* 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++)
- 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;
- 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);
}
/*}}}*/
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);
+// cout << "b" << flush;
}
return PkgIterator(*this,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() {}
// ---------------------------------------------------------------------
/* 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;
- if (Pkg->CurrentState == State::UnInstalled ||
- Pkg->CurrentState == State::HalfInstalled ||
- Pkg->InstState != State::Ok)
+ if (Pkg->CurrentState == pkgCache::State::HalfInstalled ||
+ Pkg->InstState != pkgCache::State::Ok)
return NeedsUnpack;
return NeedsNothing;
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;
}
// ---------------------------------------------------------------------
/* 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;
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++;
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++;
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
{
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;
+}
+ /*}}}*/
+// 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
projects / apt.git / blobdiff