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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: cacheiterators.h,v 1.11 1998/12/14 08:07:28 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 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 /{{{/
3c124dde	3	// $Id: cacheiterators.h,v 1.11 1998/12/14 08:07:28 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;};
578bfd0a AL	123	inline PkgIterator ParentPkg() const {return PkgIterator(Owner,Owner.PkgP + Ver->ParentPkg);};
	124	inline DepIterator DependsList() const;
	125	inline PrvIterator ProvidesList() const;
dcb79bae	126	inline VerFileIterator FileList() const;
6c139d6e	127	inline unsigned long Index() const {return Ver - Owner.VerP;};
b518cca6	128	bool Downloadable() const;
c9807169	129	const char *PriorityType();
3c124dde AL	130
	131	bool Automatic() const;
	132	VerFileIterator NewestFile() const;
	133
f55a958f	134	inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), Owner(Owner)
578bfd0a AL	135	{
	136	if (Ver == 0)
	137	Ver = Owner.VerP;
	138	};
	139	};
	140
	141	// Dependency iterator
	142	class pkgCache::DepIterator
	143	{
	144	Dependency *Dep;
	145	enum {DepVer, DepRev} Type;
	146	pkgCache *Owner;
	147
	148	void _dummy();
	149
	150	public:
	151
	152	// Iteration
	153	void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
	154	(Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
	155	inline void operator ++() {operator ++(0);};
	156	inline bool end() const {return Owner == 0 \|\| Dep == Owner->DepP?true:false;};
	157
	158	// Comparison
	159	inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
	160	inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
	161
	162	// Accessors
	163	inline Dependency *operator ->() {return Dep;};
	164	inline Dependency const *operator ->() const {return Dep;};
	165	inline Dependency &operator () {return Dep;};
	166	inline Dependency const &operator () const {return Dep;};
	167	inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
	168	inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
6c139d6e	169
578bfd0a AL	170	inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
578bfd0a AL	171	inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
578bfd0a AL	172	inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner);SmartTargetPkg(R);return R;};
	173	inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
	174	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
578bfd0a	175	inline bool Reverse() {return Type == DepRev;};
f55a958f	176	inline unsigned long Index() const {return Dep - Owner->DepP;};
6c139d6e	177	bool IsCritical();
43d017d6	178	void GlobOr(DepIterator &Start,DepIterator &End);
6c139d6e AL	179	Version **AllTargets();
6c139d6e AL	180	bool SmartTargetPkg(PkgIterator &Result);
0a8e3465	181	const char *CompType();
43d017d6	182	const char *DepType();
0a8e3465	183
578bfd0a AL	184	inline DepIterator(pkgCache &Owner,Dependency Trg,Version = 0) :
	185	Dep(Trg), Type(DepVer), Owner(&Owner)
	186	{
	187	if (Dep == 0)
	188	Dep = Owner.DepP;
	189	};
	190	inline DepIterator(pkgCache &Owner,Dependency Trg,Package ) :
	191	Dep(Trg), Type(DepRev), Owner(&Owner)
	192	{
	193	if (Dep == 0)
	194	Dep = Owner.DepP;
	195	};
	196	inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
	197	};
	198
	199	// Provides iterator
	200	class pkgCache::PrvIterator
	201	{
	202	Provides *Prv;
	203	enum {PrvVer, PrvPkg} Type;
	204	pkgCache *Owner;
	205
	206	void _dummy();
	207
	208	public:
	209
	210	// Iteration
	211	void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
	212	(Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
	213	inline void operator ++() {operator ++(0);};
	214	inline bool end() const {return Prv == Owner->ProvideP?true:false;};
	215
	216	// Comparison
	217	inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
	218	inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
	219
	220	// Accessors
	221	inline Provides *operator ->() {return Prv;};
	222	inline Provides const *operator ->() const {return Prv;};
	223	inline Provides &operator () {return Prv;};
	224	inline Provides const &operator () const {return Prv;};
	225	inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
	226	inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
6c139d6e	227
578bfd0a AL	228	inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
	229	inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
	230	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
	231	inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
	232	inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
f55a958f	233	inline unsigned long Index() const {return Prv - Owner->ProvideP;};
578bfd0a AL	234
	235	inline PrvIterator(pkgCache &Owner,Provides Trg,Version ) :
	236	Prv(Trg), Type(PrvVer), Owner(&Owner)
	237	{
	238	if (Prv == 0)
	239	Prv = Owner.ProvideP;
	240	};
	241	inline PrvIterator(pkgCache &Owner,Provides Trg,Package ) :
	242	Prv(Trg), Type(PrvPkg), Owner(&Owner)
	243	{
	244	if (Prv == 0)
	245	Prv = Owner.ProvideP;
	246	};
	247	};
	248
	249	// Package file
	250	class pkgCache::PkgFileIterator
	251	{
	252	pkgCache *Owner;
	253	PackageFile *File;
	254
	255	public:
	256
	257	// Iteration
	258	void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
	259	inline void operator ++() {operator ++(0);};
	260	inline bool end() const {return File == Owner->PkgFileP?true:false;};
	261
	262	// Comparison
	263	inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
	264	inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
	265
	266	// Accessors
	267	inline PackageFile *operator ->() {return File;};
	268	inline PackageFile const *operator ->() const {return File;};
	269	inline PackageFile const &operator () const {return File;};
	270	inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
	271	inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
	272
	273	inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
b0b4efb9 AL	274	inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
b0b4efb9 AL	275	inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
578bfd0a	276	inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
b0b4efb9 AL	277	inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
	278	inline const char *Label() const {return File->Origin == 0?0:Owner->StrP + File->Label;};
	279	inline const char *Architecture() const {return File->Origin == 0?0:Owner->StrP + File->Architecture;};
	280
f55a958f	281	inline unsigned long Index() const {return File - Owner->PkgFileP;};
578bfd0a AL	282
	283	bool IsOk();
	284
	285	// Constructors
	286	inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP + Owner.Head().FileList) {};
	287	inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
	288	};
	289
