- initial import of revision 374 from cnc
[apt.git] / apt-pkg / depcache.h
1 // -*- mode: cpp; mode: fold -*-
2 // Description                                                          /*{{{*/
3 // $Id: depcache.h,v 1.2 2003/01/29 13:04:48 niemeyer Exp $
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                                                                         /*}}}*/
38 #ifndef PKGLIB_DEPCACHE_H
39 #define PKGLIB_DEPCACHE_H
40
41 #ifdef __GNUG__
42 #pragma interface "apt-pkg/depcache.h"
43 #endif
44
45 #include <apt-pkg/pkgcache.h>
46 #include <apt-pkg/progress.h>
47
48 class pkgDepCache : protected pkgCache::Namespace
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
62    enum InternalFlags {AutoKept = (1 << 0), Purge = (1 << 1), ReInstall = (1 << 2)};
63       
64    enum VersionTypes {NowVersion, InstallVersion, CandidateVersion};
65    enum ModeList {ModeDelete = 0, ModeKeep = 1, ModeInstall = 2};
66    struct StateCache
67    {
68       // Epoch stripped text versions of the two version fields
69       const char *CandVersion;
70       const char *CurVersion;
71
72       // Pointer to the candidate install version. 
73       Version *CandidateVer;
74
75       // Pointer to the install version.
76       Version *InstallVer;
77       
78       // Copy of Package::Flags
79       unsigned short Flags;
80       unsigned short iFlags;           // Internal flags
81
82       // Various tree indicators
83       signed char Status;              // -1,0,1,2
84       unsigned char Mode;              // ModeList
85       unsigned char DepState;          // DepState Flags
86
87       // Update of candidate version
88       const char *StripEpoch(const char *Ver);
89       void Update(PkgIterator Pkg,pkgCache &Cache);
90       
91       // Various test members for the current status of the package
92       inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;};
93       inline bool Delete() const {return Mode == ModeDelete;};
94       inline bool Keep() const {return Mode == ModeKeep;};
95       inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
96       inline bool Upgradable() const {return Status >= 1;};
97       inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;};
98       inline bool Held() const {return Status != 0 && Keep();};
99       inline bool NowBroken() const {return (DepState & DepNowMin) != DepNowMin;};
100       inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};
101       inline bool Install() const {return Mode == ModeInstall;};
102       inline VerIterator InstVerIter(pkgCache &Cache)
103                 {return VerIterator(Cache,InstallVer);};
104       inline VerIterator CandidateVerIter(pkgCache &Cache)
105                 {return VerIterator(Cache,CandidateVer);};
106    };
107    
108    // Helper functions
109    void BuildGroupOrs(VerIterator const &V);
110    void UpdateVerState(PkgIterator Pkg);
111
112    // User Policy control
113    class Policy
114    {
115       public:
116       
117       virtual VerIterator GetCandidateVer(PkgIterator Pkg);
118       virtual bool IsImportantDep(DepIterator Dep);
119       // CNC:2003-03-05 - We need access to the priority in pkgDistUpgrade
120       //                  while checking for obsoleting packages.
121       virtual signed short GetPkgPriority(pkgCache::PkgIterator const &Pkg)
122          { return 0; };
123       
124       virtual ~Policy() {};
125    };
126      
127    protected:
128
129    // State information
130    pkgCache *Cache;
131    StateCache *PkgState;
132    unsigned char *DepState;
133    
134    double iUsrSize;
135    double iDownloadSize;
136    unsigned long iInstCount;
137    unsigned long iDelCount;
138    unsigned long iKeepCount;
139    unsigned long iBrokenCount;
140    unsigned long iBadCount;
141    
142    Policy *delLocalPolicy;           // For memory clean up..
143    Policy *LocalPolicy;
144    
145    // Check for a matching provides
146    bool CheckDep(DepIterator Dep,int Type,PkgIterator &Res);
147    inline bool CheckDep(DepIterator Dep,int Type)
148    {
149       PkgIterator Res(*this,0);
150       return CheckDep(Dep,Type,Res);
151    }
152    
153    // Computes state information for deps and versions (w/o storing)
154    unsigned char DependencyState(DepIterator &D);
155    unsigned char VersionState(DepIterator D,unsigned char Check,
156                               unsigned char SetMin,
157                               unsigned char SetPolicy);
158
159    // Recalculates various portions of the cache, call after changing something
160    void Update(DepIterator Dep);           // Mostly internal
161    void Update(PkgIterator const &P);
162    
163    // Count manipulators
164    void AddSizes(const PkgIterator &Pkg,signed long Mult = 1);
165    inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg,-1);};
166    void AddStates(const PkgIterator &Pkg,int Add = 1);
167    inline void RemoveStates(const PkgIterator &Pkg) {AddStates(Pkg,-1);};
168    
169    public:
170
171    // CNC:2003-02-23 - See below.
172    class State;
173    friend class State;
174    
175    // Legacy.. We look like a pkgCache
176    inline operator pkgCache &() {return *Cache;};
177    inline Header &Head() {return *Cache->HeaderP;};
178    inline PkgIterator PkgBegin() {return Cache->PkgBegin();};
179    inline PkgIterator FindPkg(string const &Name) {return Cache->FindPkg(Name);};
180
181    inline pkgCache &GetCache() {return *Cache;};
182    inline pkgVersioningSystem &VS() {return *Cache->VS;};
183    
184    // Policy implementation
185    inline VerIterator GetCandidateVer(PkgIterator Pkg) {return LocalPolicy->GetCandidateVer(Pkg);};
186    inline bool IsImportantDep(DepIterator Dep) {return LocalPolicy->IsImportantDep(Dep);};
187    inline Policy &GetPolicy() {return *LocalPolicy;};
188    // CNC:2003-03-05 - See above.
189    inline signed short GetPkgPriority(pkgCache::PkgIterator const &Pkg) {return LocalPolicy->GetPkgPriority(Pkg);};
190    
191    // Accessors
192    inline StateCache &operator [](PkgIterator const &I) {return PkgState[I->ID];};
193    inline unsigned char &operator [](DepIterator const &I) {return DepState[I->ID];};
194
195    // Manipulators
196    void MarkKeep(PkgIterator const &Pkg,bool Soft = false);
197    void MarkDelete(PkgIterator const &Pkg,bool Purge = false);
198    void MarkInstall(PkgIterator const &Pkg,bool AutoInst = true,
199                     unsigned long Depth = 0);
200    void SetReInstall(PkgIterator const &Pkg,bool To);
201    void SetCandidateVersion(VerIterator TargetVer);
202    
203    // This is for debuging
204    void Update(OpProgress *Prog = 0);
205    
206    // Size queries
207    inline double UsrSize() {return iUsrSize;};
208    inline double DebSize() {return iDownloadSize;};
209    inline unsigned long DelCount() {return iDelCount;};
210    inline unsigned long KeepCount() {return iKeepCount;};
211    inline unsigned long InstCount() {return iInstCount;};
212    inline unsigned long BrokenCount() {return iBrokenCount;};
213    inline unsigned long BadCount() {return iBadCount;};
214
215    bool Init(OpProgress *Prog);
216    
217    pkgDepCache(pkgCache *Cache,Policy *Plcy = 0);
218    virtual ~pkgDepCache();
219 };
220
221 // CNC:2003-02-24 - Class to work on the state of a depcache.
222 class pkgDepCache::State
223 {
224    protected:
225
226    pkgDepCache *Dep;
227
228    StateCache *PkgState;
229    unsigned char *DepState;
230    double iUsrSize;
231    double iDownloadSize;
232    unsigned long iInstCount;
233    unsigned long iDelCount;
234    unsigned long iKeepCount;
235    unsigned long iBrokenCount;
236    unsigned long iBadCount;
237    
238    bool *PkgIgnore;
239       
240    public:
241
242    void Save(pkgDepCache *Dep);
243    void Restore();
244    bool Changed();
245
246    void Ignore(PkgIterator const &I) {PkgIgnore[I->ID] = true;};
247    void UnIgnore(PkgIterator const &I) {PkgIgnore[I->ID] = false;};
248    bool Ignored(PkgIterator const &I) {return PkgIgnore[I->ID];};
249    void UnIgnoreAll();
250
251    StateCache &operator [](pkgCache::PkgIterator const &I) {return PkgState[I->ID];};
252
253    // Size queries
254    inline double UsrSize() {return iUsrSize;};
255    inline double DebSize() {return iDownloadSize;};
256    inline unsigned long DelCount() {return iDelCount;};
257    inline unsigned long KeepCount() {return iKeepCount;};
258    inline unsigned long InstCount() {return iInstCount;};
259    inline unsigned long BrokenCount() {return iBrokenCount;};
260    inline unsigned long BadCount() {return iBadCount;};
261
262    void Copy(State const &Other);
263    void operator =(State const &Other)
264       {
265          delete[] PkgState;
266          delete[] DepState;
267          delete[] PkgIgnore;
268          Copy(Other);
269       };
270    State(const State &Other)
271       { Copy(Other); };
272    State(pkgDepCache *Dep=NULL)
273          : Dep(0), PkgState(0), DepState(0), PkgIgnore(0)
274       { if (Dep != NULL) Save(Dep); };
275    ~State()
276       {
277          delete[] PkgState;
278          delete[] DepState;
279          delete[] PkgIgnore;
280       };
281 };
282
283
284 /* This is an exact copy of the structure above, nested in pkgDepCache.
285  * This is defined again here since SWIG doesn't know how to handle nested
286  * structures yet. It will be dropped once that situation changes. */
287 #ifdef SWIG
288    struct pkgDepCache::StateCache
289    {
290       // Epoch stripped text versions of the two version fields
291       const char *CandVersion;
292       const char *CurVersion;
293
294       // Pointer to the candidate install version. 
295       Version *CandidateVer;
296
297       // Pointer to the install version.
298       Version *InstallVer;
299       
300       // Copy of Package::Flags
301       unsigned short Flags;
302       unsigned short iFlags;           // Internal flags
303
304       // Various tree indicators
305       signed char Status;              // -1,0,1,2
306       unsigned char Mode;              // ModeList
307       unsigned char DepState;          // DepState Flags
308
309       // Update of candidate version
310       const char *StripEpoch(const char *Ver);
311       void Update(PkgIterator Pkg,pkgCache &Cache);
312       
313       // Various test members for the current status of the package
314       inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;};
315       inline bool Delete() const {return Mode == ModeDelete;};
316       inline bool Keep() const {return Mode == ModeKeep;};
317       inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
318       inline bool Upgradable() const {return Status >= 1;};
319       inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;};
320       inline bool Held() const {return Status != 0 && Keep();};
321       inline bool NowBroken() const {return (DepState & DepNowMin) != DepNowMin;};
322       inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};
323       inline bool Install() const {return Mode == ModeInstall;};
324       inline VerIterator InstVerIter(pkgCache &Cache)
325                 {return VerIterator(Cache,InstallVer);};
326       inline VerIterator CandidateVerIter(pkgCache &Cache)
327                 {return VerIterator(Cache,CandidateVer);};
328    };
329 #endif
330
331 #endif
332
333 // vim:sts=3:sw=3