[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(std::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) == 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);};
	std::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;
	bool IsIgnorable(PrvIterator const &Prv) const;
	bool IsIgnorable(PkgIterator const &Pkg) const;
	bool IsMultiArchImplicit() const;
	bool IsSatisfied(VerIterator const &Ver) const;
	bool IsSatisfied(PrvIterator const &Prv) 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);};

	bool IsMultiArchImplicit() const;

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