summaryrefslogtreecommitdiffstats
path: root/apt-pkg/orderlist.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-13 09:59:37 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-13 09:59:37 +0000
commit76e2632459410dec81337edb6a9fee33c9a660f3 (patch)
treea73345df208eede4a4daad340515c9328f34625c /apt-pkg/orderlist.h
parentInitial commit. (diff)
downloadapt-76e2632459410dec81337edb6a9fee33c9a660f3.tar.xz
apt-76e2632459410dec81337edb6a9fee33c9a660f3.zip
Adding upstream version 2.7.12.upstream/2.7.12
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'apt-pkg/orderlist.h')
-rw-r--r--apt-pkg/orderlist.h126
1 files changed, 126 insertions, 0 deletions
diff --git a/apt-pkg/orderlist.h b/apt-pkg/orderlist.h
new file mode 100644
index 0000000..559bf98
--- /dev/null
+++ b/apt-pkg/orderlist.h
@@ -0,0 +1,126 @@
+// -*- mode: cpp; mode: fold -*-
+// Description /*{{{*/
+/* ######################################################################
+
+ Order List - Represents and Manipulates an ordered list of packages.
+
+ A list of packages can be ordered by a number of conflicting criteria
+ each given a specific priority. Each package also has a set of flags
+ indicating some useful things about it that are derived in the
+ course of sorting. The pkgPackageManager class uses this class for
+ all of it's installation ordering needs.
+
+ ##################################################################### */
+ /*}}}*/
+#ifndef PKGLIB_ORDERLIST_H
+#define PKGLIB_ORDERLIST_H
+
+#include <apt-pkg/macros.h>
+#include <apt-pkg/pkgcache.h>
+
+#include <string>
+
+class pkgDepCache;
+class APT_PUBLIC pkgOrderList : protected pkgCache::Namespace
+{
+ void * const d;
+ protected:
+
+ pkgDepCache &Cache;
+ typedef bool (pkgOrderList::*DepFunc)(DepIterator D);
+
+ // These are the currently selected ordering functions
+ DepFunc Primary;
+ DepFunc Secondary;
+ DepFunc RevDepends;
+ DepFunc Remove;
+
+ // State
+ Package **End;
+ Package **List;
+ Package **AfterEnd;
+ std::string *FileList;
+ DepIterator Loops[20];
+ int LoopCount;
+ int Depth;
+ unsigned short *Flags;
+ bool Debug;
+
+ // Main visit function
+ bool VisitNode(PkgIterator Pkg, char const* from);
+ bool VisitDeps(DepFunc F,PkgIterator Pkg);
+ bool VisitRDeps(DepFunc F,PkgIterator Pkg);
+ bool VisitRProvides(DepFunc F,VerIterator Ver);
+ bool VisitProvides(DepIterator Pkg,bool Critical);
+
+ // Dependency checking functions.
+ bool DepUnPackCrit(DepIterator D);
+ bool DepUnPackPreD(DepIterator D);
+ bool DepUnPackPre(DepIterator D);
+ bool DepUnPackDep(DepIterator D);
+ bool DepConfigure(DepIterator D);
+ bool DepRemove(DepIterator D);
+
+ // Analysis helpers
+ bool AddLoop(DepIterator D);
+ bool CheckDep(DepIterator D);
+ bool DoRun();
+
+ // For pre sorting
+ int OrderCompareA(Package *a, Package *b) APT_PURE;
+ int OrderCompareB(Package *a, Package *b) APT_PURE;
+ int FileCmp(PkgIterator A,PkgIterator B) APT_PURE;
+
+ public:
+
+ typedef Package **iterator;
+
+ /* State flags
+ The Loop flag can be set on a package that is currently being processed by either SmartConfigure or
+ SmartUnPack. This allows the package manager to tell when a loop has been formed as it will try to
+ SmartUnPack or SmartConfigure a package with the Loop flag set. It will then either stop (as it knows
+ that the operation is unnecessary as its already in process), or in the case of the conflicts resolution
+ in SmartUnPack, use EarlyRemove to resolve the situation. */
+ enum Flags {Added = (1 << 0), AddPending = (1 << 1),
+ Immediate = (1 << 2), Loop = (1 << 3),
+ UnPacked = (1 << 4), Configured = (1 << 5),
+ Removed = (1 << 6), // Early Remove
+ InList = (1 << 7),
+ After = (1 << 8),
+ States = (UnPacked | Configured | Removed)};
+
+ // Flag manipulators
+ inline bool IsFlag(PkgIterator Pkg,unsigned long F) {return (Flags[Pkg->ID] & F) == F;};
+ inline bool IsFlag(Package *Pkg,unsigned long F) {return (Flags[Pkg->ID] & F) == F;};
+ void Flag(PkgIterator Pkg,unsigned long State, unsigned long F) {Flags[Pkg->ID] = (Flags[Pkg->ID] & (~F)) | State;};
+ inline void Flag(PkgIterator Pkg,unsigned long F) {Flags[Pkg->ID] |= F;};
+ inline void Flag(Package *Pkg,unsigned long F) {Flags[Pkg->ID] |= F;};
+ // RmFlag removes a flag from a package
+ inline void RmFlag(Package *Pkg,unsigned long F) {Flags[Pkg->ID] &= ~F;};
+ // IsNow will return true if the Pkg has been not been either configured or unpacked
+ inline bool IsNow(PkgIterator Pkg) {return (Flags[Pkg->ID] & (States & (~Removed))) == 0;};
+ bool IsMissing(PkgIterator Pkg) APT_PURE;
+ void WipeFlags(unsigned long F);
+ void SetFileList(std::string *FileList) {this->FileList = FileList;};
+
+ // Accessors
+ inline iterator begin() {return List;};
+ inline iterator end() {return End;};
+ inline void push_back(Package *Pkg) {*(End++) = Pkg;};
+ inline void push_back(PkgIterator Pkg) {*(End++) = Pkg;};
+ inline void pop_back() {End--;};
+ inline bool empty() {return End == List;};
+ inline unsigned int size() {return End - List;};
+
+ // Ordering modes
+ bool OrderCritical();
+ bool OrderUnpack(std::string *FileList = 0);
+ bool OrderConfigure();
+
+ int Score(PkgIterator Pkg);
+
+ explicit pkgOrderList(pkgDepCache *Cache);
+ virtual ~pkgOrderList();
+};
+
+#endif