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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
/* ######################################################################
   
   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
#include<iterator>

#include<string.h>
// abstract Iterator template						/*{{{*/
/* This template provides the very basic iterator methods we
   need to have for doing some walk-over-the-cache magic */
template<typename Str, typename Itr> class pkgCache::Iterator :
			public std::iterator<std::forward_iterator_tag, Str> {
	protected:
	Str *S;
	pkgCache *Owner;

	/** \brief Returns the Pointer for this struct in the owner
	 *  The implementation of this method should be pretty short
	 *  as it will only return the Pointer into the mmap stored
	 *  in the owner but the name of this pointer is different for
	 *  each stucture and we want to abstract here at least for the
	 *  basic methods from the actual structure.
	 *  \return Pointer to the first structure of this type
	 */
	virtual Str* OwnerPointer() const = 0;

	public:
	// Iteration
	virtual void operator ++(int) = 0;
	virtual void operator ++() = 0; // Should be {operator ++(0);};
	inline bool end() const {return Owner == 0 || S == OwnerPointer();};

	// Comparison
	inline bool operator ==(const Itr &B) const {return S == B.S;};
	inline bool operator !=(const Itr &B) const {return S != B.S;};

	// Accessors
	inline Str *operator ->() {return S;};
	inline Str const *operator ->() const {return S;};
	inline operator Str *() {return S == OwnerPointer() ? 0 : S;};
	inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;};
	inline Str &operator *() {return *S;};
	inline Str const &operator *() const {return *S;};
	inline pkgCache *Cache() const {return Owner;};

	// Mixed stuff
	inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;};
	inline bool IsGood() const { return S && Owner && ! end();};
	inline unsigned long Index() const {return S - OwnerPointer();};

	void ReMap(void const * const oldMap, void const * const newMap) {
		if (Owner == 0 || S == 0)
			return;
		S += (Str*)(newMap) - (Str*)(oldMap);
	}

	// Constructors - look out for the variable assigning
	inline Iterator() : S(0), Owner(0) {};
	inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {};
};
									/*}}}*/
// Group Iterator							/*{{{*/
/* Packages with the same name are collected in a Group so someone only
   interest in package names can iterate easily over the names, so the
   different architectures can be treated as of the "same" package
   (apt internally treat them as totally different packages) */
class pkgCache::GrpIterator: public Iterator<Group, GrpIterator> {
	long HashIndex;

	protected:
	inline Group* OwnerPointer() const {
		return (Owner != 0) ? Owner->GrpP : 0;
	};

	public:
	// This constructor is the 'begin' constructor, never use it.
	inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
		S = OwnerPointer();
		operator ++(0);
	};

	virtual void operator ++(int);
	virtual void operator ++() {operator ++(0);};

	inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
	inline PkgIterator PackageList() const;
	PkgIterator FindPkg(string Arch = "any") const;
	/** \brief find the package with the "best" architecture

	    The best architecture is either the "native" or the first
	    in the list of Architectures which is not an end-Pointer

	    \param PreferNonVirtual tries to respond with a non-virtual package
		   and only if this fails returns the best virtual package */
	PkgIterator FindPreferredPkg(bool const &PreferNonVirtual = true) const;
	PkgIterator NextPkg(PkgIterator const &Pkg) const;

	// Constructors
	inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
		if (S == 0)
			S = OwnerPointer();
	};
	inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {};

};
									/*}}}*/
// Package Iterator							/*{{{*/
class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
	long HashIndex;

	protected:
	inline Package* OwnerPointer() const {
		return (Owner != 0) ? Owner->PkgP : 0;
	};

	public:
	// This constructor is the 'begin' constructor, never use it.
	inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
		S = OwnerPointer();
		operator ++(0);
	};

	virtual void operator ++(int);
	virtual void operator ++() {operator ++(0);};

	enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};

	// Accessors
	inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
	inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
	inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
		(S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);};
	inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;};
	inline GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);};

	inline VerIterator VersionList() const;
	inline VerIterator CurrentVer() const;
	inline DepIterator RevDependsList() const;
	inline PrvIterator ProvidesList() const;
	OkState State() const;
	const char *CandVersion() const;
	const char *CurVersion() const;

	//Nice printable representation
	friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
	std::string FullName(bool const &Pretty = false) const;

	// Constructors
	inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
		if (S == 0)
			S = OwnerPointer();
	};
	inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
};
									/*}}}*/
