]>
Commit | Line | Data |
---|---|---|
6c139d6e AL |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
b2e465d6 | 3 | // $Id: depcache.h,v 1.14 2001/02/20 07:03:17 jgg Exp $ |
6c139d6e AL |
4 | /* ###################################################################### |
5 | ||
6 | DepCache - Dependency Extension data for the cache | |
7 | ||
8 | This class stores the cache data and a set of extension structures for | |
9 | monitoring the current state of all the packages. It also generates and | |
10 | caches the 'install' state of many things. This refers to the state of the | |
11 | package after an install has been run. | |
12 | ||
13 | The StateCache::State field can be -1,0,1,2 which is <,=,>,no current. | |
14 | StateCache::Mode is which of the 3 fields is active. | |
15 | ||
16 | This structure is important to support the readonly status of the cache | |
17 | file. When the data is saved the cache will be refereshed from our | |
18 | internal rep and written to disk. Then the actual persistant data | |
19 | files will be put on the disk. | |
20 | ||
21 | Each dependency is compared against 3 target versions to produce to | |
22 | 3 dependency results. | |
23 | Now - Compared using the Currently install version | |
24 | Install - Compared using the install version (final state) | |
25 | CVer - (Candidate Verion) Compared using the Candidate Version | |
26 | The candidate and now results are used to decide wheather a package | |
27 | should be automatically installed or if it should be left alone. | |
28 | ||
29 | Remember, the Candidate Version is selected based on the distribution | |
30 | settings for the Package. The Install Version is selected based on the | |
31 | state (Delete, Keep, Install) field and can be either the Current Version | |
32 | or the Candidate version. | |
33 | ||
34 | The Candidate version is what is shown the 'Install Version' field. | |
35 | ||
36 | ##################################################################### */ | |
37 | /*}}}*/ | |
6c139d6e AL |
38 | #ifndef PKGLIB_DEPCACHE_H |
39 | #define PKGLIB_DEPCACHE_H | |
40 | ||
41 | #ifdef __GNUG__ | |
094a497d | 42 | #pragma interface "apt-pkg/depcache.h" |
6c139d6e AL |
43 | #endif |
44 | ||
094a497d | 45 | #include <apt-pkg/pkgcache.h> |
a246f2dc | 46 | #include <apt-pkg/progress.h> |
6c139d6e | 47 | |
b2e465d6 | 48 | class pkgDepCache : protected pkgCache::Namespace |
6c139d6e AL |
49 | { |
50 | public: | |
51 | ||
52 | // These flags are used in DepState | |
53 | enum DepFlags {DepNow = (1 << 0),DepInstall = (1 << 1),DepCVer = (1 << 2), | |
54 | DepGNow = (1 << 3),DepGInstall = (1 << 4),DepGCVer = (1 << 5)}; | |
55 | ||
56 | // These flags are used in StateCache::DepState | |
57 | enum DepStateFlags {DepNowPolicy = (1 << 0), DepNowMin = (1 << 1), | |
58 | DepInstPolicy = (1 << 2), DepInstMin = (1 << 3), | |
59 | DepCandPolicy = (1 << 4), DepCandMin = (1 << 5)}; | |
60 | ||
61 | // These flags are used in StateCache::iFlags | |
d0c59649 | 62 | enum InternalFlags {AutoKept = (1 << 0), Purge = (1 << 1), ReInstall = (1 << 2)}; |
6c139d6e AL |
63 | |
64 | enum VersionTypes {NowVersion, InstallVersion, CandidateVersion}; | |
65 | enum ModeList {ModeDelete = 0, ModeKeep = 1, ModeInstall = 2}; | |
0a57c0f0 | 66 | |
6c139d6e AL |
67 | struct StateCache |
68 | { | |
69 | // Epoch stripped text versions of the two version fields | |
70 | const char *CandVersion; | |
71 | const char *CurVersion; | |
72 | ||
73 | // Pointer to the candidate install version. | |
74 | Version *CandidateVer; | |
75 | ||
76 | // Pointer to the install version. | |
77 | Version *InstallVer; | |
b2e465d6 AL |
78 | |
79 | // Copy of Package::Flags | |
80 | unsigned short Flags; | |
81 | unsigned short iFlags; // Internal flags | |
6c139d6e | 82 | |
0a57c0f0 | 83 | // mark and sweep flags |
0a57c0f0 MV |
84 | bool Marked; |
85 | bool Garbage; | |
afb1e2e3 | 86 | |
6c139d6e AL |
87 | // Various tree indicators |
88 | signed char Status; // -1,0,1,2 | |
89 | unsigned char Mode; // ModeList | |
90 | unsigned char DepState; // DepState Flags | |
91 | ||
6c139d6e AL |
92 | // Update of candidate version |
93 | const char *StripEpoch(const char *Ver); | |
94 | void Update(PkgIterator Pkg,pkgCache &Cache); | |
95 | ||
96 | // Various test members for the current status of the package | |
97 | inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;}; | |
98 | inline bool Delete() const {return Mode == ModeDelete;}; | |
99 | inline bool Keep() const {return Mode == ModeKeep;}; | |
100 | inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;}; | |
0a8e3465 | 101 | inline bool Upgradable() const {return Status >= 1;}; |
6321777b | 102 | inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;}; |
6c139d6e AL |
103 | inline bool Held() const {return Status != 0 && Keep();}; |
104 | inline bool NowBroken() const {return (DepState & DepNowMin) != DepNowMin;}; | |
105 | inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;}; | |
106 | inline bool Install() const {return Mode == ModeInstall;}; | |
107 | inline VerIterator InstVerIter(pkgCache &Cache) | |
108 | {return VerIterator(Cache,InstallVer);}; | |
109 | inline VerIterator CandidateVerIter(pkgCache &Cache) | |
110 | {return VerIterator(Cache,CandidateVer);}; | |
111 | }; | |
112 | ||
113 | // Helper functions | |
114 | void BuildGroupOrs(VerIterator const &V); | |
115 | void UpdateVerState(PkgIterator Pkg); | |
116 | ||
b2e465d6 AL |
117 | // User Policy control |
118 | class Policy | |
119 | { | |
120 | public: | |
121 | ||
122 | virtual VerIterator GetCandidateVer(PkgIterator Pkg); | |
123 | virtual bool IsImportantDep(DepIterator Dep); | |
124 | ||
125 | virtual ~Policy() {}; | |
126 | }; | |
127 | ||
6c139d6e AL |
128 | protected: |
129 | ||
130 | // State information | |
b2e465d6 | 131 | pkgCache *Cache; |
6c139d6e AL |
132 | StateCache *PkgState; |
133 | unsigned char *DepState; | |
134 | ||
b2e465d6 AL |
135 | double iUsrSize; |
136 | double iDownloadSize; | |
a6568219 AL |
137 | unsigned long iInstCount; |
138 | unsigned long iDelCount; | |
139 | unsigned long iKeepCount; | |
140 | unsigned long iBrokenCount; | |
141 | unsigned long iBadCount; | |
b2e465d6 AL |
142 | |
143 | Policy *delLocalPolicy; // For memory clean up.. | |
144 | Policy *LocalPolicy; | |
145 | ||
6c139d6e AL |
146 | // Check for a matching provides |
147 | bool CheckDep(DepIterator Dep,int Type,PkgIterator &Res); | |
148 | inline bool CheckDep(DepIterator Dep,int Type) | |
149 | { | |
b2e465d6 | 150 | PkgIterator Res(*this,0); |
6c139d6e | 151 | return CheckDep(Dep,Type,Res); |
b2e465d6 | 152 | } |
6c139d6e AL |
153 | |
154 | // Computes state information for deps and versions (w/o storing) | |
155 | unsigned char DependencyState(DepIterator &D); | |
156 | unsigned char VersionState(DepIterator D,unsigned char Check, | |
157 | unsigned char SetMin, | |
158 | unsigned char SetPolicy); | |
159 | ||
160 | // Recalculates various portions of the cache, call after changing something | |
161 | void Update(DepIterator Dep); // Mostly internal | |
162 | void Update(PkgIterator const &P); | |
163 | ||
164 | // Count manipulators | |
b2e465d6 | 165 | void AddSizes(const PkgIterator &Pkg,signed long Mult = 1); |
6c139d6e AL |
166 | inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg,-1);}; |
167 | void AddStates(const PkgIterator &Pkg,int Add = 1); | |
168 | inline void RemoveStates(const PkgIterator &Pkg) {AddStates(Pkg,-1);}; | |
b2e465d6 | 169 | |
6c139d6e AL |
170 | public: |
171 | ||
b2e465d6 AL |
172 | // Legacy.. We look like a pkgCache |
173 | inline operator pkgCache &() {return *Cache;}; | |
174 | inline Header &Head() {return *Cache->HeaderP;}; | |
175 | inline PkgIterator PkgBegin() {return Cache->PkgBegin();}; | |
176 | inline PkgIterator FindPkg(string const &Name) {return Cache->FindPkg(Name);}; | |
177 | ||
178 | inline pkgCache &GetCache() {return *Cache;}; | |
179 | inline pkgVersioningSystem &VS() {return *Cache->VS;}; | |
180 | ||
6c139d6e | 181 | // Policy implementation |
b2e465d6 AL |
182 | inline VerIterator GetCandidateVer(PkgIterator Pkg) {return LocalPolicy->GetCandidateVer(Pkg);}; |
183 | inline bool IsImportantDep(DepIterator Dep) {return LocalPolicy->IsImportantDep(Dep);}; | |
184 | inline Policy &GetPolicy() {return *LocalPolicy;}; | |
185 | ||
6c139d6e AL |
186 | // Accessors |
187 | inline StateCache &operator [](PkgIterator const &I) {return PkgState[I->ID];}; | |
188 | inline unsigned char &operator [](DepIterator const &I) {return DepState[I->ID];}; | |
189 | ||
190 | // Manipulators | |
191 | void MarkKeep(PkgIterator const &Pkg,bool Soft = false); | |
d556d1a1 | 192 | void MarkDelete(PkgIterator const &Pkg,bool Purge = false); |
b2e465d6 AL |
193 | void MarkInstall(PkgIterator const &Pkg,bool AutoInst = true, |
194 | unsigned long Depth = 0); | |
d0c59649 | 195 | void SetReInstall(PkgIterator const &Pkg,bool To); |
6321777b | 196 | void SetCandidateVersion(VerIterator TargetVer); |
6c139d6e AL |
197 | |
198 | // This is for debuging | |
a246f2dc | 199 | void Update(OpProgress *Prog = 0); |
a83d884d MV |
200 | |
201 | // read persistent states | |
202 | bool readStateFile(OpProgress *prog); | |
203 | bool writeStateFile(OpProgress *prog); | |
e331f6ed | 204 | |
6c139d6e | 205 | // Size queries |
b2e465d6 AL |
206 | inline double UsrSize() {return iUsrSize;}; |
207 | inline double DebSize() {return iDownloadSize;}; | |
a6568219 AL |
208 | inline unsigned long DelCount() {return iDelCount;}; |
209 | inline unsigned long KeepCount() {return iKeepCount;}; | |
210 | inline unsigned long InstCount() {return iInstCount;}; | |
211 | inline unsigned long BrokenCount() {return iBrokenCount;}; | |
212 | inline unsigned long BadCount() {return iBadCount;}; | |
b2e465d6 AL |
213 | |
214 | bool Init(OpProgress *Prog); | |
6c139d6e | 215 | |
b2e465d6 | 216 | pkgDepCache(pkgCache *Cache,Policy *Plcy = 0); |
6c139d6e AL |
217 | virtual ~pkgDepCache(); |
218 | }; | |
219 | ||
220 | #endif |