a3c837d8a767a02f9c4a3ce87f54102640364afc
[apt.git] / apt-pkg / cacheiterators.h
1 // -*- mode: c++; mode: fold -*-
2 // Description                                                          /*{{{*/
3 // $Id: cacheiterators.h,v 1.18 2003/10/09 23:15:25 mdz Exp $
4 /* ######################################################################
5    
6    Cache Iterators - Iterators for navigating the cache structure
7    
8    The iterators all provides ++,==,!=,->,* and end for their type.
9    The end function can be used to tell if the list has been fully
10    traversed.
11    
12    Unlike STL iterators these contain helper functions to access the data
13    that is being iterated over. This is because the data structures can't
14    be formed in a manner that is intuitive to use and also mmapable.
15    
16    For each variable in the target structure that would need a translation
17    to be accessed correctly a translating function of the same name is
18    present in the iterator. If applicable the translating function will
19    return an iterator.
20
21    The DepIterator can iterate over two lists, a list of 'version depends'
22    or a list of 'package reverse depends'. The type is determined by the
23    structure passed to the constructor, which should be the structure
24    that has the depends pointer as a member. The provide iterator has the
25    same system.
26    
27    This header is not user includable, please use apt-pkg/pkgcache.h
28    
29    ##################################################################### */
30                                                                         /*}}}*/
31 #ifndef PKGLIB_CACHEITERATORS_H
32 #define PKGLIB_CACHEITERATORS_H
33
34 #ifdef __GNUG__
35 #pragma interface "apt-pkg/cacheiterators.h"
36 #endif 
37
38 // Package Iterator
39 class pkgCache::PkgIterator
40 {
41    friend class pkgCache;
42    Package *Pkg;
43    pkgCache *Owner;
44    long HashIndex;
45
46    protected:
47    
48    // This constructor is the 'begin' constructor, never use it.
49    inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
50    {
51       Pkg = Owner.PkgP;
52       operator ++(0);
53    };
54    
55    public:
56
57    enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
58       
59    // Iteration
60    void operator ++(int);
61    inline void operator ++() {operator ++(0);};
62    inline bool end() const {return Owner == 0 || Pkg == Owner->PkgP?true:false;};
63
64    // Comparison
65    inline bool operator ==(const PkgIterator &B) const {return Pkg == B.Pkg;};
66    inline bool operator !=(const PkgIterator &B) const {return Pkg != B.Pkg;};
67                            
68    // Accessors
69    inline Package *operator ->() {return Pkg;};
70    inline Package const *operator ->() const {return Pkg;};
71    inline Package const &operator *() const {return *Pkg;};
72    inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
73    inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
74    inline pkgCache *Cache() {return Owner;};
75    
76    inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
77    inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
78    inline bool Purge() const {return Pkg->CurrentState == pkgCache::State::Purge ||
79          (Pkg->CurrentVer == 0 && Pkg->CurrentState == pkgCache::State::NotInstalled);};
80    inline VerIterator VersionList() const;
81    inline VerIterator TargetVer() const;
82    inline VerIterator CurrentVer() const;
83    inline DepIterator RevDependsList() const;
84    inline PrvIterator ProvidesList() const;
85    inline unsigned long Index() const {return Pkg - Owner->PkgP;};
86    OkState State() const;
87    
88    // Constructors
89    inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
90           HashIndex(0) 
91    { 
92       if (Pkg == 0)
93          Pkg = Owner.PkgP;
94    };
95    inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
96 };
97
98 // Version Iterator
99 class pkgCache::VerIterator
100 {
101    Version *Ver;
102    pkgCache *Owner;
103    
104    void _dummy();
105    
106    public:
107
108    // Iteration
109    void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
110    inline void operator ++() {operator ++(0);};
111    inline bool end() const {return Ver == Owner->VerP?true:false;};
112    inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
113    
114    // Comparison
115    inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
116    inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
117    int CompareVer(const VerIterator &B) const;
118    
119    // Accessors
120    inline Version *operator ->() {return Ver;};
121    inline Version const *operator ->() const {return Ver;};
122    inline Version &operator *() {return *Ver;};
123    inline Version const &operator *() const {return *Ver;};
124    inline operator Version *() {return Ver == Owner->VerP?0:Ver;};
125    inline operator Version const *() const {return Ver == Owner->VerP?0:Ver;};
126    inline pkgCache *Cache() {return Owner;};
127       
128    inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner->StrP + Ver->VerStr;};
129    inline const char *Section() const {return Ver->Section == 0?0:Owner->StrP + Ver->Section;};
130    inline const char *Arch() const {return Ver->Arch == 0?0:Owner->StrP + Ver->Arch;};
131    inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Ver->ParentPkg);};
132    inline DepIterator DependsList() const;
133    inline PrvIterator ProvidesList() const;
134    inline VerFileIterator FileList() const;
135    inline unsigned long Index() const {return Ver - Owner->VerP;};
136    bool Downloadable() const;
137    inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
138    string RelStr();
139    
140    bool Automatic() const;
141    VerFileIterator NewestFile() const;
142
143    inline VerIterator() : Ver(0), Owner(0) {};   
144    inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), 
145               Owner(&Owner) 
146    { 
147       if (Ver == 0)
148          Ver = Owner.VerP;
149    };
150 };
151
152 // Dependency iterator
153 class pkgCache::DepIterator
154 {
155    Dependency *Dep;
156    enum {DepVer, DepRev} Type;
157    pkgCache *Owner;
158    
159    void _dummy();
160    
161    public:
162
163    // Iteration
164    void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
165         (Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
166    inline void operator ++() {operator ++(0);};
167    inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
168    
169    // Comparison
170    inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
171    inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
172
173    // Accessors
174    inline Dependency *operator ->() {return Dep;};
175    inline Dependency const *operator ->() const {return Dep;};
176    inline Dependency &operator *() {return *Dep;};
177    inline Dependency const &operator *() const {return *Dep;};
178    inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
179    inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
180    inline pkgCache *Cache() {return Owner;};
181    
182    inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
183    inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
184    inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
185    inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
186    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
187    inline bool Reverse() {return Type == DepRev;};
188    inline unsigned long Index() const {return Dep - Owner->DepP;};
189    // CNC:2003-02-17 - This is a very used function, so it's now
190    //                  inlined here.
191    inline bool IsCritical()
192                 {
193                         switch (Dep->Type) {
194                                 case pkgCache::Dep::Conflicts:
195                                 case pkgCache::Dep::Obsoletes:
196                                 case pkgCache::Dep::Depends:
197                                 case pkgCache::Dep::PreDepends:
198                                         return true;
199                                 default:
200                                         return false;
201                         }
202                 }
203    void GlobOr(DepIterator &Start,DepIterator &End);
204    Version **AllTargets();   
205    bool SmartTargetPkg(PkgIterator &Result);
206    inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
207    inline const char *DepType() {return Owner->DepType(Dep->Type);};
208    
209    inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
210           Dep(Trg), Type(DepVer), Owner(&Owner) 
211    {
212       if (Dep == 0)
213          Dep = Owner.DepP;
214    };
215    inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
216           Dep(Trg), Type(DepRev), Owner(&Owner)
217    {
218       if (Dep == 0)
219          Dep = Owner.DepP;
220    };
221    inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
222 };
223
224 // Provides iterator
225 class pkgCache::PrvIterator
226 {
227    Provides *Prv;
228    enum {PrvVer, PrvPkg} Type;
229    pkgCache *Owner;
230    
231    void _dummy();
232    
233    public:
234
235    // Iteration
236    void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
237         (Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
238    inline void operator ++() {operator ++(0);};
239    inline bool end() const {return Prv == Owner->ProvideP?true:false;};
240    
241    // Comparison
242    inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
243    inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
244
245    // Accessors
246    inline Provides *operator ->() {return Prv;};
247    inline Provides const *operator ->() const {return Prv;};
248    inline Provides &operator *() {return *Prv;};
249    inline Provides const &operator *() const {return *Prv;};
250    inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
251    inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
252    inline pkgCache *Cache() {return Owner;};
253
254    inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
255    inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
256    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
257    inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
258    inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
259    inline unsigned long Index() const {return Prv - Owner->ProvideP;};
260
261    inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
262           Prv(Trg), Type(PrvVer), Owner(&Owner) 
263    {
264       if (Prv == 0)
265          Prv = Owner.ProvideP;
266    };
267    inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) : 
268           Prv(Trg), Type(PrvPkg), Owner(&Owner)
269    {
270       if (Prv == 0)
271          Prv = Owner.ProvideP;
272    };
273 };
274
275 // Package file 
276 class pkgCache::PkgFileIterator
277 {
278    pkgCache *Owner;
279    PackageFile *File;
280
281    public:
282
283    // Iteration
284    void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
285    inline void operator ++() {operator ++(0);};
286    inline bool end() const {return File == Owner->PkgFileP?true:false;};
287
288    // Comparison
289    inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
290    inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
291                            
292    // Accessors
293    inline PackageFile *operator ->() {return File;};
294    inline PackageFile const *operator ->() const {return File;};
295    inline PackageFile const &operator *() const {return *File;};
296    inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
297    inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
298    inline pkgCache *Cache() {return Owner;};
299
300    inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
301    inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
302    inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
303    inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
304    inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
305    inline const char *Label() const {return File->Label == 0?0:Owner->StrP + File->Label;};
306    inline const char *Site() const {return File->Site == 0?0:Owner->StrP + File->Site;};
307    inline const char *Architecture() const {return File->Architecture == 0?0:Owner->StrP + File->Architecture;};
308    inline const char *IndexType() const {return File->IndexType == 0?0:Owner->StrP + File->IndexType;};
309
310    inline unsigned long Index() const {return File - Owner->PkgFileP;};
311
312    bool IsOk();
313    string RelStr();
314    
315    // Constructors
316    inline PkgFileIterator() : Owner(0), File(0) {};
317    inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
318    inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
319 };
320
321 // Version File 
322 class pkgCache::VerFileIterator
323 {
324    pkgCache *Owner;
325    VerFile *FileP;
326
327    public:
328
329    // Iteration
330    void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
331    inline void operator ++() {operator ++(0);};
332    inline bool end() const {return FileP == Owner->VerFileP?true:false;};
333
334    // Comparison
335    inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
336    inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
337                            
338    // Accessors
339    inline VerFile *operator ->() {return FileP;};
340    inline VerFile const *operator ->() const {return FileP;};
341    inline VerFile const &operator *() const {return *FileP;};
342    inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
343    inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
344    inline pkgCache *Cache() {return Owner;};
345   
346    inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
347    inline unsigned long Index() const {return FileP - Owner->VerFileP;};
348       
349    inline VerFileIterator() : Owner(0), FileP(0) {};
350    inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
351 };
352
353 // Inlined Begin functions cant be in the class because of order problems
354 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
355        {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);}
356 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
357        {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);}
358 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
359        {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);}
360 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
361        {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);}
362 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
363        {return PrvIterator(*Owner,Owner->ProvideP + Ver->ProvidesList,Ver);}
364 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
365        {return DepIterator(*Owner,Owner->DepP + Ver->DependsList,Ver);}
366 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
367        {return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);}
368
369 #endif