X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/6c139d6e362f04a1582e8a8f511f8aeab031fecf..65a1e968442361247b646dc61843f841235114e0:/apt-pkg/pkgcache.cc diff --git a/apt-pkg/pkgcache.cc b/apt-pkg/pkgcache.cc index 085225031..8ad501e96 100644 --- a/apt-pkg/pkgcache.cc +++ b/apt-pkg/pkgcache.cc @@ -1,11 +1,11 @@ // -*- mode: cpp; mode: fold -*- // Description /*{{{*/ -// $Id: pkgcache.cc,v 1.5 1998/07/07 04:17:02 jgg Exp $ +// $Id: pkgcache.cc,v 1.22 1998/12/14 08:07:29 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 @@ -21,12 +21,12 @@ /*}}}*/ // 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 -#include -#include +#include +#include +#include #include #include @@ -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; - MinorVersion = 0; + MinorVersion = 2; Dirty = true; HeaderSz = sizeof(pkgCache::Header); @@ -59,6 +59,9 @@ pkgCache::Header::Header() VersionCount = 0; DependsCount = 0; PackageFileCount = 0; + VerFileCount = 0; + ProvidesCount = 0; + MaxVerFileSize = 0; FileList = 0; StringList = 0; @@ -158,7 +161,8 @@ pkgCache::PkgIterator pkgCache::FindPkg(string Name) 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,0); @@ -202,14 +206,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 -{ - 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::UnInstalled || + Pkg->CurrentState == pkgCache::State::HalfInstalled || + Pkg->InstState != pkgCache::State::Ok) return NeedsUnpack; return NeedsNothing; @@ -221,8 +229,9 @@ pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const 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; } @@ -281,7 +290,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 - 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; @@ -297,7 +307,8 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets() 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++; @@ -311,7 +322,8 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets() 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++; @@ -335,6 +347,50 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets() 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 @@ -358,6 +414,60 @@ int pkgCache::VerIterator::CompareVer(const VerIterator &B) const 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 ""; +} + /*}}}*/ +// 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