- add missing include (Ralf)
[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 #include <apt-pkg/pkgcache.h>
39
40 // Package Iterator
41 class pkgCache::PkgIterator
42 {
43    friend class pkgCache;
44    Package *Pkg;
45    pkgCache *Owner;
46    long HashIndex;
47
48    protected:
49    
50    // This constructor is the 'begin' constructor, never use it.
51    inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
52    {
53       Pkg = Owner.PkgP;
54       operator ++(0);
55    };
56    
57    public:
58
59    enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
60       
61    // Iteration
62    void operator ++(int);
63    inline void operator ++() {operator ++(0);};
64    inline bool end() const {return Owner == 0 || Pkg == Owner->PkgP?true:false;};
65
66    // Comparison
67    inline bool operator ==(const PkgIterator &B) const {return Pkg == B.Pkg;};
68    inline bool operator !=(const PkgIterator &B) const {return Pkg != B.Pkg;};
69                            
70    // Accessors
71    inline Package *operator ->() {return Pkg;};
72    inline Package const *operator ->() const {return Pkg;};
73    inline Package const &operator *() const {return *Pkg;};
74    inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
75    inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
76    inline pkgCache *Cache() {return Owner;};
77    
78    inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
79    inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
80    inline bool Purge() const {return Pkg->CurrentState == pkgCache::State::Purge ||
81          (Pkg->CurrentVer == 0 && Pkg->CurrentState == pkgCache::State::NotInstalled);};
82    inline VerIterator VersionList() const;
83    inline VerIterator TargetVer() const;
84    inline VerIterator CurrentVer() const;
85    inline DepIterator RevDependsList() const;
86    inline PrvIterator ProvidesList() const;
87    inline unsigned long Index() const {return Pkg - Owner->PkgP;};
88    OkState State() const;
89    
90    // Constructors
91    inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
92           HashIndex(0) 
93    { 
94       if (Pkg == 0)
95          Pkg = Owner.PkgP;
96    };
97    inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
98 };
99
100 // Version Iterator
101 class pkgCache::VerIterator
102 {
103    Version *Ver;
104    pkgCache *Owner;
105    
106    void _dummy();
107    
108    public:
109
110    // Iteration
111    void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
112    inline void operator ++() {operator ++(0);};
113    inline bool end() const {return Ver == Owner->VerP?true:false;};
114    inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
115    
116    // Comparison
117    inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
118    inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
119    int CompareVer(const VerIterator &B) const;
120    
121    // Accessors
122    inline Version *operator ->() {return Ver;};
123    inline Version const *operator ->() const {return Ver;};
124    inline Version &operator *() {return *Ver;};
125    inline Version const &operator *() const {return *Ver;};
126    inline operator Version *() {return Ver == Owner->VerP?0:Ver;};
127    inline operator Version const *() const {return Ver == Owner->VerP?0:Ver;};
128    inline pkgCache *Cache() {return Owner;};
129       
130    inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner->StrP + Ver->VerStr;};
131    inline const char *Section() const {return Ver->Section == 0?0:Owner->StrP + Ver->Section;};
132    inline const char *Arch() const {return Ver->Arch == 0?0:Owner->StrP + Ver->Arch;};
133    inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Ver->ParentPkg);};
134    inline DepIterator DependsList() const;
135    inline PrvIterator ProvidesList() const;
136    inline VerFileIterator FileList() const;
137    inline unsigned long Index() const {return Ver - Owner->VerP;};
138    bool Downloadable() const;
139    inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
140    string RelStr();
141    
142    bool Automatic() const;
143    VerFileIterator NewestFile() const;
144
145    inline VerIterator() : Ver(0), Owner(0) {};   
146    inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), 
147               Owner(&Owner) 
148    { 
149       if (Ver == 0)
150          Ver = Owner.VerP;
151    };
152 };
153
154 // Dependency iterator
155 class pkgCache::DepIterator
156 {
157    Dependency *Dep;
158    enum {DepVer, DepRev} Type;
159    pkgCache *Owner;
160    
161    void _dummy();
162    
163    public:
164
165    // Iteration
166    void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
167         (Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
168    inline void operator ++() {operator ++(0);};
169    inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
170    
171    // Comparison
172    inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
173    inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
174
175    // Accessors
176    inline Dependency *operator ->() {return Dep;};
177    inline Dependency const *operator ->() const {return Dep;};
178    inline Dependency &operator *() {return *Dep;};
179    inline Dependency const &operator *() const {return *Dep;};
180    inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
181    inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
182    inline pkgCache *Cache() {return Owner;};
183    
184    inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
185    inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
186    inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
187    inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
188    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
189    inline bool Reverse() {return Type == DepRev;};
190    inline unsigned long Index() const {return Dep - Owner->DepP;};
191    // CNC:2003-02-17 - This is a very used function, so it's now
192    //                  inlined here.
193    inline bool IsCritical()
194                 {
195                         switch (Dep->Type) {
196                                 case pkgCache::Dep::Conflicts:
197                                 case pkgCache::Dep::Obsoletes:
198                                 case pkgCache::Dep::Depends:
199                                 case pkgCache::Dep::PreDepends:
200                                         return true;
201                                 default:
202                                         return false;
203                         }
204                 }
205    void GlobOr(DepIterator &Start,DepIterator &End);
206    Version **AllTargets();   
207    bool SmartTargetPkg(PkgIterator &Result);
208    inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
209    inline const char *DepType() {return Owner->DepType(Dep->Type);};
210    
211    inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
212           Dep(Trg), Type(DepVer), Owner(&Owner) 
213    {
214       if (Dep == 0)
215          Dep = Owner.DepP;
216    };
217    inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
218           Dep(Trg), Type(DepRev), Owner(&Owner)
219    {
220       if (Dep == 0)
221          Dep = Owner.DepP;
222    };
223    inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
224 };
225
226 // Provides iterator
227 class pkgCache::PrvIterator
228 {
229    Provides *Prv;
230    enum {PrvVer, PrvPkg} Type;
231    pkgCache *Owner;
232    
233    void _dummy();
234    
235    public:
236
237    // Iteration
238    void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
239         (Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
240    inline void operator ++() {operator ++(0);};
241    inline bool end() const {return Prv == Owner->ProvideP?true:false;};
242    
243    // Comparison
244    inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
245    inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
246
247    // Accessors
248    inline Provides *operator ->() {return Prv;};
249    inline Provides const *operator ->() const {return Prv;};
250    inline Provides &operator *() {return *Prv;};
251    inline Provides const &operator *() const {return *Prv;};
252    inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
253    inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
254    inline pkgCache *Cache() {return Owner;};
255
256    inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
257    inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
258    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
259    inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
260    inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
261    inline unsigned long Index() const {return Prv - Owner->ProvideP;};
262
263    inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
264           Prv(Trg), Type(PrvVer), Owner(&Owner) 
265    {
266       if (Prv == 0)
267          Prv = Owner.ProvideP;
268    };
269    inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) : 
270           Prv(Trg), Type(PrvPkg), Owner(&Owner)
271    {
272       if (Prv == 0)
273          Prv = Owner.ProvideP;
274    };
275 };
276
277 // Package file 
278 class pkgCache::PkgFileIterator
279 {
280    pkgCache *Owner;
281    PackageFile *File;
282
283    public:
284
285    // Iteration
286    void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
287    inline void operator ++() {operator ++(0);};
288    inline bool end() const {return File == Owner->PkgFileP?true:false;};
289
290    // Comparison
291    inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
292    inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
293                            
294    // Accessors
295    inline PackageFile *operator ->() {return File;};
296    inline PackageFile const *operator ->() const {return File;};
297    inline PackageFile const &operator *() const {return *File;};
298    inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
299    inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
300    inline pkgCache *Cache() {return Owner;};
301
302    inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
303    inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
304    inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
305    inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
306    inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
307    inline const char *Label() const {return File->Label == 0?0:Owner->StrP + File->Label;};
308    inline const char *Site() const {return File->Site == 0?0:Owner->StrP + File->Site;};
309    inline const char *Architecture() const {return File->Architecture == 0?0:Owner->StrP + File->Architecture;};
310    inline const char *IndexType() const {return File->IndexType == 0?0:Owner->StrP + File->IndexType;};
311
312    inline unsigned long Index() const {return File - Owner->PkgFileP;};
313
314    bool IsOk();
315    string RelStr();
316    
317    // Constructors
318    inline PkgFileIterator() : Owner(0), File(0) {};
319    inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
320    inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
321 };
322
323 // Version File 
324 class pkgCache::VerFileIterator
325 {
326    pkgCache *Owner;
327    VerFile *FileP;
328
329    public:
330
331    // Iteration
332    void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
333    inline void operator ++() {operator ++(0);};
334    inline bool end() const {return FileP == Owner->VerFileP?true:false;};
335
336    // Comparison
337    inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
338    inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
339                            
340    // Accessors
341    inline VerFile *operator ->() {return FileP;};
342    inline VerFile const *operator ->() const {return FileP;};
343    inline VerFile const &operator *() const {return *FileP;};
344    inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
345    inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
346    inline pkgCache *Cache() {return Owner;};
347   
348    inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
349    inline unsigned long Index() const {return FileP - Owner->VerFileP;};
350       
351    inline VerFileIterator() : Owner(0), FileP(0) {};
352    inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
353 };
354
355 // Inlined Begin functions cant be in the class because of order problems
356 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
357        {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);}
358 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
359        {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);}
360 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
361        {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);}
362 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
363        {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);}
364 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
365        {return PrvIterator(*Owner,Owner->ProvideP + Ver->ProvidesList,Ver);}
366 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
367        {return DepIterator(*Owner,Owner->DepP + Ver->DependsList,Ver);}
368 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
369        {return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);}
370
371 #endif