// Version Iterator							/*{{{*/
class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
	protected:
	inline Version* OwnerPointer() const {
		return (Owner != 0) ? Owner->VerP : 0;
	};

	public:
	// Iteration
	void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
	inline void operator ++() {operator ++(0);};

	// Comparison
	int CompareVer(const VerIterator &B) const;
	/** \brief compares two version and returns if they are similar

	    This method should be used to identify if two pseudo versions are
	    refering to the same "real" version */
	inline bool SimilarVer(const VerIterator &B) const {
		return (B.end() == false && S->Hash == B->Hash && strcmp(VerStr(), B.VerStr()) == 0);
	};

	// Accessors
	inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;};
	inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
	inline const char *Arch() const {
		if (S->MultiArch == pkgCache::Version::All)
			return "all";
		return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
	};
	inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};

	inline DescIterator DescriptionList() const;
	DescIterator TranslatedDescription() const;
	inline DepIterator DependsList() const;
	inline PrvIterator ProvidesList() const;
	inline VerFileIterator FileList() const;
	bool Downloadable() const;
	inline const char *PriorityType() const {return Owner->Priority(S->Priority);};
	string RelStr() const;

	bool Automatic() const;
	VerFileIterator NewestFile() const;

	inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
		if (S == 0)
			S = OwnerPointer();
	};
	inline VerIterator() : Iterator<Version, VerIterator>() {};
};
									/*}}}*/
// Description Iterator							/*{{{*/
class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
	protected:
	inline Description* OwnerPointer() const {
		return (Owner != 0) ? Owner->DescP : 0;
	};

	public:
	// Iteration
	void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
	inline void operator ++() {operator ++(0);};

	// Comparison
	int CompareDesc(const DescIterator &B) const;

	// Accessors
	inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
	inline const char *md5() const {return Owner->StrP + S->md5sum;};
	inline DescFileIterator FileList() const;

	inline DescIterator() : Iterator<Description, DescIterator>() {};
	inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
		if (S == 0)
			S = Owner.DescP;
	};
};
									/*}}}*/
// Dependency iterator							/*{{{*/
class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
	enum {DepVer, DepRev} Type;

	protected:
	inline Dependency* OwnerPointer() const {
		return (Owner != 0) ? Owner->DepP : 0;
	};

	public:
	// Iteration
	void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
		(Type == DepVer ? S->NextDepends : S->NextRevDepends);};
	inline void operator ++() {operator ++(0);};

	// Accessors
	inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
	inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
	inline PkgIterator SmartTargetPkg() const {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
	inline VerIterator ParentVer() const {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
	inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
	inline bool Reverse() const {return Type == DepRev;};
	bool IsCritical() const;
	bool IsNegative() const;
	void GlobOr(DepIterator &Start,DepIterator &End);
	Version **AllTargets() const;
	bool SmartTargetPkg(PkgIterator &Result) const;
	inline const char *CompType() const {return Owner->CompType(S->CompareOp);};
	inline const char *DepType() const {return Owner->DepType(S->Type);};

	//Nice printable representation
	friend std::ostream& operator <<(std::ostream& out, DepIterator D);

	inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
		Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
		if (S == 0)
			S = Owner.DepP;
	};
	inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
		Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
		if (S == 0)
			S = Owner.DepP;
	};
	inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
};
									/*}}}*/
// Provides iterator							/*{{{*/
class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
	enum {PrvVer, PrvPkg} Type;

	protected:
	inline Provides* OwnerPointer() const {
		return (Owner != 0) ? Owner->ProvideP : 0;
	};

	public:
	// Iteration
	void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
		(Type == PrvVer?S->NextPkgProv:S->NextProvides);};
	inline void operator ++() {operator ++(0);};

	// Accessors
	inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
	inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
	inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
	inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);};
	inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};

	inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};

	inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
		Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
		if (S == 0)
			S = Owner.ProvideP;
	};
	inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
		Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
		if (S == 0)
			S = Owner.ProvideP;
	};
};
									/*}}}*/
// Package file								/*{{{*/
class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
	protected:
	inline PackageFile* OwnerPointer() const {
		return (Owner != 0) ? Owner->PkgFileP : 0;
	};

	public:
	// Iteration
	void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
	inline void operator ++() {operator ++(0);};

	// Accessors
	inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
	inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
	inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
	inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
	inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
	inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
	inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
	inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
	inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
	inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};

	bool IsOk();
	string RelStr();

	// Constructors
	inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
	inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {};
	inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
};
									/*}}}*/
