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

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

	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");
	/** \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 */
	PkgIterator FindPreferredPkg();
	PkgIterator NextPkg(PkgIterator const &Pkg);

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

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

	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;

	// 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 const char *Arch(bool const pseudo) const {
		if(pseudo == false)
			return Arch();
		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() {return Owner->Priority(S->Priority);};
	string RelStr();

	bool Automatic() const;
	bool Pseudo() 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->DescP;
	};

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

	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() {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
	inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
	inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
	inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
	inline bool Reverse() {return Type == DepRev;};
	bool IsCritical();
	void GlobOr(DepIterator &Start,DepIterator &End);
	Version **AllTargets();
	bool SmartTargetPkg(PkgIterator &Result);
	inline const char *CompType() {return Owner->CompType(S->CompareOp);};
	inline const char *DepType() {return Owner->DepType(S->Type);};

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

	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() {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
	inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + S->Version);};
	inline PkgIterator OwnerPkg() {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->PkgFileP;
	};

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

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

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