[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


// 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 DescIterator DescriptionList() const;
   DescIterator TranslatedDescription() 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 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) {};
};

// 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
578bfd0a AL	35	// Package Iterator
	36	class pkgCache::PkgIterator
	37	{
b2e465d6	38	friend class pkgCache;
578bfd0a AL	39	Package *Pkg;
	40	pkgCache *Owner;
	41	long HashIndex;
	42
b2e465d6 AL	43	protected:
	44
	45	// This constructor is the 'begin' constructor, never use it.
	46	inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
	47	{
	48	Pkg = Owner.PkgP;
	49	operator ++(0);
	50	};
	51
578bfd0a AL	52	public:
	53
	54	enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
	55
	56	// Iteration
	57	void operator ++(int);
	58	inline void operator ++() {operator ++(0);};
	59	inline bool end() const {return Owner == 0 \|\| Pkg == Owner->PkgP?true:false;};
	60
	61	// Comparison
	62	inline bool operator ==(const PkgIterator &B) const {return Pkg == B.Pkg;};
	63	inline bool operator !=(const PkgIterator &B) const {return Pkg != B.Pkg;};
	64
	65	// Accessors
	66	inline Package *operator ->() {return Pkg;};
	67	inline Package const *operator ->() const {return Pkg;};
	68	inline Package const &operator () const {return Pkg;};
	69	inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
	70	inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
b2e465d6	71	inline pkgCache *Cache() {return Owner;};
6c139d6e	72
578bfd0a AL	73	inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
578bfd0a AL	74	inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
e3bf76d1 AL	75	inline bool Purge() const {return Pkg->CurrentState == pkgCache::State::Purge \|\|
e3bf76d1 AL	76	(Pkg->CurrentVer == 0 && Pkg->CurrentState == pkgCache::State::NotInstalled);};
578bfd0a	77	inline VerIterator VersionList() const;
578bfd0a AL	78	inline VerIterator CurrentVer() const;
	79	inline DepIterator RevDependsList() const;
	80	inline PrvIterator ProvidesList() const;
f55a958f	81	inline unsigned long Index() const {return Pkg - Owner->PkgP;};
578bfd0a AL	82	OkState State() const;
	83
	84	// Constructors
578bfd0a AL	85	inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
	86	HashIndex(0)
	87	{
	88	if (Pkg == 0)
	89	Pkg = Owner.PkgP;
	90	};
	91	inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
	92	};
	93
	94	// Version Iterator
	95	class pkgCache::VerIterator
	96	{
	97	Version *Ver;
f9eec0e7	98	pkgCache *Owner;
770c32ec	99
578bfd0a AL	100	void _dummy();
	101
	102	public:
	103
	104	// Iteration
f9eec0e7	105	void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
578bfd0a	106	inline void operator ++() {operator ++(0);};
dc1f50b9	107	inline bool end() const {return Owner == NULL \|\| (Ver == Owner->VerP?true:false);};
f9eec0e7	108	inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
578bfd0a AL	109
	110	// Comparison
	111	inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
	112	inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
	113	int CompareVer(const VerIterator &B) const;
	114
	115	// Accessors
	116	inline Version *operator ->() {return Ver;};
	117	inline Version const *operator ->() const {return Ver;};
	118	inline Version &operator () {return Ver;};
	119	inline Version const &operator () const {return Ver;};
f9eec0e7 AL	120	inline operator Version *() {return Ver == Owner->VerP?0:Ver;};
f9eec0e7 AL	121	inline operator Version const *() const {return Ver == Owner->VerP?0:Ver;};
b2e465d6 AL	122	inline pkgCache *Cache() {return Owner;};
b2e465d6 AL	123
f9eec0e7 AL	124	inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner->StrP + Ver->VerStr;};
	125	inline const char *Section() const {return Ver->Section == 0?0:Owner->StrP + Ver->Section;};
	126	inline const char *Arch() const {return Ver->Arch == 0?0:Owner->StrP + Ver->Arch;};
	127	inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Ver->ParentPkg);};
a52f938b	128	inline DescIterator DescriptionList() const;
012b102a	129	DescIterator TranslatedDescription() const;
578bfd0a AL	130	inline DepIterator DependsList() const;
578bfd0a AL	131	inline PrvIterator ProvidesList() const;
dcb79bae	132	inline VerFileIterator FileList() const;
f9eec0e7	133	inline unsigned long Index() const {return Ver - Owner->VerP;};
b518cca6	134	bool Downloadable() const;
b2e465d6 AL	135	inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
	136	string RelStr();
	137
3c124dde AL	138	bool Automatic() const;
3c124dde AL	139	VerFileIterator NewestFile() const;
f9eec0e7 AL	140
	141	inline VerIterator() : Ver(0), Owner(0) {};
	142	inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg),
	143	Owner(&Owner)
578bfd0a AL	144	{
	145	if (Ver == 0)
	146	Ver = Owner.VerP;
	147	};
	148	};
	149
