[ntk/apt.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 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 DescIterator DescriptionList() const;
   inline DepIterator DependsList() const;
   inline PrvIterator ProvidesList() const;
   inline VerFileIterator FileList() const;
   inline unsigned long Index() const {return Ver - Owner->VerP;};
   bool Downloadable() const;
   inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
   string RelStr();
   
   bool Automatic() const;
   VerFileIterator NewestFile() const;

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

// Description Iterator
class pkgCache::DescIterator
{
   Description *Desc;
   pkgCache *Owner;
   
   void _dummy();
   
   public:

   // Iteration
   void operator ++(int) {if (Desc != Owner->DescP) Desc = Owner->DescP + Desc->NextDesc;};
   inline void operator ++() {operator ++(0);};
   inline bool end() const {return Desc == Owner->DescP?true:false;};
   inline void operator =(const DescIterator &B) {Desc = B.Desc; Owner = B.Owner;};
   
   // Comparison
   inline bool operator ==(const DescIterator &B) const {return Desc == B.Desc;};
   inline bool operator !=(const DescIterator &B) const {return Desc != B.Desc;};
   int CompareDesc(const DescIterator &B) const;
   
   // Accessors
   inline Description *operator ->() {return Desc;};
   inline Description const *operator ->() const {return Desc;};
   inline Description &operator *() {return *Desc;};
   inline Description const &operator *() const {return *Desc;};
   inline operator Description *() {return Desc == Owner->DescP?0:Desc;};
   inline operator Description const *() const {return Desc == Owner->DescP?0:Desc;};
   inline pkgCache *Cache() {return Owner;};
      
   inline const char *LanguageCode() const {return Owner->StrP + Desc->language_code;};
   inline const char *md5() const {return Owner->StrP + Desc->md5sum;};
   inline DescFileIterator FileList() const;
   inline unsigned long Index() const {return Desc - Owner->DescP;};

   inline DescIterator() : Desc(0), Owner(0) {};   
   inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Desc(Trg), 
              Owner(&Owner) 
   { 
      if (Desc == 0)
	 Desc = Owner.DescP;
   };
};

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

// Description File 
class pkgCache::DescFileIterator
{
   pkgCache *Owner;
   DescFile *FileP;

   public:

   // Iteration
   void operator ++(int) {if (FileP != Owner->DescFileP) FileP = Owner->DescFileP + FileP->NextFile;};
   inline void operator ++() {operator ++(0);};
   inline bool end() const {return FileP == Owner->DescFileP?true:false;};

   // Comparison
   inline bool operator ==(const DescFileIterator &B) const {return FileP == B.FileP;};
   inline bool operator !=(const DescFileIterator &B) const {return FileP != B.FileP;};
			   
   // Accessors
   inline DescFile *operator ->() {return FileP;};
   inline DescFile const *operator ->() const {return FileP;};
   inline DescFile const &operator *() const {return *FileP;};
   inline operator DescFile *() {return FileP == Owner->DescFileP?0:FileP;};
   inline operator DescFile const *() const {return FileP == Owner->DescFileP?0:FileP;};
   inline pkgCache *Cache() {return Owner;};
  
   inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
   inline unsigned long Index() const {return FileP - Owner->DescFileP;};
      
   inline DescFileIterator() : Owner(0), FileP(0) {};
   inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Owner(&Owner), FileP(Trg) {};
};

// 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::DescIterator pkgCache::VerIterator::DescriptionList() const
       {return DescIterator(*Owner,Owner->DescP + Ver->DescriptionList);};
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);};
inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
       {return DescFileIterator(*Owner,Owner->DescFileP + Desc->FileList);};

#endif
Commit	Line	Data
578bfd0a AL	1	// -- mode: cpp; mode: fold --
578bfd0a AL	2	// Description /{{{/
7db98ffc	3	// $Id: cacheiterators.h,v 1.18.2.1 2004/05/08 22:44:27 mdz 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	/}}}/
578bfd0a AL	31	#ifndef PKGLIB_CACHEITERATORS_H
	32	#define PKGLIB_CACHEITERATORS_H
	33
