1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>LCOV - lcov.info - /usr/include/apt-pkg/depcache.h</title>
<link rel="stylesheet" type="text/css" href="../../../gcov.css">
</head>
<body>
<table width="100%" border=0 cellspacing=0 cellpadding=0>
<tr><td class="title">LTP GCOV extension - code coverage report</td></tr>
<tr><td class="ruler"><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>
<tr>
<td width="100%">
<table cellpadding=1 border=0 width="100%">
<tr>
<td class="headerItem" width="20%">Current view:</td>
<td class="headerValue" width="80%" colspan=4><a href="../../../index.html">directory</a> - <a href="index.html">usr/include/apt-pkg</a> - depcache.h</td>
</tr>
<tr>
<td class="headerItem" width="20%">Test:</td>
<td class="headerValue" width="80%" colspan=4>lcov.info</td>
</tr>
<tr>
<td class="headerItem" width="20%">Date:</td>
<td class="headerValue" width="20%">2008-08-14</td>
<td width="20%"></td>
<td class="headerItem" width="20%">Instrumented lines:</td>
<td class="headerValue" width="20%">6</td>
</tr>
<tr>
<td class="headerItem" width="20%">Code covered:</td>
<td class="headerValue" width="20%">100.0 %</td>
<td width="20%"></td>
<td class="headerItem" width="20%">Executed lines:</td>
<td class="headerValue" width="20%">6</td>
</tr>
</table>
</td>
</tr>
<tr><td class="ruler"><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>
</table>
<table cellpadding=0 cellspacing=0 border=0>
<tr>
<td><br></td>
</tr>
<tr>
<td><pre class="source">
<span class="lineNum"> 1 </span> : // -*- mode: c++; mode: fold -*-
<span class="lineNum"> 2 </span> : // Description /*{{{*/
<span class="lineNum"> 3 </span> : // $Id: depcache.h,v 1.14 2001/02/20 07:03:17 jgg Exp $
<span class="lineNum"> 4 </span> : /* ######################################################################
<span class="lineNum"> 5 </span> :
<span class="lineNum"> 6 </span> : DepCache - Dependency Extension data for the cache
<span class="lineNum"> 7 </span> :
<span class="lineNum"> 8 </span> : This class stores the cache data and a set of extension structures for
<span class="lineNum"> 9 </span> : monitoring the current state of all the packages. It also generates and
<span class="lineNum"> 10 </span> : caches the 'install' state of many things. This refers to the state of the
<span class="lineNum"> 11 </span> : package after an install has been run.
<span class="lineNum"> 12 </span> :
<span class="lineNum"> 13 </span> : The StateCache::State field can be -1,0,1,2 which is <,=,>,no current.
<span class="lineNum"> 14 </span> : StateCache::Mode is which of the 3 fields is active.
<span class="lineNum"> 15 </span> :
<span class="lineNum"> 16 </span> : This structure is important to support the readonly status of the cache
<span class="lineNum"> 17 </span> : file. When the data is saved the cache will be refereshed from our
<span class="lineNum"> 18 </span> : internal rep and written to disk. Then the actual persistant data
<span class="lineNum"> 19 </span> : files will be put on the disk.
<span class="lineNum"> 20 </span> :
<span class="lineNum"> 21 </span> : Each dependency is compared against 3 target versions to produce to
<span class="lineNum"> 22 </span> : 3 dependency results.
<span class="lineNum"> 23 </span> : Now - Compared using the Currently install version
<span class="lineNum"> 24 </span> : Install - Compared using the install version (final state)
<span class="lineNum"> 25 </span> : CVer - (Candidate Verion) Compared using the Candidate Version
<span class="lineNum"> 26 </span> : The candidate and now results are used to decide wheather a package
<span class="lineNum"> 27 </span> : should be automatically installed or if it should be left alone.
<span class="lineNum"> 28 </span> :
<span class="lineNum"> 29 </span> : Remember, the Candidate Version is selected based on the distribution
<span class="lineNum"> 30 </span> : settings for the Package. The Install Version is selected based on the
<span class="lineNum"> 31 </span> : state (Delete, Keep, Install) field and can be either the Current Version
<span class="lineNum"> 32 </span> : or the Candidate version.
<span class="lineNum"> 33 </span> :
<span class="lineNum"> 34 </span> : The Candidate version is what is shown the 'Install Version' field.
<span class="lineNum"> 35 </span> :
<span class="lineNum"> 36 </span> : ##################################################################### */
<span class="lineNum"> 37 </span> : /*}}}*/
<span class="lineNum"> 38 </span> : #ifndef PKGLIB_DEPCACHE_H
<span class="lineNum"> 39 </span> : #define PKGLIB_DEPCACHE_H
<span class="lineNum"> 40 </span> :
<span class="lineNum"> 41 </span> :
<span class="lineNum"> 42 </span> : #include <apt-pkg/pkgcache.h>
<span class="lineNum"> 43 </span> : #include <apt-pkg/progress.h>
<span class="lineNum"> 44 </span> :
<span class="lineNum"> 45 </span> : #include <regex.h>
<span class="lineNum"> 46 </span> :
<span class="lineNum"> 47 </span> : #include <vector>
<span class="lineNum"> 48 </span> : #include <memory>
<span class="lineNum"> 49 </span> :
<span class="lineNum"> 50 </span> : class pkgDepCache : protected pkgCache::Namespace
<span class="lineNum"> 51 </span> : {
<span class="lineNum"> 52 </span> : public:
<span class="lineNum"> 53 </span> :
<span class="lineNum"> 54 </span> : /** \brief An arbitrary predicate on packages. */
<span class="lineNum"> 55 </span> : class InRootSetFunc
<span class="lineNum"> 56 </span> : {
<span class="lineNum"> 57 </span> : public:
<span class="lineNum"> 58 </span> : virtual bool InRootSet(const pkgCache::PkgIterator &pkg) {return false;};
<span class="lineNum"> 59 </span> : virtual ~InRootSetFunc() {};
<span class="lineNum"> 60 </span> : };
<span class="lineNum"> 61 </span> :
<span class="lineNum"> 62 </span> : private:
<span class="lineNum"> 63 </span> : /** \brief Mark a single package and all its unmarked important
<span class="lineNum"> 64 </span> : * dependencies during mark-and-sweep.
<span class="lineNum"> 65 </span> : *
<span class="lineNum"> 66 </span> : * Recursively invokes itself to mark all dependencies of the
<span class="lineNum"> 67 </span> : * package.
<span class="lineNum"> 68 </span> : *
<span class="lineNum"> 69 </span> : * \param pkg The package to mark.
<span class="lineNum"> 70 </span> : *
<span class="lineNum"> 71 </span> : * \param ver The version of the package that is to be marked.
<span class="lineNum"> 72 </span> : *
<span class="lineNum"> 73 </span> : * \param follow_recommends If \b true, recommendations of the
<span class="lineNum"> 74 </span> : * package will be recursively marked.
<span class="lineNum"> 75 </span> : *
<span class="lineNum"> 76 </span> : * \param follow_suggests If \b true, suggestions of the package
<span class="lineNum"> 77 </span> : * will be recursively marked.
<span class="lineNum"> 78 </span> : */
<span class="lineNum"> 79 </span> : void MarkPackage(const pkgCache::PkgIterator &pkg,
<span class="lineNum"> 80 </span> : const pkgCache::VerIterator &ver,
<span class="lineNum"> 81 </span> : bool follow_recommends,
<span class="lineNum"> 82 </span> : bool follow_suggests);
<span class="lineNum"> 83 </span> :
<span class="lineNum"> 84 </span> : /** \brief Update the Marked field of all packages.
<span class="lineNum"> 85 </span> : *
<span class="lineNum"> 86 </span> : * Each package's StateCache::Marked field will be set to \b true
<span class="lineNum"> 87 </span> : * if and only if it can be reached from the root set. By
<span class="lineNum"> 88 </span> : * default, the root set consists of the set of manually installed
<span class="lineNum"> 89 </span> : * or essential packages, but it can be extended using the
<span class="lineNum"> 90 </span> : * parameter #rootFunc.
<span class="lineNum"> 91 </span> : *
<span class="lineNum"> 92 </span> : * \param rootFunc A callback that can be used to add extra
<span class="lineNum"> 93 </span> : * packages to the root set.
<span class="lineNum"> 94 </span> : *
<span class="lineNum"> 95 </span> : * \return \b false if an error occurred.
<span class="lineNum"> 96 </span> : */
<span class="lineNum"> 97 </span> : bool MarkRequired(InRootSetFunc &rootFunc);
<span class="lineNum"> 98 </span> :
<span class="lineNum"> 99 </span> : /** \brief Set the StateCache::Garbage flag on all packages that
<span class="lineNum"> 100 </span> : * should be removed.
<span class="lineNum"> 101 </span> : *
<span class="lineNum"> 102 </span> : * Packages that were not marked by the last call to #MarkRequired
<span class="lineNum"> 103 </span> : * are tested to see whether they are actually garbage. If so,
<span class="lineNum"> 104 </span> : * they are marked as such.
<span class="lineNum"> 105 </span> : *
<span class="lineNum"> 106 </span> : * \return \b false if an error occurred.
<span class="lineNum"> 107 </span> : */
<span class="lineNum"> 108 </span> : bool Sweep();
<span class="lineNum"> 109 </span> :
<span class="lineNum"> 110 </span> : public:
<span class="lineNum"> 111 </span> :
<span class="lineNum"> 112 </span> : // These flags are used in DepState
<span class="lineNum"> 113 </span> : enum DepFlags {DepNow = (1 << 0),DepInstall = (1 << 1),DepCVer = (1 << 2),
<span class="lineNum"> 114 </span> : DepGNow = (1 << 3),DepGInstall = (1 << 4),DepGCVer = (1 << 5)};
<span class="lineNum"> 115 </span> :
<span class="lineNum"> 116 </span> : // These flags are used in StateCache::DepState
<span class="lineNum"> 117 </span> : enum DepStateFlags {DepNowPolicy = (1 << 0), DepNowMin = (1 << 1),
<span class="lineNum"> 118 </span> : DepInstPolicy = (1 << 2), DepInstMin = (1 << 3),
<span class="lineNum"> 119 </span> : DepCandPolicy = (1 << 4), DepCandMin = (1 << 5)};
<span class="lineNum"> 120 </span> :
<span class="lineNum"> 121 </span> : // These flags are used in StateCache::iFlags
<span class="lineNum"> 122 </span> : enum InternalFlags {AutoKept = (1 << 0), Purge = (1 << 1), ReInstall = (1 << 2)};
<span class="lineNum"> 123 </span> :
<span class="lineNum"> 124 </span> : enum VersionTypes {NowVersion, InstallVersion, CandidateVersion};
<span class="lineNum"> 125 </span> : enum ModeList {ModeDelete = 0, ModeKeep = 1, ModeInstall = 2};
<span class="lineNum"> 126 </span> :
<span class="lineNum"> 127 </span> : /** \brief Represents an active action group.
<span class="lineNum"> 128 </span> : *
<span class="lineNum"> 129 </span> : * An action group is a group of actions that are currently being
<span class="lineNum"> 130 </span> : * performed. While an active group is active, certain routine
<span class="lineNum"> 131 </span> : * clean-up actions that would normally be performed after every
<span class="lineNum"> 132 </span> : * cache operation are delayed until the action group is
<span class="lineNum"> 133 </span> : * completed. This is necessary primarily to avoid inefficiencies
<span class="lineNum"> 134 </span> : * when modifying a large number of packages at once.
<span class="lineNum"> 135 </span> : *
<span class="lineNum"> 136 </span> : * This class represents an active action group. Creating an
<span class="lineNum"> 137 </span> : * instance will create an action group; destroying one will
<span class="lineNum"> 138 </span> : * destroy the corresponding action group.
<span class="lineNum"> 139 </span> : *
<span class="lineNum"> 140 </span> : * The following operations are suppressed by this class:
<span class="lineNum"> 141 </span> : *
<span class="lineNum"> 142 </span> : * - Keeping the Marked and Garbage flags up to date.
<span class="lineNum"> 143 </span> : *
<span class="lineNum"> 144 </span> : * \note This can be used in the future to easily accumulate
<span class="lineNum"> 145 </span> : * atomic actions for undo or to display "what apt did anyway";
<span class="lineNum"> 146 </span> : * e.g., change the counter of how many action groups are active
<span class="lineNum"> 147 </span> : * to a std::set of pointers to them and use those to store
<span class="lineNum"> 148 </span> : * information about what happened in a group in the group.
<span class="lineNum"> 149 </span> : */
<span class="lineNum"> 150 </span> : class ActionGroup
<span class="lineNum"> 151 </span> : {
<span class="lineNum"> 152 </span> : pkgDepCache &cache;
<span class="lineNum"> 153 </span> :
<span class="lineNum"> 154 </span> : bool released;
<span class="lineNum"> 155 </span> :
<span class="lineNum"> 156 </span> : /** Action groups are noncopyable. */
<span class="lineNum"> 157 </span> : ActionGroup(const ActionGroup &other);
<span class="lineNum"> 158 </span> : public:
<span class="lineNum"> 159 </span> : /** \brief Create a new ActionGroup.
<span class="lineNum"> 160 </span> : *
<span class="lineNum"> 161 </span> : * \param cache The cache that this ActionGroup should
<span class="lineNum"> 162 </span> : * manipulate.
<span class="lineNum"> 163 </span> : *
<span class="lineNum"> 164 </span> : * As long as this object exists, no automatic cleanup
<span class="lineNum"> 165 </span> : * operations will be undertaken.
<span class="lineNum"> 166 </span> : */
<span class="lineNum"> 167 </span> : ActionGroup(pkgDepCache &cache);
<span class="lineNum"> 168 </span> :
<span class="lineNum"> 169 </span> : /** \brief Clean up the action group before it is destroyed.
<span class="lineNum"> 170 </span> : *
<span class="lineNum"> 171 </span> : * If it is destroyed later, no second cleanup wil be run.
<span class="lineNum"> 172 </span> : */
<span class="lineNum"> 173 </span> : void release();
<span class="lineNum"> 174 </span> :
<span class="lineNum"> 175 </span> : /** \brief Destroy the action group.
<span class="lineNum"> 176 </span> : *
<span class="lineNum"> 177 </span> : * If this is the last action group, the automatic cache
<span class="lineNum"> 178 </span> : * cleanup operations will be undertaken.
<span class="lineNum"> 179 </span> : */
<span class="lineNum"> 180 </span> : ~ActionGroup();
<span class="lineNum"> 181 </span> : };
<span class="lineNum"> 182 </span> :
<span class="lineNum"> 183 </span> : /** \brief Returns \b true for packages matching a regular
<span class="lineNum"> 184 </span> : * expression in APT::NeverAutoRemove.
<span class="lineNum"> 185 </span> : */
<span class="lineNum"> 186 </span> : class DefaultRootSetFunc : public InRootSetFunc
<span class="lineNum"> 187 </span> : {
<span class="lineNum"> 188 </span> : std::vector<regex_t *> rootSetRegexp;
<span class="lineNum"> 189 </span> : bool constructedSuccessfully;
<span class="lineNum"> 190 </span> :
<span class="lineNum"> 191 </span> : public:
<span class="lineNum"> 192 </span> : DefaultRootSetFunc();
<span class="lineNum"> 193 </span> : ~DefaultRootSetFunc();
<span class="lineNum"> 194 </span> :
<span class="lineNum"> 195 </span> : /** \return \b true if the class initialized successfully, \b
<span class="lineNum"> 196 </span> : * false otherwise. Used to avoid throwing an exception, since
<span class="lineNum"> 197 </span> : * APT classes generally don't.
<span class="lineNum"> 198 </span> : */
<span class="lineNum"> 199 </span> : bool wasConstructedSuccessfully() const { return constructedSuccessfully; }
<span class="lineNum"> 200 </span> :
<span class="lineNum"> 201 </span> : bool InRootSet(const pkgCache::PkgIterator &pkg);
<span class="lineNum"> 202 </span> : };
<span class="lineNum"> 203 </span> :
<span class="lineNum"> 204 </span> : struct StateCache
<span class="lineNum"> 205 </span> : {
<span class="lineNum"> 206 </span> : // Epoch stripped text versions of the two version fields
<span class="lineNum"> 207 </span> : const char *CandVersion;
<span class="lineNum"> 208 </span> : const char *CurVersion;
<span class="lineNum"> 209 </span> :
<span class="lineNum"> 210 </span> : // Pointer to the candidate install version.
<span class="lineNum"> 211 </span> : Version *CandidateVer;
<span class="lineNum"> 212 </span> :
<span class="lineNum"> 213 </span> : // Pointer to the install version.
<span class="lineNum"> 214 </span> : Version *InstallVer;
<span class="lineNum"> 215 </span> :
<span class="lineNum"> 216 </span> : // Copy of Package::Flags
<span class="lineNum"> 217 </span> : unsigned short Flags;
<span class="lineNum"> 218 </span> : unsigned short iFlags; // Internal flags
<span class="lineNum"> 219 </span> :
<span class="lineNum"> 220 </span> : /** \brief \b true if this package can be reached from the root set. */
<span class="lineNum"> 221 </span> : bool Marked;
<span class="lineNum"> 222 </span> :
<span class="lineNum"> 223 </span> : /** \brief \b true if this package is unused and should be removed.
<span class="lineNum"> 224 </span> : *
<span class="lineNum"> 225 </span> : * This differs from !#Marked, because it is possible that some
<span class="lineNum"> 226 </span> : * unreachable packages will be protected from becoming
<span class="lineNum"> 227 </span> : * garbage.
<span class="lineNum"> 228 </span> : */
<span class="lineNum"> 229 </span> : bool Garbage;
<span class="lineNum"> 230 </span> :
<span class="lineNum"> 231 </span> : // Various tree indicators
<span class="lineNum"> 232 </span> : signed char Status; // -1,0,1,2
<span class="lineNum"> 233 </span> : unsigned char Mode; // ModeList
<span class="lineNum"> 234 </span> : unsigned char DepState; // DepState Flags
<span class="lineNum"> 235 </span> :
<span class="lineNum"> 236 </span> : // Update of candidate version
<span class="lineNum"> 237 </span> : const char *StripEpoch(const char *Ver);
<span class="lineNum"> 238 </span> : void Update(PkgIterator Pkg,pkgCache &Cache);
<span class="lineNum"> 239 </span> :
<span class="lineNum"> 240 </span> : // Various test members for the current status of the package
<span class="lineNum"> 241 </span> : inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;};
<span class="lineNum"> 242 </span><span class="lineCov"> 3785 : inline bool Delete() const {return Mode == ModeDelete;};</span>
<span class="lineNum"> 243 </span><span class="lineCov"> 3785 : inline bool Keep() const {return Mode == ModeKeep;};</span>
<span class="lineNum"> 244 </span> : inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
<span class="lineNum"> 245 </span> : inline bool Upgradable() const {return Status >= 1;};
<span class="lineNum"> 246 </span> : inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;};
<span class="lineNum"> 247 </span> : inline bool Held() const {return Status != 0 && Keep();};
<span class="lineNum"> 248 </span><span class="lineCov"> 3785 : inline bool NowBroken() const {return (DepState & DepNowMin) != DepNowMin;};</span>
<span class="lineNum"> 249 </span> : inline bool NowPolicyBroken() const {return (DepState & DepNowPolicy) != DepNowPolicy;};
<span class="lineNum"> 250 </span><span class="lineCov"> 3785 : inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};</span>
<span class="lineNum"> 251 </span> : inline bool InstPolicyBroken() const {return (DepState & DepInstPolicy) != DepInstPolicy;};
<span class="lineNum"> 252 </span><span class="lineCov"> 3785 : inline bool Install() const {return Mode == ModeInstall;};</span>
<span class="lineNum"> 253 </span> : inline VerIterator InstVerIter(pkgCache &Cache)
<span class="lineNum"> 254 </span> : {return VerIterator(Cache,InstallVer);};
<span class="lineNum"> 255 </span> : inline VerIterator CandidateVerIter(pkgCache &Cache)
<span class="lineNum"> 256 </span> : {return VerIterator(Cache,CandidateVer);};
<span class="lineNum"> 257 </span> : };
<span class="lineNum"> 258 </span> :
<span class="lineNum"> 259 </span> : // Helper functions
<span class="lineNum"> 260 </span> : void BuildGroupOrs(VerIterator const &V);
<span class="lineNum"> 261 </span> : void UpdateVerState(PkgIterator Pkg);
<span class="lineNum"> 262 </span> :
<span class="lineNum"> 263 </span> : // User Policy control
<span class="lineNum"> 264 </span> : class Policy
<span class="lineNum"> 265 </span> : {
<span class="lineNum"> 266 </span> : public:
<span class="lineNum"> 267 </span> :
<span class="lineNum"> 268 </span> : virtual VerIterator GetCandidateVer(PkgIterator Pkg);
<span class="lineNum"> 269 </span> : virtual bool IsImportantDep(DepIterator Dep);
<span class="lineNum"> 270 </span> :
<span class="lineNum"> 271 </span> : virtual ~Policy() {};
<span class="lineNum"> 272 </span> : };
<span class="lineNum"> 273 </span> :
<span class="lineNum"> 274 </span> : private:
<span class="lineNum"> 275 </span> : /** The number of open "action groups"; certain post-action
<span class="lineNum"> 276 </span> : * operations are suppressed if this number is > 0.
<span class="lineNum"> 277 </span> : */
<span class="lineNum"> 278 </span> : int group_level;
<span class="lineNum"> 279 </span> :
<span class="lineNum"> 280 </span> : friend class ActionGroup;
<span class="lineNum"> 281 </span> :
<span class="lineNum"> 282 </span> : protected:
<span class="lineNum"> 283 </span> :
<span class="lineNum"> 284 </span> : // State information
<span class="lineNum"> 285 </span> : pkgCache *Cache;
<span class="lineNum"> 286 </span> : StateCache *PkgState;
<span class="lineNum"> 287 </span> : unsigned char *DepState;
<span class="lineNum"> 288 </span> :
<span class="lineNum"> 289 </span> : double iUsrSize;
<span class="lineNum"> 290 </span> : double iDownloadSize;
<span class="lineNum"> 291 </span> : unsigned long iInstCount;
<span class="lineNum"> 292 </span> : unsigned long iDelCount;
<span class="lineNum"> 293 </span> : unsigned long iKeepCount;
<span class="lineNum"> 294 </span> : unsigned long iBrokenCount;
<span class="lineNum"> 295 </span> : unsigned long iPolicyBrokenCount;
<span class="lineNum"> 296 </span> : unsigned long iBadCount;
<span class="lineNum"> 297 </span> :
<span class="lineNum"> 298 </span> : Policy *delLocalPolicy; // For memory clean up..
<span class="lineNum"> 299 </span> : Policy *LocalPolicy;
<span class="lineNum"> 300 </span> :
<span class="lineNum"> 301 </span> : // Check for a matching provides
<span class="lineNum"> 302 </span> : bool CheckDep(DepIterator Dep,int Type,PkgIterator &Res);
<span class="lineNum"> 303 </span> : inline bool CheckDep(DepIterator Dep,int Type)
<span class="lineNum"> 304 </span> : {
<span class="lineNum"> 305 </span> : PkgIterator Res(*this,0);
<span class="lineNum"> 306 </span> : return CheckDep(Dep,Type,Res);
<span class="lineNum"> 307 </span> : }
<span class="lineNum"> 308 </span> :
<span class="lineNum"> 309 </span> : // Computes state information for deps and versions (w/o storing)
<span class="lineNum"> 310 </span> : unsigned char DependencyState(DepIterator &D);
<span class="lineNum"> 311 </span> : unsigned char VersionState(DepIterator D,unsigned char Check,
<span class="lineNum"> 312 </span> : unsigned char SetMin,
<span class="lineNum"> 313 </span> : unsigned char SetPolicy);
<span class="lineNum"> 314 </span> :
<span class="lineNum"> 315 </span> : // Recalculates various portions of the cache, call after changing something
<span class="lineNum"> 316 </span> : void Update(DepIterator Dep); // Mostly internal
<span class="lineNum"> 317 </span> : void Update(PkgIterator const &P);
<span class="lineNum"> 318 </span> :
<span class="lineNum"> 319 </span> : // Count manipulators
<span class="lineNum"> 320 </span> : void AddSizes(const PkgIterator &Pkg,signed long Mult = 1);
<span class="lineNum"> 321 </span> : inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg,-1);};
<span class="lineNum"> 322 </span> : void AddStates(const PkgIterator &Pkg,int Add = 1);
<span class="lineNum"> 323 </span> : inline void RemoveStates(const PkgIterator &Pkg) {AddStates(Pkg,-1);};
<span class="lineNum"> 324 </span> :
<span class="lineNum"> 325 </span> : public:
<span class="lineNum"> 326 </span> :
<span class="lineNum"> 327 </span> : // Legacy.. We look like a pkgCache
<span class="lineNum"> 328 </span> : inline operator pkgCache &() {return *Cache;};
<span class="lineNum"> 329 </span> : inline Header &Head() {return *Cache->HeaderP;};
<span class="lineNum"> 330 </span> : inline PkgIterator PkgBegin() {return Cache->PkgBegin();};
<span class="lineNum"> 331 </span> : inline PkgIterator FindPkg(string const &Name) {return Cache->FindPkg(Name);};
<span class="lineNum"> 332 </span> :
<span class="lineNum"> 333 </span> : inline pkgCache &GetCache() {return *Cache;};
<span class="lineNum"> 334 </span> : inline pkgVersioningSystem &VS() {return *Cache->VS;};
<span class="lineNum"> 335 </span> :
<span class="lineNum"> 336 </span> : // Policy implementation
<span class="lineNum"> 337 </span> : inline VerIterator GetCandidateVer(PkgIterator Pkg) {return LocalPolicy->GetCandidateVer(Pkg);};
<span class="lineNum"> 338 </span> : inline bool IsImportantDep(DepIterator Dep) {return LocalPolicy->IsImportantDep(Dep);};
<span class="lineNum"> 339 </span> : inline Policy &GetPolicy() {return *LocalPolicy;};
<span class="lineNum"> 340 </span> :
<span class="lineNum"> 341 </span> : // Accessors
<span class="lineNum"> 342 </span><span class="lineCov"> 3787 : inline StateCache &operator [](PkgIterator const &I) {return PkgState[I->ID];};</span>
<span class="lineNum"> 343 </span> : inline unsigned char &operator [](DepIterator const &I) {return DepState[I->ID];};
<span class="lineNum"> 344 </span> :
<span class="lineNum"> 345 </span> : /** \return A function identifying packages in the root set other
<span class="lineNum"> 346 </span> : * than manually installed packages and essential packages, or \b
<span class="lineNum"> 347 </span> : * NULL if an error occurs.
<span class="lineNum"> 348 </span> : *
<span class="lineNum"> 349 </span> : * \todo Is this the best place for this function? Perhaps the
<span class="lineNum"> 350 </span> : * settings for mark-and-sweep should be stored in a single
<span class="lineNum"> 351 </span> : * external class?
<span class="lineNum"> 352 </span> : */
<span class="lineNum"> 353 </span> : virtual InRootSetFunc *GetRootSetFunc();
<span class="lineNum"> 354 </span> :
<span class="lineNum"> 355 </span> : /** \return \b true if the garbage collector should follow recommendations.
<span class="lineNum"> 356 </span> : */
<span class="lineNum"> 357 </span> : virtual bool MarkFollowsRecommends();
<span class="lineNum"> 358 </span> :
<span class="lineNum"> 359 </span> : /** \return \b true if the garbage collector should follow suggestions.
<span class="lineNum"> 360 </span> : */
<span class="lineNum"> 361 </span> : virtual bool MarkFollowsSuggests();
<span class="lineNum"> 362 </span> :
<span class="lineNum"> 363 </span> : /** \brief Update the Marked and Garbage fields of all packages.
<span class="lineNum"> 364 </span> : *
<span class="lineNum"> 365 </span> : * This routine is implicitly invoked after all state manipulators
<span class="lineNum"> 366 </span> : * and when an ActionGroup is destroyed. It invokes #MarkRequired
<span class="lineNum"> 367 </span> : * and #Sweep to do its dirty work.
<span class="lineNum"> 368 </span> : *
<span class="lineNum"> 369 </span> : * \param rootFunc A predicate that returns \b true for packages
<span class="lineNum"> 370 </span> : * that should be added to the root set.
<span class="lineNum"> 371 </span> : */
<span class="lineNum"> 372 </span> : bool MarkAndSweep(InRootSetFunc &rootFunc)
<span class="lineNum"> 373 </span> : {
<span class="lineNum"> 374 </span> : return MarkRequired(rootFunc) && Sweep();
<span class="lineNum"> 375 </span> : }
<span class="lineNum"> 376 </span> :
<span class="lineNum"> 377 </span> : bool MarkAndSweep()
<span class="lineNum"> 378 </span> : {
<span class="lineNum"> 379 </span> : std::auto_ptr<InRootSetFunc> f(GetRootSetFunc());
<span class="lineNum"> 380 </span> : if(f.get() != NULL)
<span class="lineNum"> 381 </span> : return MarkAndSweep(*f.get());
<span class="lineNum"> 382 </span> : else
<span class="lineNum"> 383 </span> : return false;
<span class="lineNum"> 384 </span> : }
<span class="lineNum"> 385 </span> :
<span class="lineNum"> 386 </span> : /** \name State Manipulators
<span class="lineNum"> 387 </span> : */
<span class="lineNum"> 388 </span> : // @{
<span class="lineNum"> 389 </span> : void MarkKeep(PkgIterator const &Pkg, bool Soft = false,
<span class="lineNum"> 390 </span> : bool FromUser = true);
<span class="lineNum"> 391 </span> : void MarkDelete(PkgIterator const &Pkg,bool Purge = false);
<span class="lineNum"> 392 </span> : void MarkInstall(PkgIterator const &Pkg,bool AutoInst = true,
<span class="lineNum"> 393 </span> : unsigned long Depth = 0, bool FromUser = true,
<span class="lineNum"> 394 </span> : bool ForceImportantDeps = false);
<span class="lineNum"> 395 </span> : void SetReInstall(PkgIterator const &Pkg,bool To);
<span class="lineNum"> 396 </span> : void SetCandidateVersion(VerIterator TargetVer);
<span class="lineNum"> 397 </span> :
<span class="lineNum"> 398 </span> : /** Set the "is automatically installed" flag of Pkg. */
<span class="lineNum"> 399 </span> : void MarkAuto(const PkgIterator &Pkg, bool Auto);
<span class="lineNum"> 400 </span> : // @}
<span class="lineNum"> 401 </span> :
<span class="lineNum"> 402 </span> : // This is for debuging
<span class="lineNum"> 403 </span> : void Update(OpProgress *Prog = 0);
<span class="lineNum"> 404 </span> :
<span class="lineNum"> 405 </span> : // read persistent states
<span class="lineNum"> 406 </span> : bool readStateFile(OpProgress *prog);
<span class="lineNum"> 407 </span> : bool writeStateFile(OpProgress *prog, bool InstalledOnly=false);
<span class="lineNum"> 408 </span> :
<span class="lineNum"> 409 </span> : // Size queries
<span class="lineNum"> 410 </span> : inline double UsrSize() {return iUsrSize;};
<span class="lineNum"> 411 </span> : inline double DebSize() {return iDownloadSize;};
<span class="lineNum"> 412 </span> : inline unsigned long DelCount() {return iDelCount;};
<span class="lineNum"> 413 </span> : inline unsigned long KeepCount() {return iKeepCount;};
<span class="lineNum"> 414 </span> : inline unsigned long InstCount() {return iInstCount;};
<span class="lineNum"> 415 </span> : inline unsigned long BrokenCount() {return iBrokenCount;};
<span class="lineNum"> 416 </span> : inline unsigned long PolicyBrokenCount() {return iPolicyBrokenCount;};
<span class="lineNum"> 417 </span> : inline unsigned long BadCount() {return iBadCount;};
<span class="lineNum"> 418 </span> :
<span class="lineNum"> 419 </span> : bool Init(OpProgress *Prog);
<span class="lineNum"> 420 </span> :
<span class="lineNum"> 421 </span> : pkgDepCache(pkgCache *Cache,Policy *Plcy = 0);
<span class="lineNum"> 422 </span> : virtual ~pkgDepCache();
<span class="lineNum"> 423 </span> : };
<span class="lineNum"> 424 </span> :
<span class="lineNum"> 425 </span> : #endif
</pre>
</td>
</tr>
</table>
<br>
<table width="100%" border=0 cellspacing=0 cellpadding=0>
<tr><td class="ruler"><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>
<tr><td class="versionInfo">Generated by: <a href="http://ltp.sourceforge.net/coverage/lcov.php" target="_parent">LTP GCOV extension version 1.6</a></td></tr>
</table>
<br>
</body>
</html>
|
