[ntk/apt.git] / apt-pkg / cacheiterators.h

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: cacheiterators.h,v 1.12 1999/02/01 02:22:11 jgg Exp $
/* ######################################################################
   
   Cache Iterators - Iterators for navigating the cache structure
   
   The iterators all provides ++,==,!=,->,* and end for their type.
   The end function can be used to tell if the list has been fully
   traversed.
   
   Unlike STL iterators these contain helper functions to access the data
   that is being iterated over. This is because the data structures can't
   be formed in a manner that is intuitive to use and also mmapable.
   
   For each variable in the target structure that would need a translation
   to be accessed correctly a translating function of the same name is
   present in the iterator. If applicable the translating function will
   return an iterator.

   The DepIterator can iterate over two lists, a list of 'version depends'
   or a list of 'package reverse depends'. The type is determined by the
   structure passed to the constructor, which should be the structure
   that has the depends pointer as a member. The provide iterator has the
   same system.
   
   This header is not user includable, please use apt-pkg/pkgcache.h
   
   ##################################################################### */
									/*}}}*/
// Header section: pkglib
#ifndef PKGLIB_CACHEITERATORS_H
#define PKGLIB_CACHEITERATORS_H

#ifdef __GNUG__
#pragma interface "apt-pkg/cacheiterators.h"
#endif 

// Package Iterator
class pkgCache::PkgIterator
{
   Package *Pkg;
   pkgCache *Owner;
   long HashIndex;

   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 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 const char *TargetDist() const {return Pkg->TargetDist == 0?0:Owner->StrP + Pkg->TargetDist;};
   inline VerIterator VersionList() const;
   inline VerIterator TargetVer() 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;
   
   // Constructors
   inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
   {
      Pkg = Owner.PkgP;
      operator ++(0);
   };
   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) {};
};

// 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 Ver == Owner.VerP?true:false;};
   inline void operator =(const VerIterator &B) {Ver = B.Ver;};
   
   // 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;
   
   // 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 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 DepIterator DependsList() const;
   inline PrvIterator ProvidesList() const;
   inline VerFileIterator FileList() const;
   inline unsigned long Index() const {return Ver - Owner.VerP;};
   bool Downloadable() const;
   const char *PriorityType();

   bool Automatic() const;
   VerFileIterator NewestFile() const;
      
   inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), Owner(Owner) 
   { 
      if (Ver == 0)
	 Ver = Owner.VerP;
   };
};

// 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 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);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);
   const char *CompType();
   const char *DepType();
   
   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) {};
};

// 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 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 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(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;
   };
};

// 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 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 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 *Label() const {return File->Origin == 0?0:Owner->StrP + File->Label;};
   inline const char *Architecture() const {return File->Origin == 0?0:Owner->StrP + File->Architecture;};

   inline unsigned long Index() const {return File - Owner->PkgFileP;};

   bool IsOk();
   
   // Constructors
   inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP + Owner.Head().FileList) {};
   inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(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 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 PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
   inline unsigned long Index() const {return FileP - Owner->VerFileP;};
      
   inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(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);};
inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
       {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
inline pkgCache::VerIterator pkgCache::PkgIterator::TargetVer() const
       {return VerIterator(*Owner,Owner->VerP + Pkg->TargetVer);};
inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
       {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
       {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
       {return PrvIterator(Owner,Owner.ProvideP + Ver->ProvidesList,Ver);};
inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
       {return DepIterator(Owner,Owner.DepP + Ver->DependsList,Ver);};
inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
       {return VerFileIterator(Owner,Owner.VerFileP + Ver->FileList);};

#endif
Commit	Line	Data
578bfd0a AL	1	// -- mode: cpp; mode: fold --
578bfd0a AL	2	// Description /{{{/
17caf1b1	3	// $Id: cacheiterators.h,v 1.12 1999/02/01 02:22:11 jgg Exp $
578bfd0a AL	4	/* ######################################################################
	5
	6	Cache Iterators - Iterators for navigating the cache structure
	7
	8	The iterators all provides ++,==,!=,->,* and end for their type.
	9	The end function can be used to tell if the list has been fully
	10	traversed.
	11
	12	Unlike STL iterators these contain helper functions to access the data
	13	that is being iterated over. This is because the data structures can't
	14	be formed in a manner that is intuitive to use and also mmapable.
	15
	16	For each variable in the target structure that would need a translation
	17	to be accessed correctly a translating function of the same name is
	18	present in the iterator. If applicable the translating function will
	19	return an iterator.
	20
	21	The DepIterator can iterate over two lists, a list of 'version depends'
	22	or a list of 'package reverse depends'. The type is determined by the
	23	structure passed to the constructor, which should be the structure
6c139d6e AL	24	that has the depends pointer as a member. The provide iterator has the
6c139d6e AL	25	same system.
578bfd0a	26
094a497d	27	This header is not user includable, please use apt-pkg/pkgcache.h
578bfd0a AL	28
	29	##################################################################### */
	30	/}}}/
	31	// Header section: pkglib
	32	#ifndef PKGLIB_CACHEITERATORS_H
	33	#define PKGLIB_CACHEITERATORS_H
	34
6c139d6e	35	#ifdef __GNUG__
094a497d	36	#pragma interface "apt-pkg/cacheiterators.h"
6c139d6e AL	37	#endif
6c139d6e AL	38
578bfd0a AL	39	// Package Iterator
	40	class pkgCache::PkgIterator
	41	{
	42	Package *Pkg;
	43	pkgCache *Owner;
	44	long HashIndex;
	45
	46	public:
	47
	48	enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
	49
	50	// Iteration
	51	void operator ++(int);
	52	inline void operator ++() {operator ++(0);};
	53	inline bool end() const {return Owner == 0 \|\| Pkg == Owner->PkgP?true:false;};
	54
	55	// Comparison
	56	inline bool operator ==(const PkgIterator &B) const {return Pkg == B.Pkg;};
	57	inline bool operator !=(const PkgIterator &B) const {return Pkg != B.Pkg;};
	58
	59	// Accessors
	60	inline Package *operator ->() {return Pkg;};
	61	inline Package const *operator ->() const {return Pkg;};
	62	inline Package const &operator () const {return Pkg;};
	63	inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
	64	inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
6c139d6e	65
578bfd0a AL	66	inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
	67	inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
	68	inline const char *TargetDist() const {return Pkg->TargetDist == 0?0:Owner->StrP + Pkg->TargetDist;};
	69	inline VerIterator VersionList() const;
	70	inline VerIterator TargetVer() const;
	71	inline VerIterator CurrentVer() const;
	72	inline DepIterator RevDependsList() const;
	73	inline PrvIterator ProvidesList() const;
f55a958f	74	inline unsigned long Index() const {return Pkg - Owner->PkgP;};
578bfd0a AL	75	OkState State() const;
	76
	77	// Constructors
	78	inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
	79	{
	80	Pkg = Owner.PkgP;
	81	operator ++(0);
	82	};
	83	inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
	84	HashIndex(0)
	85	{
	86	if (Pkg == 0)
	87	Pkg = Owner.PkgP;
	88	};
	89	inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
	90	};
	91
	92	// Version Iterator
	93	class pkgCache::VerIterator
	94	{
	95	Version *Ver;
	96	pkgCache &Owner;
	97
	98	void _dummy();
	99
	100	public:
	101
	102	// Iteration
	103	void operator ++(int) {if (Ver != Owner.VerP) Ver = Owner.VerP + Ver->NextVer;};
	104	inline void operator ++() {operator ++(0);};
	105	inline bool end() const {return Ver == Owner.VerP?true:false;};
	106	inline void operator =(const VerIterator &B) {Ver = B.Ver;};
	107
	108	// Comparison
	109	inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
	110	inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
	111	int CompareVer(const VerIterator &B) const;
	112
	113	// Accessors
	114	inline Version *operator ->() {return Ver;};
	115	inline Version const *operator ->() const {return Ver;};
	116	inline Version &operator () {return Ver;};
	117	inline Version const &operator () const {return Ver;};
	118	inline operator Version *() {return Ver == Owner.VerP?0:Ver;};
	119	inline operator Version const *() const {return Ver == Owner.VerP?0:Ver;};
c9807169	120
578bfd0a AL	121	inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner.StrP + Ver->VerStr;};
578bfd0a AL	122	inline const char *Section() const {return Ver->Section == 0?0:Owner.StrP + Ver->Section;};
17caf1b1	123	inline const char *Arch() const {return Ver->Arch == 0?0:Owner.StrP + Ver->Arch;};
578bfd0a AL	124	inline PkgIterator ParentPkg() const {return PkgIterator(Owner,Owner.PkgP + Ver->ParentPkg);};
	125	inline DepIterator DependsList() const;
	126	inline PrvIterator ProvidesList() const;