// Version File								/*{{{*/
class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
	protected:
	inline VerFile* OwnerPointer() const {
		return (Owner != 0) ? Owner->VerFileP : 0;
	};

	public:
	// Iteration
	void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
	inline void operator ++() {operator ++(0);};

	// Accessors
	inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};

	inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
	inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
};
									/*}}}*/
// Description File							/*{{{*/
class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
	protected:
	inline DescFile* OwnerPointer() const {
		return (Owner != 0) ? Owner->DescFileP : 0;
	};

	public:
	// Iteration
	void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
	inline void operator ++() {operator ++(0);};

	// Accessors
	inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};

	inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
	inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
};
									/*}}}*/
// Inlined Begin functions cant be in the class because of order problems /*{{{*/
inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
       {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);};
inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
       {return VerIterator(*Owner,Owner->VerP + S->VersionList);};
inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
       {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
       {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
       {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
       {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
       {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
       {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
       {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
       {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
									/*}}}*/
#endif
Commit	Line	Data
578bfd0a AL	1	// -- mode: cpp; mode: fold --
578bfd0a AL	2	// Description /{{{/
578bfd0a AL	3	/* ######################################################################
	4
	5	Cache Iterators - Iterators for navigating the cache structure
	6
	7	The iterators all provides ++,==,!=,->,* and end for their type.
	8	The end function can be used to tell if the list has been fully
	9	traversed.
	10
	11	Unlike STL iterators these contain helper functions to access the data
	12	that is being iterated over. This is because the data structures can't
	13	be formed in a manner that is intuitive to use and also mmapable.
	14
	15	For each variable in the target structure that would need a translation
	16	to be accessed correctly a translating function of the same name is
	17	present in the iterator. If applicable the translating function will
	18	return an iterator.
	19
	20	The DepIterator can iterate over two lists, a list of 'version depends'
	21	or a list of 'package reverse depends'. The type is determined by the
	22	structure passed to the constructor, which should be the structure
6c139d6e AL	23	that has the depends pointer as a member. The provide iterator has the
6c139d6e AL	24	same system.
578bfd0a	25
094a497d	26	This header is not user includable, please use apt-pkg/pkgcache.h
578bfd0a AL	27
	28	##################################################################### */
	29	/}}}/
578bfd0a AL	30	#ifndef PKGLIB_CACHEITERATORS_H
578bfd0a AL	31	#define PKGLIB_CACHEITERATORS_H
b3fdb998	32	#include<iterator>
8ceeb9d6 DK	33
8ceeb9d6 DK	34	#include<string.h>
773e2c1f DK	35	// abstract Iterator template /{{{/
773e2c1f DK	36	/* This template provides the very basic iterator methods we
5bf15716	37	need to have for doing some walk-over-the-cache magic */
b3fdb998 DK	38	template<typename Str, typename Itr> class pkgCache::Iterator :
b3fdb998 DK	39	public std::iterator<std::forward_iterator_tag, Str> {
773e2c1f DK	40	protected:
	41	Str *S;
	42	pkgCache *Owner;
	43
	44	/** \brief Returns the Pointer for this struct in the owner
	45	* The implementation of this method should be pretty short
	46	* as it will only return the Pointer into the mmap stored
	47	* in the owner but the name of this pointer is different for
	48	* each stucture and we want to abstract here at least for the
	49	* basic methods from the actual structure.
	50	* \return Pointer to the first structure of this type
	51	*/
	52	virtual Str* OwnerPointer() const = 0;
	53
	54	public:
	55	// Iteration
	56	virtual void operator ++(int) = 0;
	57	virtual void operator ++() = 0; // Should be {operator ++(0);};
	58	inline bool end() const {return Owner == 0 \|\| S == OwnerPointer();};
	59
	60	// Comparison
	61	inline bool operator ==(const Itr &B) const {return S == B.S;};
	62	inline bool operator !=(const Itr &B) const {return S != B.S;};
	63
	64	// Accessors
	65	inline Str *operator ->() {return S;};
	66	inline Str const *operator ->() const {return S;};
	67	inline operator Str *() {return S == OwnerPointer() ? 0 : S;};
	68	inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;};
9552aeeb	69	inline Str &operator () {return S;};
773e2c1f	70	inline Str const &operator () const {return S;};
ffee1c2b	71	inline pkgCache *Cache() const {return Owner;};
773e2c1f DK	72
	73	// Mixed stuff
	74	inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;};
	75	inline bool IsGood() const { return S && Owner && ! end();};
	76	inline unsigned long Index() const {return S - OwnerPointer();};
	77
f7a35f2e DK	78	void ReMap(void const * const oldMap, void const * const newMap) {
f7a35f2e DK	79	if (Owner == 0 \|\| S == 0)
a9fe5928 DK	80	return;
	81	S += (Str)(newMap) - (Str)(oldMap);
	82	}
	83
773e2c1f DK	84	// Constructors - look out for the variable assigning
	85	inline Iterator() : S(0), Owner(0) {};
	86	inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {};
5bf15716 DK	87	};
	88	/}}}/
	89	// Group Iterator /{{{/
	90	/* Packages with the same name are collected in a Group so someone only
	91	interest in package names can iterate easily over the names, so the
	92	different architectures can be treated as of the "same" package
	93	(apt internally treat them as totally different packages) */
	94	class pkgCache::GrpIterator: public Iterator<Group, GrpIterator> {
25396fb0 DK	95	long HashIndex;
25396fb0 DK	96
5bf15716 DK	97	protected:
5bf15716 DK	98	inline Group* OwnerPointer() const {
c55b8a54	99	return (Owner != 0) ? Owner->GrpP : 0;
5bf15716 DK	100	};
	101
	102	public:
25396fb0 DK	103	// This constructor is the 'begin' constructor, never use it.
	104	inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
	105	S = OwnerPointer();
	106	operator ++(0);
	107	};
	108
	109	virtual void operator ++(int);
