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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: cacheiterators.h,v 1.4 1998/07/07 04:17:00 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 pkglib/pkgcache.h
   
   ##################################################################### */
									/*}}}*/
// Header section: pkglib
#ifndef PKGLIB_CACHEITERATORS_H
#define PKGLIB_CACHEITERATORS_H

#ifdef __GNUG__
#pragma interface "pkglib/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;};

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