a52f938b OS	150	// Description Iterator
	151	class pkgCache::DescIterator
	152	{
	153	Description *Desc;
	154	pkgCache *Owner;
	155
	156	void _dummy();
	157
	158	public:
	159
	160	// Iteration
	161	void operator ++(int) {if (Desc != Owner->DescP) Desc = Owner->DescP + Desc->NextDesc;};
	162	inline void operator ++() {operator ++(0);};
	163	inline bool end() const {return Desc == Owner->DescP?true:false;};
	164	inline void operator =(const DescIterator &B) {Desc = B.Desc; Owner = B.Owner;};
	165
	166	// Comparison
	167	inline bool operator ==(const DescIterator &B) const {return Desc == B.Desc;};
	168	inline bool operator !=(const DescIterator &B) const {return Desc != B.Desc;};
	169	int CompareDesc(const DescIterator &B) const;
	170
	171	// Accessors
	172	inline Description *operator ->() {return Desc;};
	173	inline Description const *operator ->() const {return Desc;};
	174	inline Description &operator () {return Desc;};
	175	inline Description const &operator () const {return Desc;};
	176	inline operator Description *() {return Desc == Owner->DescP?0:Desc;};
	177	inline operator Description const *() const {return Desc == Owner->DescP?0:Desc;};
	178	inline pkgCache *Cache() {return Owner;};
	179
	180	inline const char *LanguageCode() const {return Owner->StrP + Desc->language_code;};
	181	inline const char *md5() const {return Owner->StrP + Desc->md5sum;};
	182	inline DescFileIterator FileList() const;
	183	inline unsigned long Index() const {return Desc - Owner->DescP;};
	184
	185	inline DescIterator() : Desc(0), Owner(0) {};
	186	inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Desc(Trg),
	187	Owner(&Owner)
	188	{
	189	if (Desc == 0)
	190	Desc = Owner.DescP;
	191	};
	192	};
	193
578bfd0a AL	194	// Dependency iterator
	195	class pkgCache::DepIterator
	196	{
	197	Dependency *Dep;
	198	enum {DepVer, DepRev} Type;
	199	pkgCache *Owner;
	200
	201	void _dummy();
	202
	203	public:
	204
	205	// Iteration
	206	void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
	207	(Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
	208	inline void operator ++() {operator ++(0);};
	209	inline bool end() const {return Owner == 0 \|\| Dep == Owner->DepP?true:false;};
	210
	211	// Comparison
	212	inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
	213	inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
	214
	215	// Accessors
	216	inline Dependency *operator ->() {return Dep;};
	217	inline Dependency const *operator ->() const {return Dep;};
	218	inline Dependency &operator () {return Dep;};
	219	inline Dependency const &operator () const {return Dep;};
	220	inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
	221	inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
b2e465d6	222	inline pkgCache *Cache() {return Owner;};
6c139d6e	223
578bfd0a AL	224	inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
578bfd0a AL	225	inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
b2e465d6	226	inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
578bfd0a AL	227	inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
578bfd0a AL	228	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
578bfd0a	229	inline bool Reverse() {return Type == DepRev;};
f55a958f	230	inline unsigned long Index() const {return Dep - Owner->DepP;};
6c139d6e	231	bool IsCritical();
43d017d6	232	void GlobOr(DepIterator &Start,DepIterator &End);
6c139d6e AL	233	Version **AllTargets();
6c139d6e AL	234	bool SmartTargetPkg(PkgIterator &Result);
b2e465d6 AL	235	inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
b2e465d6 AL	236	inline const char *DepType() {return Owner->DepType(Dep->Type);};
0a8e3465	237
578bfd0a AL	238	inline DepIterator(pkgCache &Owner,Dependency Trg,Version = 0) :
	239	Dep(Trg), Type(DepVer), Owner(&Owner)
	240	{
	241	if (Dep == 0)
	242	Dep = Owner.DepP;
	243	};
	244	inline DepIterator(pkgCache &Owner,Dependency Trg,Package ) :
	245	Dep(Trg), Type(DepRev), Owner(&Owner)
	246	{
	247	if (Dep == 0)
	248	Dep = Owner.DepP;
	249	};
	250	inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
	251	};
	252
	253	// Provides iterator
	254	class pkgCache::PrvIterator
	255	{
	256	Provides *Prv;
	257	enum {PrvVer, PrvPkg} Type;
	258	pkgCache *Owner;
	259
	260	void _dummy();
	261
	262	public:
	263
	264	// Iteration
	265	void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
	266	(Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
	267	inline void operator ++() {operator ++(0);};
13e8426f	268	inline bool end() const {return Owner == 0 \|\| Prv == Owner->ProvideP?true:false;};
578bfd0a AL	269
	270	// Comparison
	271	inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
	272	inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
	273
	274	// Accessors
	275	inline Provides *operator ->() {return Prv;};
	276	inline Provides const *operator ->() const {return Prv;};
	277	inline Provides &operator () {return Prv;};
	278	inline Provides const &operator () const {return Prv;};
	279	inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
	280	inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
b2e465d6	281	inline pkgCache *Cache() {return Owner;};
6c139d6e	282
578bfd0a AL	283	inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
	284	inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
	285	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
	286	inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
	287	inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
f55a958f	288	inline unsigned long Index() const {return Prv - Owner->ProvideP;};
578bfd0a	289
c320a1e6	290	inline PrvIterator() : Prv(0), Type(PrvVer), Owner(0) {};
13e8426f	291
578bfd0a AL	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