// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: pkgcache.cc,v 1.3 1998/07/04 22:32:11 jgg Exp $
+// $Id: pkgcache.cc,v 1.18 1998/11/27 00:07:24 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 /*{{{*/
-#include <pkglib/pkgcache.h>
-#include <pkglib/version.h>
-#include <pkglib/error.h>
+#ifdef __GNUG__
+#pragma implementation "apt-pkg/pkgcache.h"
+#pragma implementation "apt-pkg/cacheiterators.h"
+#endif
+#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;
+ MinorVersion = 2;
Dirty = true;
HeaderSz = sizeof(pkgCache::Header);
VersionSz = sizeof(pkgCache::Version);
DependencySz = sizeof(pkgCache::Dependency);
ProvidesSz = sizeof(pkgCache::Provides);
-
+ VerFileSz = sizeof(pkgCache::VerFile);
+
PackageCount = 0;
VersionCount = 0;
DependsCount = 0;
PackageFileCount = 0;
+ MaxVerFileSize = 0;
FileList = 0;
StringList = 0;
PackageSz == Against.PackageSz &&
PackageFileSz == Against.PackageFileSz &&
VersionSz == Against.VersionSz &&
- DependencySz == Against.DependencySz &&
+ DependencySz == Against.DependencySz &&
+ VerFileSz == Against.VerFileSz &&
ProvidesSz == Against.ProvidesSz)
return true;
return false;
// Apply the typecasts.
HeaderP = (Header *)Map.Data();
PkgP = (Package *)Map.Data();
+ VerFileP = (VerFile *)Map.Data();
PkgFileP = (PackageFile *)Map.Data();
VerP = (Version *)Map.Data();
ProvideP = (Provides *)Map.Data();
StringItemP = (StringItem *)Map.Data();
StrP = (char *)Map.Data();
- cout << "Size is " << Map.Size() << endl;
if (Map.Size() == 0)
return false;
// ---------------------------------------------------------------------
/* By this we mean if it is either cleanly installed or cleanly removed. */
pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
-{
- if (Pkg->CurrentState == UnPacked ||
- Pkg->CurrentState == 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 == UnInstalled ||
- Pkg->CurrentState == HalfInstalled ||
- Pkg->InstState != Ok)
+ if (Pkg->CurrentState == pkgCache::State::UnInstalled ||
+ Pkg->CurrentState == pkgCache::State::HalfInstalled ||
+ Pkg->InstState != pkgCache::State::Ok)
return NeedsUnpack;
return NeedsNothing;
conflicts. */
bool pkgCache::DepIterator::IsCritical()
{
- if (Dep->Type == Conflicts || Dep->Type == Depends ||
- Dep->Type == 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 == 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 == 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; (*this)++)
+ {
+ LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
+ 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
return -1;
}
/*}}}*/
+// VerIterator::Downloadable - Checks if the version is downloadable /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool pkgCache::VerIterator::Downloadable() const
+{
+ VerFileIterator Files = FileList();
+ for (; Files.end() == false; Files++)
+ 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 "";
+}
+ /*}}}*/
// 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