Browse Source

Refactor the cache iterators by using a common base class

This should not change the public interface, but it removes the
friend connection between the iterators and pkgcache as it is unused.
debian/1.8.y
David Kalnischkies 13 years ago
parent
commit
773e2c1fe5
  1. 673
      apt-pkg/cacheiterators.h
  2. 56
      apt-pkg/pkgcache.cc
  3. 9
      apt-pkg/pkgcache.h

673
apt-pkg/cacheiterators.h

@ -1,6 +1,5 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: cacheiterators.h,v 1.18.2.1 2004/05/08 22:44:27 mdz Exp $
/* ######################################################################
Cache Iterators - Iterators for navigating the cache structure
@ -30,417 +29,333 @@
/*}}}*/
#ifndef PKGLIB_CACHEITERATORS_H
#define PKGLIB_CACHEITERATORS_H
// abstract Iterator template /*{{{*/
/* This template provides the very basic iterator methods we
need to have for doing some walk-over-the-cache magic, */
template<typename Str, typename Itr> class pkgCache::Iterator {
__attribute__ ((deprecated)) void _dummy(); // FIXME: Who on earth uses this method ???
protected:
Str *S;
pkgCache *Owner;
/** \brief Returns the Pointer for this struct in the owner
* The implementation of this method should be pretty short
* as it will only return the Pointer into the mmap stored
* in the owner but the name of this pointer is different for
* each stucture and we want to abstract here at least for the
* basic methods from the actual structure.
* \return Pointer to the first structure of this type
*/
virtual Str* OwnerPointer() const = 0;
public:
// Iteration
virtual void operator ++(int) = 0;
virtual void operator ++() = 0; // Should be {operator ++(0);};
inline bool end() const {return Owner == 0 || S == OwnerPointer();};
// Comparison
inline bool operator ==(const Itr &B) const {return S == B.S;};
inline bool operator !=(const Itr &B) const {return S != B.S;};
// Accessors
inline Str *operator ->() {return S;};
inline Str const *operator ->() const {return S;};
inline operator Str *() {return S == OwnerPointer() ? 0 : S;};
inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;};
inline Str const &operator *() const {return *S;};
inline pkgCache *Cache() {return Owner;};
// Mixed stuff
inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;};
inline bool IsGood() const { return S && Owner && ! end();};
inline unsigned long Index() const {return S - OwnerPointer();};
// Constructors - look out for the variable assigning
inline Iterator() : S(0), Owner(0) {};
inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {};
};
/*}}}*/
// Package Iterator /*{{{*/
class pkgCache::PkgIterator
{
friend class pkgCache;
Package *Pkg;
pkgCache *Owner;
long HashIndex;
protected:
// This constructor is the 'begin' constructor, never use it.
inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
{
Pkg = Owner.PkgP;
operator ++(0);
};
public:
enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
// Iteration
void operator ++(int);
inline void operator ++() {operator ++(0);};
inline bool end() const {return Owner == 0 || Pkg == Owner->PkgP?true:false;};
// Comparison
inline bool operator ==(const PkgIterator &B) const {return Pkg == B.Pkg;};
inline bool operator !=(const PkgIterator &B) const {return Pkg != B.Pkg;};
// Accessors
inline Package *operator ->() {return Pkg;};
inline Package const *operator ->() const {return Pkg;};
inline Package const &operator *() const {return *Pkg;};
inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
inline pkgCache *Cache() {return Owner;};
inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
inline bool Purge() const {return Pkg->CurrentState == pkgCache::State::Purge ||
(Pkg->CurrentVer == 0 && Pkg->CurrentState == pkgCache::State::NotInstalled);};
inline VerIterator VersionList() const;
inline VerIterator CurrentVer() const;
inline DepIterator RevDependsList() const;
inline PrvIterator ProvidesList() const;
inline unsigned long Index() const {return Pkg - Owner->PkgP;};
OkState State() const;
//Nice printable representation
friend std::ostream& operator<<(std::ostream& out, pkgCache::PkgIterator Pkg);
const char *CandVersion() const;
const char *CurVersion() const;
// Constructors
inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
HashIndex(0)
{
if (Pkg == 0)
Pkg = Owner.PkgP;
};
inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
long HashIndex;
protected:
inline Package* OwnerPointer() const {
return Owner->PkgP;
};
public:
// This constructor is the 'begin' constructor, never use it.
inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
S = OwnerPointer();
operator ++(0);
};
virtual void operator ++(int);
virtual void operator ++() {operator ++(0);};
enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
// Accessors
inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
(S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);};
inline VerIterator VersionList() const;
inline VerIterator CurrentVer() const;
inline DepIterator RevDependsList() const;
inline PrvIterator ProvidesList() const;
OkState State() const;
const char *CandVersion() const;
const char *CurVersion() const;
//Nice printable representation
friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
// Constructors
inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
if (S == 0)
S = OwnerPointer();
};
inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
};
/*}}}*/
// Version Iterator /*{{{*/
class pkgCache::VerIterator
{
Version *Ver;
pkgCache *Owner;
void _dummy();
public:
// Iteration
void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
inline void operator ++() {operator ++(0);};
inline bool end() const {return Owner == 0 || (Ver == Owner->VerP?true:false);};
inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
// Comparison
inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
int CompareVer(const VerIterator &B) const;
// Testing
inline bool IsGood() const { return Ver && Owner && ! end();};
// Accessors
inline Version *operator ->() {return Ver;};
inline Version const *operator ->() const {return Ver;};
inline Version &operator *() {return *Ver;};
inline Version const &operator *() const {return *Ver;};
inline operator Version *() {return Ver == Owner->VerP?0:Ver;};
inline operator Version const *() const {return Ver == Owner->VerP?0:Ver;};
inline pkgCache *Cache() {return Owner;};
inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner->StrP + Ver->VerStr;};
inline const char *Section() const {return Ver->Section == 0?0:Owner->StrP + Ver->Section;};
inline const char *Arch() const {return Ver->Arch == 0?0:Owner->StrP + Ver->Arch;};
inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Ver->ParentPkg);};
inline DescIterator DescriptionList() const;
DescIterator TranslatedDescription() const;
inline DepIterator DependsList() const;
inline PrvIterator ProvidesList() const;
inline VerFileIterator FileList() const;
inline unsigned long Index() const {return Ver - Owner->VerP;};
bool Downloadable() const;
inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
string RelStr();
bool Automatic() const;
VerFileIterator NewestFile() const;
inline VerIterator() : Ver(0), Owner(0) {};
inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg),
Owner(&Owner)
{
if (Ver == 0)
Ver = Owner.VerP;
};
class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
protected:
inline Version* OwnerPointer() const {
return Owner->VerP;
};
public:
// Iteration
void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
inline void operator ++() {operator ++(0);};
// Comparison
int CompareVer(const VerIterator &B) const;
// Accessors
inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;};
inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;};
inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
inline DescIterator DescriptionList() const;
DescIterator TranslatedDescription() const;
inline DepIterator DependsList() const;
inline PrvIterator ProvidesList() const;
inline VerFileIterator FileList() const;
bool Downloadable() const;
inline const char *PriorityType() {return Owner->Priority(S->Priority);};
string RelStr();
bool Automatic() const;
VerFileIterator NewestFile() const;
inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
if (S == 0)
S = OwnerPointer();
};
inline VerIterator() : Iterator<Version, VerIterator>() {};
};
/*}}}*/
// Description Iterator /*{{{*/
class pkgCache::DescIterator
{
Description *Desc;
pkgCache *Owner;
void _dummy();
public:
// Iteration
void operator ++(int) {if (Desc != Owner->DescP) Desc = Owner->DescP + Desc->NextDesc;};
inline void operator ++() {operator ++(0);};
inline bool end() const {return Owner == 0 || Desc == Owner->DescP?true:false;};
inline void operator =(const DescIterator &B) {Desc = B.Desc; Owner = B.Owner;};
// Comparison
inline bool operator ==(const DescIterator &B) const {return Desc == B.Desc;};
inline bool operator !=(const DescIterator &B) const {return Desc != B.Desc;};
int CompareDesc(const DescIterator &B) const;
// Accessors
inline Description *operator ->() {return Desc;};
inline Description const *operator ->() const {return Desc;};
inline Description &operator *() {return *Desc;};
inline Description const &operator *() const {return *Desc;};
inline operator Description *() {return Desc == Owner->DescP?0:Desc;};
inline operator Description const *() const {return Desc == Owner->DescP?0:Desc;};
inline pkgCache *Cache() {return Owner;};
inline const char *LanguageCode() const {return Owner->StrP + Desc->language_code;};
inline const char *md5() const {return Owner->StrP + Desc->md5sum;};
inline DescFileIterator FileList() const;
inline unsigned long Index() const {return Desc - Owner->DescP;};
inline DescIterator() : Desc(0), Owner(0) {};
inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Desc(Trg),
Owner(&Owner)
{
if (Desc == 0)
Desc = Owner.DescP;
};
class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
protected:
inline Description* OwnerPointer() const {
return Owner->DescP;
};
public:
// Iteration
void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
inline void operator ++() {operator ++(0);};
// Comparison
int CompareDesc(const DescIterator &B) const;
// Accessors
inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
inline const char *md5() const {return Owner->StrP + S->md5sum;};
inline DescFileIterator FileList() const;
inline DescIterator() : Iterator<Description, DescIterator>() {};
inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
if (S == 0)
S = Owner.DescP;
};
};
/*}}}*/
// Dependency iterator /*{{{*/
class pkgCache::DepIterator
{
Dependency *Dep;
enum {DepVer, DepRev} Type;
pkgCache *Owner;
void _dummy();
public:
// Iteration
void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
(Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
inline void operator ++() {operator ++(0);};
inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
// Comparison
inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
// Accessors
inline Dependency *operator ->() {return Dep;};
inline Dependency const *operator ->() const {return Dep;};
inline Dependency &operator *() {return *Dep;};
inline Dependency const &operator *() const {return *Dep;};
inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
inline pkgCache *Cache() {return Owner;};
inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
inline bool Reverse() {return Type == DepRev;};
inline unsigned long Index() const {return Dep - Owner->DepP;};
bool IsCritical();
void GlobOr(DepIterator &Start,DepIterator &End);
Version **AllTargets();
bool SmartTargetPkg(PkgIterator &Result);
inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
inline const char *DepType() {return Owner->DepType(Dep->Type);};
inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
Dep(Trg), Type(DepVer), Owner(&Owner)
{
if (Dep == 0)
Dep = Owner.DepP;
};
inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
Dep(Trg), Type(DepRev), Owner(&Owner)
{
if (Dep == 0)
Dep = Owner.DepP;
};
inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
enum {DepVer, DepRev} Type;
protected:
inline Dependency* OwnerPointer() const {
return Owner->DepP;
};
public:
// Iteration
void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
(Type == DepVer ? S->NextDepends : S->NextRevDepends);};
inline void operator ++() {operator ++(0);};
// Accessors
inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
inline bool Reverse() {return Type == DepRev;};
bool IsCritical();
void GlobOr(DepIterator &Start,DepIterator &End);
Version **AllTargets();
bool SmartTargetPkg(PkgIterator &Result);
inline const char *CompType() {return Owner->CompType(S->CompareOp);};
inline const char *DepType() {return Owner->DepType(S->Type);};
inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
if (S == 0)
S = Owner.DepP;
};
inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
if (S == 0)
S = Owner.DepP;
};
inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
};
/*}}}*/
// Provides iterator /*{{{*/
class pkgCache::PrvIterator
{
Provides *Prv;
enum {PrvVer, PrvPkg} Type;
pkgCache *Owner;
void _dummy();
public:
// Iteration
void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
(Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
inline void operator ++() {operator ++(0);};
inline bool end() const {return Owner == 0 || Prv == Owner->ProvideP?true:false;};
// Comparison
inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
// Accessors
inline Provides *operator ->() {return Prv;};
inline Provides const *operator ->() const {return Prv;};
inline Provides &operator *() {return *Prv;};
inline Provides const &operator *() const {return *Prv;};
inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
inline pkgCache *Cache() {return Owner;};
inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
inline unsigned long Index() const {return Prv - Owner->ProvideP;};
inline PrvIterator() : Prv(0), Type(PrvVer), Owner(0) {};
inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
Prv(Trg), Type(PrvVer), Owner(&Owner)
{
if (Prv == 0)
Prv = Owner.ProvideP;
};
inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) :
Prv(Trg), Type(PrvPkg), Owner(&Owner)
{
if (Prv == 0)
Prv = Owner.ProvideP;
};
class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
enum {PrvVer, PrvPkg} Type;
protected:
inline Provides* OwnerPointer() const {
return Owner->ProvideP;
};
public:
// Iteration
void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
(Type == PrvVer?S->NextPkgProv:S->NextProvides);};
inline void operator ++() {operator ++(0);};
// Accessors
inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + S->Version);};
inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};
inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
if (S == 0)
S = Owner.ProvideP;
};
inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
if (S == 0)
S = Owner.ProvideP;
};
};
/*}}}*/
// Package file /*{{{*/
class pkgCache::PkgFileIterator
{
pkgCache *Owner;
PackageFile *File;
public:
// Iteration
void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
inline void operator ++() {operator ++(0);};
inline bool end() const {return Owner == 0 || File == Owner->PkgFileP?true:false;};
// Comparison
inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
// Accessors
inline PackageFile *operator ->() {return File;};
inline PackageFile const *operator ->() const {return File;};
inline PackageFile const &operator *() const {return *File;};
inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
inline pkgCache *Cache() {return Owner;};
inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
inline const char *Codename() const {return File->Codename ==0?0:Owner->StrP + File->Codename;};
inline const char *Label() const {return File->Label == 0?0:Owner->StrP + File->Label;};
inline const char *Site() const {return File->Site == 0?0:Owner->StrP + File->Site;};
inline const char *Architecture() const {return File->Architecture == 0?0:Owner->StrP + File->Architecture;};
inline const char *IndexType() const {return File->IndexType == 0?0:Owner->StrP + File->IndexType;};
inline unsigned long Index() const {return File - Owner->PkgFileP;};
bool IsOk();
string RelStr();
// Constructors
inline PkgFileIterator() : Owner(0), File(0) {};
inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
protected:
inline PackageFile* OwnerPointer() const {
return Owner->PkgFileP;
};
public:
// Iteration
void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
inline void operator ++() {operator ++(0);};
// Accessors
inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
bool IsOk();
string RelStr();
// Constructors
inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg = 0) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
};
/*}}}*/
// Version File /*{{{*/
class pkgCache::VerFileIterator
{
pkgCache *Owner;
VerFile *FileP;
public:
// Iteration
void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
inline void operator ++() {operator ++(0);};
inline bool end() const {return Owner == 0 || FileP == Owner->VerFileP?true:false;};
// Comparison
inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
// Accessors
inline VerFile *operator ->() {return FileP;};
inline VerFile const *operator ->() const {return FileP;};
inline VerFile const &operator *() const {return *FileP;};
inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
inline pkgCache *Cache() {return Owner;};
inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
inline unsigned long Index() const {return FileP - Owner->VerFileP;};
inline VerFileIterator() : Owner(0), FileP(0) {};
inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
protected:
inline VerFile* OwnerPointer() const {
return Owner->VerFileP;
};
public:
// Iteration
void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
inline void operator ++() {operator ++(0);};
// Accessors
inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
};
/*}}}*/
// Description File /*{{{*/
class pkgCache::DescFileIterator
{
pkgCache *Owner;
DescFile *FileP;
public:
// Iteration
void operator ++(int) {if (FileP != Owner->DescFileP) FileP = Owner->DescFileP + FileP->NextFile;};
inline void operator ++() {operator ++(0);};
inline bool end() const {return Owner == 0 || FileP == Owner->DescFileP?true:false;};
// Comparison
inline bool operator ==(const DescFileIterator &B) const {return FileP == B.FileP;};
inline bool operator !=(const DescFileIterator &B) const {return FileP != B.FileP;};
// Accessors
inline DescFile *operator ->() {return FileP;};
inline DescFile const *operator ->() const {return FileP;};
inline DescFile const &operator *() const {return *FileP;};
inline operator DescFile *() {return FileP == Owner->DescFileP?0:FileP;};
inline operator DescFile const *() const {return FileP == Owner->DescFileP?0:FileP;};
inline pkgCache *Cache() {return Owner;};
inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
inline unsigned long Index() const {return FileP - Owner->DescFileP;};
inline DescFileIterator() : Owner(0), FileP(0) {};
inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Owner(&Owner), FileP(Trg) {};
class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
protected:
inline DescFile* OwnerPointer() const {
return Owner->DescFileP;
};
public:
// Iteration
void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
inline void operator ++() {operator ++(0);};
// Accessors
inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
};
/*}}}*/
// Inlined Begin functions cant be in the class because of order problems /*{{{*/
inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
{return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
{return VerIterator(*Owner,Owner->VerP + S->VersionList);};
inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
{return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
{return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
{return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
{return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
{return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
{return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
{return DescIterator(*Owner,Owner->DescP + Ver->DescriptionList);};
{return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
{return PrvIterator(*Owner,Owner->ProvideP + Ver->ProvidesList,Ver);};
{return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
{return DepIterator(*Owner,Owner->DepP + Ver->DependsList,Ver);};
{return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
{return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);};
{return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
{return DescFileIterator(*Owner,Owner->DescFileP + Desc->FileList);};
{return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
/*}}}*/
#endif

56
apt-pkg/pkgcache.cc

@ -242,26 +242,20 @@ const char *pkgCache::Priority(unsigned char Prio)
return 0;
}
/*}}}*/
// Bases for iterator classes /*{{{*/
void pkgCache::VerIterator::_dummy() {}
void pkgCache::DepIterator::_dummy() {}
void pkgCache::PrvIterator::_dummy() {}
void pkgCache::DescIterator::_dummy() {}
/*}}}*/
// PkgIterator::operator ++ - Postfix incr /*{{{*/
// ---------------------------------------------------------------------
/* This will advance to the next logical package in the hash table. */
void pkgCache::PkgIterator::operator ++(int)
{
// Follow the current links
if (Pkg != Owner->PkgP)
Pkg = Owner->PkgP + Pkg->NextPackage;
if (S != Owner->PkgP)
S = Owner->PkgP + S->NextPackage;
// Follow the hash table
while (Pkg == Owner->PkgP && (HashIndex+1) < (signed)_count(Owner->HeaderP->HashTable))
while (S == Owner->PkgP && (HashIndex+1) < (signed)_count(Owner->HeaderP->HashTable))
{
HashIndex++;
Pkg = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex];
S = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex];
}
};
/*}}}*/
@ -270,12 +264,12 @@ 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->InstState == pkgCache::State::ReInstReq ||
Pkg->InstState == pkgCache::State::HoldReInstReq)
if (S->InstState == pkgCache::State::ReInstReq ||
S->InstState == pkgCache::State::HoldReInstReq)
return NeedsUnpack;
if (Pkg->CurrentState == pkgCache::State::UnPacked ||
Pkg->CurrentState == pkgCache::State::HalfConfigured)
if (S->CurrentState == pkgCache::State::UnPacked ||
S->CurrentState == pkgCache::State::HalfConfigured)
// we leave triggers alone complettely. dpkg deals with
// them in a hard-to-predict manner and if they get
// resolved by dpkg before apt run dpkg --configure on
@ -284,8 +278,8 @@ pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
//Pkg->CurrentState == pkgCache::State::TriggersPending)
return NeedsConfigure;
if (Pkg->CurrentState == pkgCache::State::HalfInstalled ||
Pkg->InstState != pkgCache::State::Ok)
if (S->CurrentState == pkgCache::State::HalfInstalled ||
S->InstState != pkgCache::State::Ok)
return NeedsUnpack;
return NeedsNothing;
@ -347,11 +341,11 @@ operator<<(ostream& out, pkgCache::PkgIterator Pkg)
conflicts (including dpkg's Breaks fields). */
bool pkgCache::DepIterator::IsCritical()
{
if (Dep->Type == pkgCache::Dep::Conflicts ||
Dep->Type == pkgCache::Dep::DpkgBreaks ||
Dep->Type == pkgCache::Dep::Obsoletes ||
Dep->Type == pkgCache::Dep::Depends ||
Dep->Type == pkgCache::Dep::PreDepends)
if (S->Type == pkgCache::Dep::Conflicts ||
S->Type == pkgCache::Dep::DpkgBreaks ||
S->Type == pkgCache::Dep::Obsoletes ||
S->Type == pkgCache::Dep::Depends ||
S->Type == pkgCache::Dep::PreDepends)
return true;
return false;
}
@ -430,12 +424,12 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
// Walk along the actual package providing versions
for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)
{
if (Owner->VS->CheckDep(I.VerStr(),Dep->CompareOp,TargetVer()) == false)
if (Owner->VS->CheckDep(I.VerStr(),S->CompareOp,TargetVer()) == false)
continue;
if ((Dep->Type == pkgCache::Dep::Conflicts ||
Dep->Type == pkgCache::Dep::DpkgBreaks ||
Dep->Type == pkgCache::Dep::Obsoletes) &&
if ((S->Type == pkgCache::Dep::Conflicts ||
S->Type == pkgCache::Dep::DpkgBreaks ||
S->Type == pkgCache::Dep::Obsoletes) &&
ParentPkg() == I.ParentPkg())
continue;
@ -447,12 +441,12 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
// Follow all provides
for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)
{
if (Owner->VS->CheckDep(I.ProvideVersion(),Dep->CompareOp,TargetVer()) == false)
if (Owner->VS->CheckDep(I.ProvideVersion(),S->CompareOp,TargetVer()) == false)
continue;
if ((Dep->Type == pkgCache::Dep::Conflicts ||
Dep->Type == pkgCache::Dep::DpkgBreaks ||
Dep->Type == pkgCache::Dep::Obsoletes) &&
if ((S->Type == pkgCache::Dep::Conflicts ||
S->Type == pkgCache::Dep::DpkgBreaks ||
S->Type == pkgCache::Dep::Obsoletes) &&
ParentPkg() == I.OwnerPkg())
continue;
@ -490,7 +484,7 @@ void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
End = *this;
for (bool LastOR = true; end() == false && LastOR == true;)
{
LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
LastOR = (S->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
(*this)++;
if (LastOR == true)
End = (*this);
@ -640,7 +634,7 @@ bool pkgCache::PkgFileIterator::IsOk()
if (stat(FileName(),&Buf) != 0)
return false;
if (Buf.st_size != (signed)File->Size || Buf.st_mtime != File->mtime)
if (Buf.st_size != (signed)S->Size || Buf.st_mtime != S->mtime)
return false;
return true;

9
apt-pkg/pkgcache.h

@ -43,6 +43,7 @@ class pkgCache /*{{{*/
struct DescFile;
// Iterators
template<typename Str, typename Itr> class Iterator;
class PkgIterator;
class VerIterator;
class DescIterator;
@ -51,14 +52,6 @@ class pkgCache /*{{{*/
class PkgFileIterator;
class VerFileIterator;
class DescFileIterator;
friend class PkgIterator;
friend class VerIterator;
friend class DescInterator;
friend class DepIterator;
friend class PrvIterator;
friend class PkgFileIterator;
friend class VerFileIterator;
friend class DescFileIterator;
class Namespace;

Loading…
Cancel
Save