dcb79bae AL	290	// Version File
	291	class pkgCache::VerFileIterator
	292	{
	293	pkgCache *Owner;
	294	VerFile *FileP;
	295
	296	public:
	297
	298	// Iteration
	299	void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
	300	inline void operator ++() {operator ++(0);};
	301	inline bool end() const {return FileP == Owner->VerFileP?true:false;};
	302
	303	// Comparison
	304	inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
	305	inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
	306
	307	// Accessors
	308	inline VerFile *operator ->() {return FileP;};
	309	inline VerFile const *operator ->() const {return FileP;};
	310	inline VerFile const &operator () const {return FileP;};
	311	inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
	312	inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
	313
	314	inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
	315	inline unsigned long Index() const {return FileP - Owner->VerFileP;};
b518cca6	316
dcb79bae AL	317	inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
	318	};
	319
578bfd0a AL	320	// Inlined Begin functions cant be in the class because of order problems
	321	inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
	322	{return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
	323	inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
	324	{return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
	325	inline pkgCache::VerIterator pkgCache::PkgIterator::TargetVer() const
	326	{return VerIterator(*Owner,Owner->VerP + Pkg->TargetVer);};
	327	inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
	328	{return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
	329	inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
	330	{return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
	331	inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
	332	{return PrvIterator(Owner,Owner.ProvideP + Ver->ProvidesList,Ver);};
	333	inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
	334	{return DepIterator(Owner,Owner.DepP + Ver->DependsList,Ver);};
dcb79bae AL	335	inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
dcb79bae AL	336	{return VerFileIterator(Owner,Owner.VerFileP + Ver->FileList);};
578bfd0a AL	337
578bfd0a AL	338	#endif