5bf15716 DK	110	virtual void operator ++() {operator ++(0);};
	111
	112	inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
	113	inline PkgIterator PackageList() const;
e841200b	114	PkgIterator FindPkg(string Arch = "any") const;
bd2fb30a DK	115	/** \brief find the package with the "best" architecture
	116
	117	The best architecture is either the "native" or the first
3db58cf4 DK	118	in the list of Architectures which is not an end-Pointer
	119
	120	\param PreferNonVirtual tries to respond with a non-virtual package
	121	and only if this fails returns the best virtual package */
	122	PkgIterator FindPreferredPkg(bool const &PreferNonVirtual = true) const;
e841200b	123	PkgIterator NextPkg(PkgIterator const &Pkg) const;
5bf15716 DK	124
5bf15716 DK	125	// Constructors
25396fb0	126	inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
5bf15716 DK	127	if (S == 0)
	128	S = OwnerPointer();
	129	};
25396fb0	130	inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {};
5bf15716	131
773e2c1f DK	132	};
773e2c1f DK	133	/}}}/
92fcbfc1	134	// Package Iterator /{{{/
773e2c1f DK	135	class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
	136	long HashIndex;
	137
	138	protected:
	139	inline Package* OwnerPointer() const {
c55b8a54	140	return (Owner != 0) ? Owner->PkgP : 0;
773e2c1f DK	141	};
	142
	143	public:
	144	// This constructor is the 'begin' constructor, never use it.
	145	inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
	146	S = OwnerPointer();
	147	operator ++(0);
	148	};
	149
	150	virtual void operator ++(int);
	151	virtual void operator ++() {operator ++(0);};
	152
	153	enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
	154
	155	// Accessors
	156	inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
	157	inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
	158	inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge \|\|
	159	(S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);};
5bf15716 DK	160	inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;};
5bf15716 DK	161	inline GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);};
773e2c1f DK	162
	163	inline VerIterator VersionList() const;
	164	inline VerIterator CurrentVer() const;
	165	inline DepIterator RevDependsList() const;
	166	inline PrvIterator ProvidesList() const;
	167	OkState State() const;
	168	const char *CandVersion() const;
	169	const char *CurVersion() const;
	170
	171	//Nice printable representation
	172	friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
75ce2062	173	std::string FullName(bool const &Pretty = false) const;
773e2c1f DK	174
	175	// Constructors
	176	inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
	177	if (S == 0)
	178	S = OwnerPointer();
	179	};
	180	inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