dcb79bae	127	inline VerFileIterator FileList() const;
6c139d6e	128	inline unsigned long Index() const {return Ver - Owner.VerP;};
b518cca6	129	bool Downloadable() const;
c9807169	130	const char *PriorityType();
3c124dde AL	131
	132	bool Automatic() const;
	133	VerFileIterator NewestFile() const;
	134
f55a958f	135	inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), Owner(Owner)
578bfd0a AL	136	{
	137	if (Ver == 0)
	138	Ver = Owner.VerP;
	139	};
	140	};
	141
	142	// Dependency iterator
	143	class pkgCache::DepIterator
	144	{
	145	Dependency *Dep;
	146	enum {DepVer, DepRev} Type;
	147	pkgCache *Owner;
	148
	149	void _dummy();
	150
	151	public:
	152
	153	// Iteration
	154	void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
	155	(Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
	156	inline void operator ++() {operator ++(0);};
	157	inline bool end() const {return Owner == 0 \|\| Dep == Owner->DepP?true:false;};
	158
	159	// Comparison
	160	inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
	161	inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
	162
	163	// Accessors
	164	inline Dependency *operator ->() {return Dep;};
	165	inline Dependency const *operator ->() const {return Dep;};
	166	inline Dependency &operator () {return Dep;};
	167	inline Dependency const &operator () const {return Dep;};
	168	inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
	169	inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
6c139d6e	170
578bfd0a AL	171	inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
578bfd0a AL	172	inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
578bfd0a AL	173	inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner);SmartTargetPkg(R);return R;};
	174	inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
	175	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
