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

// -*- 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
   
   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
   
   ##################################################################### */
									/*}}}*/
#ifndef PKGLIB_CACHEITERATORS_H
#define PKGLIB_CACHEITERATORS_H

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

// 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;
   
   // 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) {};
};

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

// 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) {};
};

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

// 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 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 *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) {};
};

// 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 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) {};
};

// 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::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
da6ee469 JF	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	// $Id: cacheiterators.h,v 1.18.2.1 2004/05/08 22:44:27 mdz Exp $
	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
	24	that has the depends pointer as a member. The provide iterator has the
	25	same system.
	26
	27	This header is not user includable, please use apt-pkg/pkgcache.h
	28
	29	##################################################################### */
	30	/}}}/
	31	#ifndef PKGLIB_CACHEITERATORS_H
	32	#define PKGLIB_CACHEITERATORS_H
	33
	34	#ifdef __GNUG__
	35	#pragma interface "apt-pkg/cacheiterators.h"
	36	#endif
	37
	38	// Package Iterator
	39	class pkgCache::PkgIterator
	40	{
	41	friend class pkgCache;
	42	Package *Pkg;
	43	pkgCache *Owner;
	44	long HashIndex;
	45
	46	protected:
	47
	48	// This constructor is the 'begin' constructor, never use it.
	49	inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
	50	{
	51	Pkg = Owner.PkgP;
	52	operator ++(0);
	53	};
	54
	55	public:
	56
	57	enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
	58
	59	// Iteration
	60	void operator ++(int);
	61	inline void operator ++() {operator ++(0);};
	62	inline bool end() const {return Owner == 0 \|\| Pkg == Owner->PkgP?true:false;};
	63
	64	// Comparison
65	inline bool operator ==(const PkgIterator &B) const {return Pkg == B.Pkg;};
66	inline bool operator !=(const PkgIterator &B) const {return Pkg != B.Pkg;};
67
68	// Accessors
69	inline Package *operator ->() {return Pkg;};
70	inline Package const *operator ->() const {return Pkg;};
71	inline Package const &operator () const {return Pkg;};
72	inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
73	inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
74	inline pkgCache *Cache() {return Owner;};
75
76	inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
77	inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
78	inline bool Purge() const {return Pkg->CurrentState == pkgCache::State::Purge \|\|
79	(Pkg->CurrentVer == 0 && Pkg->CurrentState == pkgCache::State::NotInstalled);};
80	inline VerIterator VersionList() const;
81	inline VerIterator CurrentVer() const;
82	inline DepIterator RevDependsList() const;
83	inline PrvIterator ProvidesList() const;
84	inline unsigned long Index() const {return Pkg - Owner->PkgP;};
85	OkState State() const;
86
87	// Constructors
88	inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
89	HashIndex(0)
90	{
91	if (Pkg == 0)
92	Pkg = Owner.PkgP;
93	};
94	inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
95	};
96
97	// Version Iterator
98	class pkgCache::VerIterator
99	{
100	Version *Ver;
101	pkgCache *Owner;
102
103	void _dummy();
104
105	public:
106
107	// Iteration
108	void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
109	inline void operator ++() {operator ++(0);};
110	inline bool end() const {return Owner == NULL \|\| (Ver == Owner->VerP?true:false);};
111	inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
112
113	// Comparison
114	inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
115	inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
116	int CompareVer(const VerIterator &B) const;
117
118	// Accessors
119	inline Version *operator ->() {return Ver;};
120	inline Version const *operator ->() const {return Ver;};
121	inline Version &operator () {return Ver;};
122	inline Version const &operator () const {return Ver;};
123	inline operator Version *() {return Ver == Owner->VerP?0:Ver;};
124	inline operator Version const *() const {return Ver == Owner->VerP?0:Ver;};
125	inline pkgCache *Cache() {return Owner;};
126
127	inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner->StrP + Ver->VerStr;};
128	inline const char *Section() const {return Ver->Section == 0?0:Owner->StrP + Ver->Section;};
129	inline const char *Arch() const {return Ver->Arch == 0?0:Owner->StrP + Ver->Arch;};
130	inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Ver->ParentPkg);};
131	inline DepIterator DependsList() const;
132	inline PrvIterator ProvidesList() const;
133	inline VerFileIterator FileList() const;
134	inline unsigned long Index() const {return Ver - Owner->VerP;};
135	bool Downloadable() const;
136	inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
137	string RelStr();
138
139	bool Automatic() const;
140	VerFileIterator NewestFile() const;
141
142	inline VerIterator() : Ver(0), Owner(0) {};
143	inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg),
144	Owner(&Owner)
145	{
146	if (Ver == 0)
147	Ver = Owner.VerP;
148	};
149	};
150
151	// Dependency iterator
152	class pkgCache::DepIterator
153	{
154	Dependency *Dep;
155	enum {DepVer, DepRev} Type;
156	pkgCache *Owner;
157
158	void _dummy();
159
160	public:
161
162	// Iteration
163	void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
164	(Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
165	inline void operator ++() {operator ++(0);};
166	inline bool end() const {return Owner == 0 \|\| Dep == Owner->DepP?true:false;};
167
168	// Comparison
169	inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
170	inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
171
172	// Accessors
173	inline Dependency *operator ->() {return Dep;};
174	inline Dependency const *operator ->() const {return Dep;};
175	inline Dependency &operator () {return Dep;};
176	inline Dependency const &operator () const {return Dep;};
177	inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
178	inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
179	inline pkgCache *Cache() {return Owner;};
180
181	inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
182	inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
183	inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
184	inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
185	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
186	inline bool Reverse() {return Type == DepRev;};
187	inline unsigned long Index() const {return Dep - Owner->DepP;};
188	bool IsCritical();
189	void GlobOr(DepIterator &Start,DepIterator &End);
190	Version **AllTargets();
191	bool SmartTargetPkg(PkgIterator &Result);
192	inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
193	inline const char *DepType() {return Owner->DepType(Dep->Type);};
194
195	inline DepIterator(pkgCache &Owner,Dependency Trg,Version = 0) :
196	Dep(Trg), Type(DepVer), Owner(&Owner)
197	{
198	if (Dep == 0)
199	Dep = Owner.DepP;
200	};
201	inline DepIterator(pkgCache &Owner,Dependency Trg,Package ) :
202	Dep(Trg), Type(DepRev), Owner(&Owner)
203	{
204	if (Dep == 0)
205	Dep = Owner.DepP;
206	};
207	inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
208	};
209
210	// Provides iterator
211	class pkgCache::PrvIterator
212	{
213	Provides *Prv;
214	enum {PrvVer, PrvPkg} Type;
215	pkgCache *Owner;
216
217	void _dummy();
218
219	public:
220
221	// Iteration
222	void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
223	(Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
224	inline void operator ++() {operator ++(0);};
225	inline bool end() const {return Owner == 0 \|\| Prv == Owner->ProvideP?true:false;};
226
227	// Comparison
228	inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
229	inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
230
231	// Accessors
232	inline Provides *operator ->() {return Prv;};
233	inline Provides const *operator ->() const {return Prv;};
234	inline Provides &operator () {return Prv;};
235	inline Provides const &operator () const {return Prv;};
236	inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
237	inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
238	inline pkgCache *Cache() {return Owner;};
239
240	inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
241	inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
242	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
243	inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
244	inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
245	inline unsigned long Index() const {return Prv - Owner->ProvideP;};
246
247	inline PrvIterator() : Prv(0), Type(PrvVer), Owner(0) {};
248
249	inline PrvIterator(pkgCache &Owner,Provides Trg,Version ) :
250	Prv(Trg), Type(PrvVer), Owner(&Owner)
251	{
252	if (Prv == 0)
253	Prv = Owner.ProvideP;
254	};
255	inline PrvIterator(pkgCache &Owner,Provides Trg,Package ) :
256	Prv(Trg), Type(PrvPkg), Owner(&Owner)
257	{
258	if (Prv == 0)
259	Prv = Owner.ProvideP;
260	};
261	};
262
263	// Package file
264	class pkgCache::PkgFileIterator
265	{
266	pkgCache *Owner;
267	PackageFile *File;
268
269	public:
270
271	// Iteration
272	void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
273	inline void operator ++() {operator ++(0);};
274	inline bool end() const {return File == Owner->PkgFileP?true:false;};
275
276	// Comparison
277	inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
278	inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
279
280	// Accessors
281	inline PackageFile *operator ->() {return File;};
282	inline PackageFile const *operator ->() const {return File;};
283	inline PackageFile const &operator () const {return File;};
284	inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
285	inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
286	inline pkgCache *Cache() {return Owner;};
287
288	inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
289	inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
290	inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
291	inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
292	inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
293	inline const char *Label() const {return File->Label == 0?0:Owner->StrP + File->Label;};
294	inline const char *Site() const {return File->Site == 0?0:Owner->StrP + File->Site;};
295	inline const char *Architecture() const {return File->Architecture == 0?0:Owner->StrP + File->Architecture;};
296	inline const char *IndexType() const {return File->IndexType == 0?0:Owner->StrP + File->IndexType;};
297
298	inline unsigned long Index() const {return File - Owner->PkgFileP;};
299
300	bool IsOk();
301	string RelStr();
302
303	// Constructors
304	inline PkgFileIterator() : Owner(0), File(0) {};
305	inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
306	inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
307	};
308
309	// Version File
310	class pkgCache::VerFileIterator
311	{
312	pkgCache *Owner;
313	VerFile *FileP;
314
315	public:
316
317	// Iteration
318	void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
319	inline void operator ++() {operator ++(0);};
320	inline bool end() const {return FileP == Owner->VerFileP?true:false;};
321
322	// Comparison
323	inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
324	inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
325
326	// Accessors
327	inline VerFile *operator ->() {return FileP;};
328	inline VerFile const *operator ->() const {return FileP;};
329	inline VerFile const &operator () const {return FileP;};
330	inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
331	inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
332	inline pkgCache *Cache() {return Owner;};
333
334	inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
335	inline unsigned long Index() const {return FileP - Owner->VerFileP;};
336
337	inline VerFileIterator() : Owner(0), FileP(0) {};
338	inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
339	};
340
341	// Inlined Begin functions cant be in the class because of order problems
342	inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
343	{return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
344	inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
345	{return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
346	inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
347	{return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
348	inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
349	{return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
350	inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
351	{return PrvIterator(*Owner,Owner->ProvideP + Ver->ProvidesList,Ver);};
352	inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
353	{return DepIterator(*Owner,Owner->DepP + Ver->DependsList,Ver);};
354	inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
355	{return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);};
356
357	#endif