1 : // -*- mode: cpp; mode: fold -*-
2 : // Description /*{{{*/
3 : // $Id: algorithms.h,v 1.10 2001/05/22 04:17:41 jgg Exp $
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.
17 :
18 : pkgFixBroken corrects a broken system so that it is in a sane state.
19 :
20 : pkgAllUpgrade attempts to upgade as many packages as possible but
21 : without installing new packages.
22 :
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 :
28 : ##################################################################### */
29 : /*}}}*/
30 : #ifndef PKGLIB_ALGORITHMS_H
31 : #define PKGLIB_ALGORITHMS_H
32 :
33 :
34 : #include <apt-pkg/packagemanager.h>
35 : #include <apt-pkg/depcache.h>
36 : #include <apt-pkg/acquire.h>
37 :
38 : #include <iostream>
39 :
40 : using std::ostream;
41 :
42 : class pkgSimulate : public pkgPackageManager
43 : {
44 : protected:
45 :
46 : class Policy : public pkgDepCache::Policy
47 : {
48 : pkgDepCache *Cache;
49 : public:
50 :
51 : virtual VerIterator GetCandidateVer(PkgIterator Pkg)
52 : {
53 : return (*Cache)[Pkg].CandidateVerIter(*Cache);
54 : }
55 :
56 : Policy(pkgDepCache *Cache) : Cache(Cache) {};
57 : };
58 :
59 : unsigned char *Flags;
60 :
61 : Policy iPolicy;
62 : pkgDepCache Sim;
63 :
64 : // The Actuall installation implementation
65 : virtual bool Install(PkgIterator Pkg,string File);
66 : virtual bool Configure(PkgIterator Pkg);
67 : virtual bool Remove(PkgIterator Pkg,bool Purge);
68 :
69 : private:
70 : void ShortBreaks();
71 : void Describe(PkgIterator iPkg,ostream &out,bool Current,bool Candidate);
72 :
73 : public:
74 :
75 : pkgSimulate(pkgDepCache *Cache);
76 : };
77 :
78 : class pkgProblemResolver
79 : {
80 : pkgDepCache &Cache;
81 : typedef pkgCache::PkgIterator PkgIterator;
82 : typedef pkgCache::VerIterator VerIterator;
83 : typedef pkgCache::DepIterator DepIterator;
84 : typedef pkgCache::PrvIterator PrvIterator;
85 : typedef pkgCache::Version Version;
86 : typedef pkgCache::Package Package;
87 :
88 : enum Flags {Protected = (1 << 0), PreInstalled = (1 << 1),
89 : Upgradable = (1 << 2), ReInstateTried = (1 << 3),
90 : ToRemove = (1 << 4)};
91 : signed short *Scores;
92 : unsigned char *Flags;
93 : bool Debug;
94 :
95 : // Sort stuff
96 : static pkgProblemResolver *This;
97 : static int ScoreSort(const void *a,const void *b);
98 :
99 : struct PackageKill
100 : {
101 : PkgIterator Pkg;
102 : DepIterator Dep;
103 : };
104 :
105 : void MakeScores();
106 : bool DoUpgrade(pkgCache::PkgIterator Pkg);
107 :
108 : public:
109 :
110 4 : inline void Protect(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= Protected;};
111 0 : inline void Remove(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= ToRemove;};
112 4 : inline void Clear(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] &= ~(Protected | ToRemove);};
113 :
114 : // Try to intelligently resolve problems by installing and removing packages
115 : bool Resolve(bool BrokenFix = false);
116 :
117 : // Try to resolve problems only by using keep
118 : bool ResolveByKeep();
119 :
120 : // Install all protected packages
121 : void InstallProtect();
122 :
123 : pkgProblemResolver(pkgDepCache *Cache);
124 : ~pkgProblemResolver();
125 : };
126 :
127 : bool pkgDistUpgrade(pkgDepCache &Cache);
128 : bool pkgApplyStatus(pkgDepCache &Cache);
129 : bool pkgFixBroken(pkgDepCache &Cache);
130 : bool pkgAllUpgrade(pkgDepCache &Cache);
131 : bool pkgMinimizeUpgrade(pkgDepCache &Cache);
132 :
133 : void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List);
134 :
135 : bool ListUpdate(pkgAcquireStatus &progress, pkgSourceList &List, int PulseInterval=0);
136 :
137 : #endif
|