578bfd0a	176	inline bool Reverse() {return Type == DepRev;};
f55a958f	177	inline unsigned long Index() const {return Dep - Owner->DepP;};
6c139d6e	178	bool IsCritical();
43d017d6	179	void GlobOr(DepIterator &Start,DepIterator &End);
6c139d6e AL	180	Version **AllTargets();
6c139d6e AL	181	bool SmartTargetPkg(PkgIterator &Result);
0a8e3465	182	const char *CompType();
43d017d6	183	const char *DepType();
0a8e3465	184
578bfd0a AL	185	inline DepIterator(pkgCache &Owner,Dependency Trg,Version = 0) :
	186	Dep(Trg), Type(DepVer), Owner(&Owner)
	187	{
	188	if (Dep == 0)
	189	Dep = Owner.DepP;
	190	};
	191	inline DepIterator(pkgCache &Owner,Dependency Trg,Package ) :
	192	Dep(Trg), Type(DepRev), Owner(&Owner)
	193	{
	194	if (Dep == 0)
	195	Dep = Owner.DepP;
	196	};
	197	inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
	198	};
	199
	200	// Provides iterator
	201	class pkgCache::PrvIterator
	202	{
	203	Provides *Prv;
	204	enum {PrvVer, PrvPkg} Type;
	205	pkgCache *Owner;
	206
	207	void _dummy();
	208
	209	public:
	210
	211	// Iteration
	212	void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
	213	(Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
	214	inline void operator ++() {operator ++(0);};
	215	inline bool end() const {return Prv == Owner->ProvideP?true:false;};
	216
	217	// Comparison
	218	inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
	219	inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
	220
	221	// Accessors
	222	inline Provides *operator ->() {return Prv;};
	223	inline Provides const *operator ->() const {return Prv;};
	224	inline Provides &operator () {return Prv;};
	225	inline Provides const &operator () const {return Prv;};
	226	inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
	227	inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
6c139d6e	228
578bfd0a AL	229	inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
	230	inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
	231	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
	232	inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
	233	inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
f55a958f	234	inline unsigned long Index() const {return Prv - Owner->ProvideP;};
578bfd0a AL	235
	236	inline PrvIterator(pkgCache &Owner,Provides Trg,Version ) :
	237	Prv(Trg), Type(PrvVer), Owner(&Owner)
	238	{
	239	if (Prv == 0)
	240	Prv = Owner.ProvideP;
	241	};
	242	inline PrvIterator(pkgCache &Owner,Provides Trg,Package ) :
	243	Prv(Trg), Type(PrvPkg), Owner(&Owner)
	244	{
	245	if (Prv == 0)
	246	Prv = Owner.ProvideP;
	247	};
	248	};
	249
	250	// Package file
	251	class pkgCache::PkgFileIterator
	252	{
	253	pkgCache *Owner;
	254	PackageFile *File;
	255
	256	public:
	257
	258	// Iteration
	259	void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
	260	inline void operator ++() {operator ++(0);};
	261	inline bool end() const {return File == Owner->PkgFileP?true:false;};
	262
	263	// Comparison
	264	inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
	265	inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
	266
	267	// Accessors
	268	inline PackageFile *operator ->() {return File;};
	269	inline PackageFile const *operator ->() const {return File;};
	270	inline PackageFile const &operator () const {return File;};
	271	inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
	272	inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
	273
	274	inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
b0b4efb9 AL	275	inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
b0b4efb9 AL	276	inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
578bfd0a	277	inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
b0b4efb9 AL	278	inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
	279	inline const char *Label() const {return File->Origin == 0?0:Owner->StrP + File->Label;};
	280	inline const char *Architecture() const {return File->Origin == 0?0:Owner->StrP + File->Architecture;};
	281
f55a958f	282	inline unsigned long Index() const {return File - Owner->PkgFileP;};
578bfd0a AL	283
	284	bool IsOk();
	285
	286	// Constructors
	287	inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP + Owner.Head().FileList) {};
	288	inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
	289	};
	290
dcb79bae AL	291	// Version File
	292	class pkgCache::VerFileIterator
	293	{
	294	pkgCache *Owner;
	295	VerFile *FileP;
	296
	297	public:
	298
	299	// Iteration
	300	void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
	301	inline void operator ++() {operator ++(0);};
	302	inline bool end() const {return FileP == Owner->VerFileP?true:false;};
	303
	304	// Comparison
	305	inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
	306	inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
	307
	308	// Accessors
	309	inline VerFile *operator ->() {return FileP;};
	310	inline VerFile const *operator ->() const {return FileP;};
	311	inline VerFile const &operator () const {return FileP;};
	312	inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
	313	inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
	314
	315	inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
	316	inline unsigned long Index() const {return FileP - Owner->VerFileP;};
b518cca6	317
dcb79bae AL	318	inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
	319	};
	320
578bfd0a AL	321	// Inlined Begin functions cant be in the class because of order problems
	322	inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
	323	{return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
	324	inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
	325	{return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
	326	inline pkgCache::VerIterator pkgCache::PkgIterator::TargetVer() const
	327	{return VerIterator(*Owner,Owner->VerP + Pkg->TargetVer);};
	328	inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
	329	{return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
	330	inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
	331	{return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
	332	inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
	333	{return PrvIterator(Owner,Owner.ProvideP + Ver->ProvidesList,Ver);};
	334	inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
	335	{return DepIterator(Owner,Owner.DepP + Ver->DependsList,Ver);};
dcb79bae AL	336	inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
dcb79bae AL	337	{return VerFileIterator(Owner,Owner.VerFileP + Ver->FileList);};
578bfd0a AL	338
578bfd0a AL	339	#endif