6c139d6e	34	#ifdef __GNUG__
094a497d	35	#pragma interface "apt-pkg/cacheiterators.h"
6c139d6e AL	36	#endif
6c139d6e AL	37
578bfd0a AL	38	// Package Iterator
	39	class pkgCache::PkgIterator
	40	{
b2e465d6	41	friend class pkgCache;
578bfd0a AL	42	Package *Pkg;
	43	pkgCache *Owner;
	44	long HashIndex;
	45
b2e465d6 AL	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
578bfd0a AL	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;};
b2e465d6	74	inline pkgCache *Cache() {return Owner;};
6c139d6e	75
578bfd0a AL	76	inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
578bfd0a AL	77	inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
e3bf76d1 AL	78	inline bool Purge() const {return Pkg->CurrentState == pkgCache::State::Purge \|\|
e3bf76d1 AL	79	(Pkg->CurrentVer == 0 && Pkg->CurrentState == pkgCache::State::NotInstalled);};
578bfd0a	80	inline VerIterator VersionList() const;
578bfd0a AL	81	inline VerIterator CurrentVer() const;
	82	inline DepIterator RevDependsList() const;
	83	inline PrvIterator ProvidesList() const;
f55a958f	84	inline unsigned long Index() const {return Pkg - Owner->PkgP;};
578bfd0a AL	85	OkState State() const;
	86
	87	// Constructors
578bfd0a AL	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;
f9eec0e7	101	pkgCache *Owner;
770c32ec	102
578bfd0a AL	103	void _dummy();
	104
	105	public:
	106
	107	// Iteration
f9eec0e7	108	void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
578bfd0a	109	inline void operator ++() {operator ++(0);};
f9eec0e7 AL	110	inline bool end() const {return Ver == Owner->VerP?true:false;};
f9eec0e7 AL	111	inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
578bfd0a AL	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;};
f9eec0e7 AL	123	inline operator Version *() {return Ver == Owner->VerP?0:Ver;};
f9eec0e7 AL	124	inline operator Version const *() const {return Ver == Owner->VerP?0:Ver;};
b2e465d6 AL	125	inline pkgCache *Cache() {return Owner;};
b2e465d6 AL	126
f9eec0e7 AL	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);};
a52f938b	131	inline DescIterator DescriptionList() const;
578bfd0a AL	132	inline DepIterator DependsList() const;
578bfd0a AL	133	inline PrvIterator ProvidesList() const;
dcb79bae	134	inline VerFileIterator FileList() const;
f9eec0e7	135	inline unsigned long Index() const {return Ver - Owner->VerP;};
b518cca6	136	bool Downloadable() const;
b2e465d6 AL	137	inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
	138	string RelStr();
	139
3c124dde AL	140	bool Automatic() const;
3c124dde AL	141	VerFileIterator NewestFile() const;
f9eec0e7 AL	142
	143	inline VerIterator() : Ver(0), Owner(0) {};
	144	inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg),
	145	Owner(&Owner)
578bfd0a AL	146	{
	147	if (Ver == 0)
	148	Ver = Owner.VerP;
	149	};
	150	};
	151
a52f938b OS	152	// Description Iterator
	153	class pkgCache::DescIterator
	154	{
	155	Description *Desc;
	156	pkgCache *Owner;
	157
	158	void _dummy();
	159
	160	public:
	161
	162	// Iteration
	163	void operator ++(int) {if (Desc != Owner->DescP) Desc = Owner->DescP + Desc->NextDesc;};
	164	inline void operator ++() {operator ++(0);};
	165	inline bool end() const {return Desc == Owner->DescP?true:false;};
	166	inline void operator =(const DescIterator &B) {Desc = B.Desc; Owner = B.Owner;};
	167
	168	// Comparison
	169	inline bool operator ==(const DescIterator &B) const {return Desc == B.Desc;};
	170	inline bool operator !=(const DescIterator &B) const {return Desc != B.Desc;};
	171	int CompareDesc(const DescIterator &B) const;
	172
	173	// Accessors
	174	inline Description *operator ->() {return Desc;};
	175	inline Description const *operator ->() const {return Desc;};
	176	inline Description &operator () {return Desc;};
	177	inline Description const &operator () const {return Desc;};
	178	inline operator Description *() {return Desc == Owner->DescP?0:Desc;};
	179	inline operator Description const *() const {return Desc == Owner->DescP?0:Desc;};
	180	inline pkgCache *Cache() {return Owner;};
	181
	182	inline const char *LanguageCode() const {return Owner->StrP + Desc->language_code;};
	183	inline const char *md5() const {return Owner->StrP + Desc->md5sum;};
	184	inline DescFileIterator FileList() const;
	185	inline unsigned long Index() const {return Desc - Owner->DescP;};
	186
	187	inline DescIterator() : Desc(0), Owner(0) {};
	188	inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Desc(Trg),
	189	Owner(&Owner)
	190	{
	191	if (Desc == 0)
	192	Desc = Owner.DescP;
	193	};
	194	};
	195
