git.saurik.com Git - apt.git/blame_incremental

... / ...

Commit	Line	Data
	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	/* ######################################################################
	4
	5	Order List - Represents and Manipulates an ordered list of packages.
	6
	7	A list of packages can be ordered by a number of conflicting criteria
	8	each given a specific priority. Each package also has a set of flags
	9	indicating some useful things about it that are derived in the
	10	course of sorting. The pkgPackageManager class uses this class for
	11	all of it's installation ordering needs.
	12
	13	##################################################################### */
	14	/}}}/
	15	#ifndef PKGLIB_ORDERLIST_H
	16	#define PKGLIB_ORDERLIST_H
	17
	18	#include <apt-pkg/pkgcache.h>
	19	#include <apt-pkg/cacheiterators.h>
	20	#include <apt-pkg/macros.h>
	21
	22	#include <string>
	23
	24	class pkgDepCache;
	25	class pkgOrderList : protected pkgCache::Namespace
	26	{
	27	void * const d;
	28	protected:
	29
	30	pkgDepCache &Cache;
	31	typedef bool (pkgOrderList::*DepFunc)(DepIterator D);
	32
	33	// These are the currently selected ordering functions
	34	DepFunc Primary;
	35	DepFunc Secondary;
	36	DepFunc RevDepends;
	37	DepFunc Remove;
	38
	39	// State
	40	Package **End;
	41	Package **List;
	42	Package **AfterEnd;
	43	std::string *FileList;
	44	DepIterator Loops[20];
	45	int LoopCount;
	46	int Depth;
	47	unsigned short *Flags;
	48	bool Debug;
	49
	50	// Main visit function
	51	APT_DEPRECATED bool VisitNode(PkgIterator Pkg) { return VisitNode(Pkg, "UNKNOWN"); };
	52	bool VisitNode(PkgIterator Pkg, char const* from);
	53	bool VisitDeps(DepFunc F,PkgIterator Pkg);
	54	bool VisitRDeps(DepFunc F,PkgIterator Pkg);
	55	bool VisitRProvides(DepFunc F,VerIterator Ver);
	56	bool VisitProvides(DepIterator Pkg,bool Critical);
	57
	58	// Dependency checking functions.
	59	bool DepUnPackCrit(DepIterator D);
	60	bool DepUnPackPreD(DepIterator D);
	61	bool DepUnPackPre(DepIterator D);
	62	bool DepUnPackDep(DepIterator D);
	63	bool DepConfigure(DepIterator D);
	64	bool DepRemove(DepIterator D);
	65
	66	// Analysis helpers
	67	bool AddLoop(DepIterator D);
	68	bool CheckDep(DepIterator D);
	69	bool DoRun();
	70
	71	// For pre sorting
	72	int OrderCompareA(Package a, Package b) APT_PURE;
	73	int OrderCompareB(Package a, Package b) APT_PURE;
	74	int FileCmp(PkgIterator A,PkgIterator B) APT_PURE;
	75
	76	public:
	77
	78	typedef Package **iterator;
	79
	80	/* State flags
	81	The Loop flag can be set on a package that is currently being processed by either SmartConfigure or
	82	SmartUnPack. This allows the package manager to tell when a loop has been formed as it will try to
	83	SmartUnPack or SmartConfigure a package with the Loop flag set. It will then either stop (as it knows
	84	that the operation is unnecessary as its already in process), or in the case of the conflicts resolution
	85	in SmartUnPack, use EarlyRemove to resolve the situation. */
	86	enum Flags {Added = (1 << 0), AddPending = (1 << 1),
	87	Immediate = (1 << 2), Loop = (1 << 3),
	88	UnPacked = (1 << 4), Configured = (1 << 5),
	89	Removed = (1 << 6), // Early Remove
	90	InList = (1 << 7),
	91	After = (1 << 8),
	92	States = (UnPacked \| Configured \| Removed)};
	93
	94	// Flag manipulators
	95	inline bool IsFlag(PkgIterator Pkg,unsigned long F) {return (Flags[Pkg->ID] & F) == F;};
	96	inline bool IsFlag(Package *Pkg,unsigned long F) {return (Flags[Pkg->ID] & F) == F;};
	97	void Flag(PkgIterator Pkg,unsigned long State, unsigned long F) {Flags[Pkg->ID] = (Flags[Pkg->ID] & (~F)) \| State;};
	98	inline void Flag(PkgIterator Pkg,unsigned long F) {Flags[Pkg->ID] \|= F;};
	99	inline void Flag(Package *Pkg,unsigned long F) {Flags[Pkg->ID] \|= F;};
	100	// RmFlag removes a flag from a package
	101	inline void RmFlag(Package *Pkg,unsigned long F) {Flags[Pkg->ID] &= ~F;};
	102	// IsNow will return true if the Pkg has been not been either configured or unpacked
	103	inline bool IsNow(PkgIterator Pkg) {return (Flags[Pkg->ID] & (States & (~Removed))) == 0;};
	104	bool IsMissing(PkgIterator Pkg) APT_PURE;
	105	void WipeFlags(unsigned long F);
	106	void SetFileList(std::string *FileList) {this->FileList = FileList;};
	107
	108	// Accessors
	109	inline iterator begin() {return List;};
	110	inline iterator end() {return End;};
	111	inline void push_back(Package Pkg) {(End++) = Pkg;};
	112	inline void push_back(PkgIterator Pkg) {*(End++) = Pkg;};
	113	inline void pop_back() {End--;};
	114	inline bool empty() {return End == List;};
	115	inline unsigned int size() {return End - List;};
	116
	117	// Ordering modes
	118	bool OrderCritical();
	119	bool OrderUnpack(std::string *FileList = 0);
	120	bool OrderConfigure();
	121
	122	int Score(PkgIterator Pkg);
	123
	124	explicit pkgOrderList(pkgDepCache *Cache);
	125	virtual ~pkgOrderList();
	126	};
	127
	128	#endif