Commit | Line | Data |
---|---|---|
6c139d6e AL |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
b4fc9b6f | 3 | // $Id: algorithms.h,v 1.10 2001/05/22 04:17:41 jgg Exp $ |
6c139d6e AL |
4 | /* ###################################################################### |
5 | ||
6 | Algorithms - A set of misc algorithms | |
7 | ||
8 | This simulate class displays what the ordering code has done and | |
9 | analyses it with a fresh new dependency cache. In this way we can | |
10 | see all of the effects of an upgrade run. | |
11 | ||
12 | pkgDistUpgrade computes an upgrade that causes as many packages as | |
13 | possible to move to the newest verison. | |
14 | ||
15 | pkgApplyStatus sets the target state based on the content of the status | |
16 | field in the status file. It is important to get proper crash recovery. | |
6fc33863 AL |
17 | |
18 | pkgFixBroken corrects a broken system so that it is in a sane state. | |
0a8e3465 AL |
19 | |
20 | pkgAllUpgrade attempts to upgade as many packages as possible but | |
21 | without installing new packages. | |
6c139d6e | 22 | |
0a8e3465 AL |
23 | The problem resolver class contains a number of complex algorithms |
24 | to try to best-guess an upgrade state. It solves the problem of | |
25 | maximizing the number of install state packages while having no broken | |
26 | packages. | |
27 | ||
6c139d6e AL |
28 | ##################################################################### */ |
29 | /*}}}*/ | |
6c139d6e AL |
30 | #ifndef PKGLIB_ALGORITHMS_H |
31 | #define PKGLIB_ALGORITHMS_H | |
32 | ||
6c139d6e | 33 | |
094a497d AL |
34 | #include <apt-pkg/packagemanager.h> |
35 | #include <apt-pkg/depcache.h> | |
760d4968 | 36 | #include <apt-pkg/acquire.h> |
6c139d6e | 37 | |
b4fc9b6f AL |
38 | #include <iostream> |
39 | ||
92fcbfc1 | 40 | class pkgSimulate : public pkgPackageManager /*{{{*/ |
6c139d6e AL |
41 | { |
42 | protected: | |
43 | ||
b2e465d6 AL |
44 | class Policy : public pkgDepCache::Policy |
45 | { | |
46 | pkgDepCache *Cache; | |
47 | public: | |
48 | ||
e841200b | 49 | virtual VerIterator GetCandidateVer(PkgIterator const &Pkg) |
b2e465d6 AL |
50 | { |
51 | return (*Cache)[Pkg].CandidateVerIter(*Cache); | |
52 | } | |
53 | ||
54 | Policy(pkgDepCache *Cache) : Cache(Cache) {}; | |
55 | }; | |
56 | ||
6c139d6e AL |
57 | unsigned char *Flags; |
58 | ||
b2e465d6 | 59 | Policy iPolicy; |
6c139d6e | 60 | pkgDepCache Sim; |
496d5c70 | 61 | pkgDepCache::ActionGroup group; |
6c139d6e AL |
62 | |
63 | // The Actuall installation implementation | |
8f3ba4e8 | 64 | virtual bool Install(PkgIterator Pkg,std::string File); |
6c139d6e | 65 | virtual bool Configure(PkgIterator Pkg); |
fc4b5c9f | 66 | virtual bool Remove(PkgIterator Pkg,bool Purge); |
b3d44315 MV |
67 | |
68 | private: | |
6c139d6e | 69 | void ShortBreaks(); |
8f3ba4e8 | 70 | void Describe(PkgIterator iPkg,std::ostream &out,bool Current,bool Candidate); |
6c139d6e AL |
71 | |
72 | public: | |
73 | ||
b2e465d6 | 74 | pkgSimulate(pkgDepCache *Cache); |
6c139d6e | 75 | }; |
92fcbfc1 DK |
76 | /*}}}*/ |
77 | class pkgProblemResolver /*{{{*/ | |
6c139d6e | 78 | { |
be9b62f7 MV |
79 | /** \brief dpointer placeholder (for later in case we need it) */ |
80 | void *d; | |
81 | ||
6c139d6e AL |
82 | pkgDepCache &Cache; |
83 | typedef pkgCache::PkgIterator PkgIterator; | |
84 | typedef pkgCache::VerIterator VerIterator; | |
85 | typedef pkgCache::DepIterator DepIterator; | |
86 | typedef pkgCache::PrvIterator PrvIterator; | |
87 | typedef pkgCache::Version Version; | |
88 | typedef pkgCache::Package Package; | |
89 | ||
90 | enum Flags {Protected = (1 << 0), PreInstalled = (1 << 1), | |
3b5421b4 AL |
91 | Upgradable = (1 << 2), ReInstateTried = (1 << 3), |
92 | ToRemove = (1 << 4)}; | |
6c139d6e AL |
93 | signed short *Scores; |
94 | unsigned char *Flags; | |
95 | bool Debug; | |
96 | ||
97 | // Sort stuff | |
98 | static pkgProblemResolver *This; | |
99 | static int ScoreSort(const void *a,const void *b); | |
100 | ||
101 | struct PackageKill | |
102 | { | |
103 | PkgIterator Pkg; | |
104 | DepIterator Dep; | |
105 | }; | |
106 | ||
107 | void MakeScores(); | |
108 | bool DoUpgrade(pkgCache::PkgIterator Pkg); | |
6d38011b DK |
109 | |
110 | bool ResolveInternal(bool const BrokenFix = false); | |
741b7da9 | 111 | bool ResolveByKeepInternal(); |
6c139d6e | 112 | |
953b348c MV |
113 | protected: |
114 | bool InstOrNewPolicyBroken(pkgCache::PkgIterator Pkg); | |
115 | ||
6c139d6e AL |
116 | public: |
117 | ||
cc26da01 | 118 | inline void Protect(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= Protected; Cache.MarkProtected(Pkg);}; |
3b5421b4 | 119 | inline void Remove(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= ToRemove;}; |
61d6a8de AL |
120 | inline void Clear(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] &= ~(Protected | ToRemove);}; |
121 | ||
0a8e3465 | 122 | // Try to intelligently resolve problems by installing and removing packages |
6c139d6e | 123 | bool Resolve(bool BrokenFix = false); |
3b5421b4 | 124 | |
0a8e3465 AL |
125 | // Try to resolve problems only by using keep |
126 | bool ResolveByKeep(); | |
c320a1e6 MV |
127 | |
128 | // Install all protected packages | |
3b5421b4 AL |
129 | void InstallProtect(); |
130 | ||
b2e465d6 AL |
131 | pkgProblemResolver(pkgDepCache *Cache); |
132 | ~pkgProblemResolver(); | |
6c139d6e | 133 | }; |
92fcbfc1 | 134 | /*}}}*/ |
6c139d6e AL |
135 | bool pkgDistUpgrade(pkgDepCache &Cache); |
136 | bool pkgApplyStatus(pkgDepCache &Cache); | |
137 | bool pkgFixBroken(pkgDepCache &Cache); | |
0a8e3465 | 138 | bool pkgAllUpgrade(pkgDepCache &Cache); |
7e798dd7 | 139 | bool pkgMinimizeUpgrade(pkgDepCache &Cache); |
6c139d6e | 140 | |
b2e465d6 | 141 | void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List); |
760d4968 MV |
142 | |
143 | bool ListUpdate(pkgAcquireStatus &progress, pkgSourceList &List, int PulseInterval=0); | |
b2e465d6 | 144 | |
6c139d6e | 145 | #endif |