578bfd0a AL	196	// Dependency iterator
	197	class pkgCache::DepIterator
	198	{
	199	Dependency *Dep;
	200	enum {DepVer, DepRev} Type;
	201	pkgCache *Owner;
	202
	203	void _dummy();
	204
	205	public:
	206
	207	// Iteration
	208	void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
	209	(Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
	210	inline void operator ++() {operator ++(0);};
	211	inline bool end() const {return Owner == 0 \|\| Dep == Owner->DepP?true:false;};
	212
	213	// Comparison
	214	inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
	215	inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
	216
	217	// Accessors
	218	inline Dependency *operator ->() {return Dep;};
	219	inline Dependency const *operator ->() const {return Dep;};
	220	inline Dependency &operator () {return Dep;};
	221	inline Dependency const &operator () const {return Dep;};
	222	inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
	223	inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
b2e465d6	224	inline pkgCache *Cache() {return Owner;};
6c139d6e	225
578bfd0a AL	226	inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
578bfd0a AL	227	inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
b2e465d6	228	inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
578bfd0a AL	229	inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
578bfd0a AL	230	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
578bfd0a	231	inline bool Reverse() {return Type == DepRev;};
f55a958f	232	inline unsigned long Index() const {return Dep - Owner->DepP;};
6c139d6e	233	bool IsCritical();
43d017d6	234	void GlobOr(DepIterator &Start,DepIterator &End);
6c139d6e AL	235	Version **AllTargets();
6c139d6e AL	236	bool SmartTargetPkg(PkgIterator &Result);
b2e465d6 AL	237	inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
b2e465d6 AL	238	inline const char *DepType() {return Owner->DepType(Dep->Type);};
0a8e3465	239
578bfd0a AL	240	inline DepIterator(pkgCache &Owner,Dependency Trg,Version = 0) :
	241	Dep(Trg), Type(DepVer), Owner(&Owner)
	242	{
	243	if (Dep == 0)
	244	Dep = Owner.DepP;
	245	};
	246	inline DepIterator(pkgCache &Owner,Dependency Trg,Package ) :
	247	Dep(Trg), Type(DepRev), Owner(&Owner)
	248	{
	249	if (Dep == 0)
	250	Dep = Owner.DepP;
	251	};
	252	inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
	253	};
	254
	255	// Provides iterator
	256	class pkgCache::PrvIterator
	257	{
	258	Provides *Prv;
	259	enum {PrvVer, PrvPkg} Type;
	260	pkgCache *Owner;
	261
	262	void _dummy();
	263
	264	public:
	265
	266	// Iteration
	267	void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
	268	(Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
	269	inline void operator ++() {operator ++(0);};
	270	inline bool end() const {return Prv == Owner->ProvideP?true:false;};
	271
	272	// Comparison
	273	inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
	274	inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
	275
	276	// Accessors
	277	inline Provides *operator ->() {return Prv;};
	278	inline Provides const *operator ->() const {return Prv;};
	279	inline Provides &operator () {return Prv;};
	280	inline Provides const &operator () const {return Prv;};
	281	inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
	282	inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
b2e465d6	283	inline pkgCache *Cache() {return Owner;};
6c139d6e	284
578bfd0a AL	285	inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
	286	inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
	287	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
	288	inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
	289	inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
f55a958f	290	inline unsigned long Index() const {return Prv - Owner->ProvideP;};
578bfd0a AL	291
	292	inline PrvIterator(pkgCache &Owner,Provides Trg,Version ) :
	293	Prv(Trg), Type(PrvVer), Owner(&Owner)
	294	{
	295	if (Prv == 0)
	296	Prv = Owner.ProvideP;
	297	};
	298	inline PrvIterator(pkgCache &Owner,Provides Trg,Package ) :
	299	Prv(Trg), Type(PrvPkg), Owner(&Owner)
	300	{
	301	if (Prv == 0)
	302	Prv = Owner.ProvideP;
	303	};
	304	};
	305
	306	// Package file
	307	class pkgCache::PkgFileIterator
	308	{
	309	pkgCache *Owner;
	310	PackageFile *File;
	311
	312	public:
	313
	314	// Iteration
	315	void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
	316	inline void operator ++() {operator ++(0);};
	317	inline bool end() const {return File == Owner->PkgFileP?true:false;};
	318
	319	// Comparison
	320	inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
	321	inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
	322
	323	// Accessors
	324	inline PackageFile *operator ->() {return File;};
	325	inline PackageFile const *operator ->() const {return File;};
	326	inline PackageFile const &operator () const {return File;};
	327	inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
	328	inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
b2e465d6	329	inline pkgCache *Cache() {return Owner;};
578bfd0a AL	330
578bfd0a AL	331	inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
b0b4efb9 AL	332	inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
b0b4efb9 AL	333	inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
578bfd0a	334	inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
b0b4efb9	335	inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
a2ec6097	336	inline const char *Label() const {return File->Label == 0?0:Owner->StrP + File->Label;};
b2e465d6 AL	337	inline const char *Site() const {return File->Site == 0?0:Owner->StrP + File->Site;};
	338	inline const char *Architecture() const {return File->Architecture == 0?0:Owner->StrP + File->Architecture;};
	339	inline const char *IndexType() const {return File->IndexType == 0?0:Owner->StrP + File->IndexType;};
b0b4efb9	340
f55a958f	341	inline unsigned long Index() const {return File - Owner->PkgFileP;};
578bfd0a AL	342
578bfd0a AL	343	bool IsOk();
af87ab54 AL	344	string RelStr();
af87ab54 AL	345
578bfd0a	346	// Constructors
b2e465d6 AL	347	inline PkgFileIterator() : Owner(0), File(0) {};
b2e465d6 AL	348	inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
578bfd0a AL	349	inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
	350	};
	351
dcb79bae AL	352	// Version File
	353	class pkgCache::VerFileIterator
	354	{
	355	pkgCache *Owner;
	356	VerFile *FileP;
	357
	358	public:
	359
	360	// Iteration
	361	void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
	362	inline void operator ++() {operator ++(0);};
	363	inline bool end() const {return FileP == Owner->VerFileP?true:false;};
	364
	365	// Comparison
	366	inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
	367	inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
	368
	369	// Accessors
	370	inline VerFile *operator ->() {return FileP;};
	371	inline VerFile const *operator ->() const {return FileP;};
	372	inline VerFile const &operator () const {return FileP;};
	373	inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
	374	inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
b2e465d6	375	inline pkgCache *Cache() {return Owner;};
dcb79bae AL	376
	377	inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
	378	inline unsigned long Index() const {return FileP - Owner->VerFileP;};
b518cca6	379
b2e465d6	380	inline VerFileIterator() : Owner(0), FileP(0) {};
dcb79bae AL	381	inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
	382	};
	383
a52f938b OS	384	// Description File
	385	class pkgCache::DescFileIterator
	386	{
	387	pkgCache *Owner;
	388	DescFile *FileP;
	389
	390	public:
	391
	392	// Iteration
	393	void operator ++(int) {if (FileP != Owner->DescFileP) FileP = Owner->DescFileP + FileP->NextFile;};
	394	inline void operator ++() {operator ++(0);};
	395	inline bool end() const {return FileP == Owner->DescFileP?true:false;};
	396
	397	// Comparison
	398	inline bool operator ==(const DescFileIterator &B) const {return FileP == B.FileP;};
	399	inline bool operator !=(const DescFileIterator &B) const {return FileP != B.FileP;};
	400
	401	// Accessors
	402	inline DescFile *operator ->() {return FileP;};
	403	inline DescFile const *operator ->() const {return FileP;};
	404	inline DescFile const &operator () const {return FileP;};
	405	inline operator DescFile *() {return FileP == Owner->DescFileP?0:FileP;};
	406	inline operator DescFile const *() const {return FileP == Owner->DescFileP?0:FileP;};
	407	inline pkgCache *Cache() {return Owner;};
	408
	409	inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
	410	inline unsigned long Index() const {return FileP - Owner->DescFileP;};
	411
	412	inline DescFileIterator() : Owner(0), FileP(0) {};
	413	inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Owner(&Owner), FileP(Trg) {};
	414	};
	415
578bfd0a AL	416	// Inlined Begin functions cant be in the class because of order problems
	417	inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
	418	{return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
	419	inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
	420	{return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
578bfd0a AL	421	inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
	422	{return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
	423	inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
	424	{return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
a52f938b OS	425	inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
a52f938b OS	426	{return DescIterator(*Owner,Owner->DescP + Ver->DescriptionList);};
578bfd0a	427	inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
f9eec0e7	428	{return PrvIterator(*Owner,Owner->ProvideP + Ver->ProvidesList,Ver);};
578bfd0a	429	inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
f9eec0e7	430	{return DepIterator(*Owner,Owner->DepP + Ver->DependsList,Ver);};
dcb79bae	431	inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
f9eec0e7	432	{return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);};
a52f938b OS	433	inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
a52f938b OS	434	{return DescFileIterator(*Owner,Owner->DescFileP + Desc->FileList);};
578bfd0a AL	435
578bfd0a AL	436	#endif