578bfd0a	181	};
92fcbfc1 DK	182	/}}}/
92fcbfc1 DK	183	// Version Iterator /{{{/
773e2c1f DK	184	class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
	185	protected:
	186	inline Version* OwnerPointer() const {
c55b8a54	187	return (Owner != 0) ? Owner->VerP : 0;
773e2c1f DK	188	};
	189
	190	public:
	191	// Iteration
	192	void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
	193	inline void operator ++() {operator ++(0);};
	194
	195	// Comparison
	196	int CompareVer(const VerIterator &B) const;
8ceeb9d6 DK	197	/** \brief compares two version and returns if they are similar
	198
	199	This method should be used to identify if two pseudo versions are
	200	refering to the same "real" version */
	201	inline bool SimilarVer(const VerIterator &B) const {
	202	return (B.end() == false && S->Hash == B->Hash && strcmp(VerStr(), B.VerStr()) == 0);
	203	};
773e2c1f DK	204
	205	// Accessors
	206	inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;};
	207	inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
c5dac10c	208	inline const char *Arch() const {
894d672e	209	if (S->MultiArch == pkgCache::Version::All)
ca238ede	210	return "all";
c5dac10c DK	211	return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
c5dac10c DK	212	};
773e2c1f DK	213	inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
	214
	215	inline DescIterator DescriptionList() const;
	216	DescIterator TranslatedDescription() const;
	217	inline DepIterator DependsList() const;
	218	inline PrvIterator ProvidesList() const;
	219	inline VerFileIterator FileList() const;
	220	bool Downloadable() const;
d4489d49 DK	221	inline const char *PriorityType() const {return Owner->Priority(S->Priority);};
d4489d49 DK	222	string RelStr() const;
773e2c1f DK	223
	224	bool Automatic() const;
	225	VerFileIterator NewestFile() const;
	226
	227	inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
	228	if (S == 0)
	229	S = OwnerPointer();
	230	};
	231	inline VerIterator() : Iterator<Version, VerIterator>() {};
578bfd0a	232	};
92fcbfc1 DK	233	/}}}/
92fcbfc1 DK	234	// Description Iterator /{{{/
773e2c1f DK	235	class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
	236	protected:
	237	inline Description* OwnerPointer() const {
c55b8a54	238	return (Owner != 0) ? Owner->DescP : 0;
773e2c1f DK	239	};
	240
	241	public:
	242	// Iteration
	243	void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
	244	inline void operator ++() {operator ++(0);};
	245
	246	// Comparison
	247	int CompareDesc(const DescIterator &B) const;
	248
	249	// Accessors
	250	inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
	251	inline const char *md5() const {return Owner->StrP + S->md5sum;};
	252	inline DescFileIterator FileList() const;
	253
	254	inline DescIterator() : Iterator<Description, DescIterator>() {};
	255	inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
	256	if (S == 0)
	257	S = Owner.DescP;
	258	};
a52f938b	259	};
92fcbfc1 DK	260	/}}}/
92fcbfc1 DK	261	// Dependency iterator /{{{/
773e2c1f DK	262	class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
	263	enum {DepVer, DepRev} Type;
	264
	265	protected:
	266	inline Dependency* OwnerPointer() const {
c55b8a54	267	return (Owner != 0) ? Owner->DepP : 0;
773e2c1f DK	268	};
	269
	270	public:
	271	// Iteration
	272	void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
	273	(Type == DepVer ? S->NextDepends : S->NextRevDepends);};
	274	inline void operator ++() {operator ++(0);};
	275
	276	// Accessors
	277	inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
e841200b DK	278	inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
	279	inline PkgIterator SmartTargetPkg() const {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
	280	inline VerIterator ParentVer() const {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
	281	inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
	282	inline bool Reverse() const {return Type == DepRev;};
	283	bool IsCritical() const;
df77d8a5	284	bool IsNegative() const;
773e2c1f	285	void GlobOr(DepIterator &Start,DepIterator &End);
e841200b DK	286	Version **AllTargets() const;
	287	bool SmartTargetPkg(PkgIterator &Result) const;
	288	inline const char *CompType() const {return Owner->CompType(S->CompareOp);};
	289	inline const char *DepType() const {return Owner->DepType(S->Type);};
773e2c1f	290
47f6d1b7 DK	291	//Nice printable representation
	292	friend std::ostream& operator <<(std::ostream& out, DepIterator D);
	293
773e2c1f DK	294	inline DepIterator(pkgCache &Owner, Dependency Trg, Version = 0) :
	295	Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
	296	if (S == 0)
	297	S = Owner.DepP;
	298	};
	299	inline DepIterator(pkgCache &Owner, Dependency Trg, Package) :
	300	Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
	301	if (S == 0)
	302	S = Owner.DepP;
	303	};
	304	inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
578bfd0a	305	};
92fcbfc1 DK	306	/}}}/
92fcbfc1 DK	307	// Provides iterator /{{{/
773e2c1f DK	308	class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
	309	enum {PrvVer, PrvPkg} Type;
	310
	311	protected:
	312	inline Provides* OwnerPointer() const {
c55b8a54	313	return (Owner != 0) ? Owner->ProvideP : 0;
773e2c1f DK	314	};
	315
	316	public:
	317	// Iteration
	318	void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
	319	(Type == PrvVer?S->NextPkgProv:S->NextProvides);};
	320	inline void operator ++() {operator ++(0);};
	321
	322	// Accessors
	323	inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
	324	inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
e841200b DK	325	inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
	326	inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);};
	327	inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};
773e2c1f DK	328
	329	inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
	330
	331	inline PrvIterator(pkgCache &Owner, Provides Trg, Version) :
	332	Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
	333	if (S == 0)
	334	S = Owner.ProvideP;
	335	};
	336	inline PrvIterator(pkgCache &Owner, Provides Trg, Package) :
	337	Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
	338	if (S == 0)
	339	S = Owner.ProvideP;
	340	};
578bfd0a	341	};
92fcbfc1 DK	342	/}}}/
92fcbfc1 DK	343	// Package file /{{{/
773e2c1f DK	344	class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
	345	protected:
	346	inline PackageFile* OwnerPointer() const {
c55b8a54	347	return (Owner != 0) ? Owner->PkgFileP : 0;
773e2c1f DK	348	};
	349
	350	public:
	351	// Iteration
	352	void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
	353	inline void operator ++() {operator ++(0);};
	354
	355	// Accessors
	356	inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
	357	inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
	358	inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
	359	inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
	360	inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
	361	inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
	362	inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
	363	inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
	364	inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
	365	inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
	366
	367	bool IsOk();
	368	string RelStr();
	369
	370	// Constructors
	371	inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
a04cd1f9 DK	372	inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {};
a04cd1f9 DK	373	inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
578bfd0a	374	};
92fcbfc1 DK	375	/}}}/
92fcbfc1 DK	376	// Version File /{{{/
773e2c1f DK	377	class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
	378	protected:
	379	inline VerFile* OwnerPointer() const {
c55b8a54	380	return (Owner != 0) ? Owner->VerFileP : 0;
773e2c1f DK	381	};
	382
	383	public:
	384	// Iteration
	385	void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
	386	inline void operator ++() {operator ++(0);};
	387
	388	// Accessors
	389	inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
	390
	391	inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
	392	inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
dcb79bae	393	};
92fcbfc1 DK	394	/}}}/
92fcbfc1 DK	395	// Description File /{{{/
773e2c1f DK	396	class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
	397	protected:
	398	inline DescFile* OwnerPointer() const {
c55b8a54	399	return (Owner != 0) ? Owner->DescFileP : 0;
773e2c1f DK	400	};
	401
	402	public:
	403	// Iteration
	404	void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
	405	inline void operator ++() {operator ++(0);};
	406
	407	// Accessors
	408	inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
	409
	410	inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
	411	inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
a52f938b	412	};
92fcbfc1 DK	413	/}}}/
92fcbfc1 DK	414	// Inlined Begin functions cant be in the class because of order problems /{{{/
5bf15716 DK	415	inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
5bf15716 DK	416	{return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);};
578bfd0a	417	inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
773e2c1f	418	{return VerIterator(*Owner,Owner->VerP + S->VersionList);};
578bfd0a	419	inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
773e2c1f	420	{return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
578bfd0a	421	inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
773e2c1f	422	{return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
578bfd0a	423	inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
773e2c1f	424	{return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
a52f938b	425	inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
773e2c1f	426	{return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
578bfd0a	427	inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
773e2c1f	428	{return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
578bfd0a	429	inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
773e2c1f	430	{return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
dcb79bae	431	inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
773e2c1f	432	{return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
a52f938b	433	inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
773e2c1f	434	{return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
92fcbfc1	435	/}}}/
578bfd0a	436	#endif