Sync with apt--main--0--patch-78
[ntk/apt.git] / apt-pkg / cacheiterators.h
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: cacheiterators.h,v 1.18.2.1 2004/05/08 22:44:27 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 CurrentVer() const;
82 inline DepIterator RevDependsList() const;
83 inline PrvIterator ProvidesList() const;
84 inline unsigned long Index() const {return Pkg - Owner->PkgP;};
85 OkState State() const;
86
87 // Constructors
88 inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
89 HashIndex(0)
90 {
91 if (Pkg == 0)
92 Pkg = Owner.PkgP;
93 };
94 inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
95 };
96
97 // Version Iterator
98 class pkgCache::VerIterator
99 {
100 Version *Ver;
101 pkgCache *Owner;
102
103 void _dummy();
104
105 public:
106
107 // Iteration
108 void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
109 inline void operator ++() {operator ++(0);};
110 inline bool end() const {return Ver == Owner->VerP?true:false;};
111 inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
112
113 // Comparison
114 inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
115 inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
116 int CompareVer(const VerIterator &B) const;
117
118 // Accessors
119 inline Version *operator ->() {return Ver;};
120 inline Version const *operator ->() const {return Ver;};
121 inline Version &operator *() {return *Ver;};
122 inline Version const &operator *() const {return *Ver;};
123 inline operator Version *() {return Ver == Owner->VerP?0:Ver;};
124 inline operator Version const *() const {return Ver == Owner->VerP?0:Ver;};
125 inline pkgCache *Cache() {return Owner;};
126
127 inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner->StrP + Ver->VerStr;};
128 inline const char *Section() const {return Ver->Section == 0?0:Owner->StrP + Ver->Section;};
129 inline const char *Arch() const {return Ver->Arch == 0?0:Owner->StrP + Ver->Arch;};
130 inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Ver->ParentPkg);};
131 inline DescIterator DescriptionList() const;
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 // Description Iterator
153 class pkgCache::DescIterator
154 {
155 Description *Desc;
156 pkgCache *Owner;
157
158 void _dummy();
159
160 public:
161
162 // Iteration
163 void operator ++(int) {if (Desc != Owner->DescP) Desc = Owner->DescP + Desc->NextDesc;};
164 inline void operator ++() {operator ++(0);};
165 inline bool end() const {return Desc == Owner->DescP?true:false;};
166 inline void operator =(const DescIterator &B) {Desc = B.Desc; Owner = B.Owner;};
167
168 // Comparison
169 inline bool operator ==(const DescIterator &B) const {return Desc == B.Desc;};
170 inline bool operator !=(const DescIterator &B) const {return Desc != B.Desc;};
171 int CompareDesc(const DescIterator &B) const;
172
173 // Accessors
174 inline Description *operator ->() {return Desc;};
175 inline Description const *operator ->() const {return Desc;};
176 inline Description &operator *() {return *Desc;};
177 inline Description const &operator *() const {return *Desc;};
178 inline operator Description *() {return Desc == Owner->DescP?0:Desc;};
179 inline operator Description const *() const {return Desc == Owner->DescP?0:Desc;};
180 inline pkgCache *Cache() {return Owner;};
181
182 inline const char *LanguageCode() const {return Owner->StrP + Desc->language_code;};
183 inline const char *md5() const {return Owner->StrP + Desc->md5sum;};
184 inline DescFileIterator FileList() const;
185 inline unsigned long Index() const {return Desc - Owner->DescP;};
186
187 inline DescIterator() : Desc(0), Owner(0) {};
188 inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Desc(Trg),
189 Owner(&Owner)
190 {
191 if (Desc == 0)
192 Desc = Owner.DescP;
193 };
194 };
195
196 // Dependency iterator
197 class pkgCache::DepIterator
198 {
199 Dependency *Dep;
200 enum {DepVer, DepRev} Type;
201 pkgCache *Owner;
202
203 void _dummy();
204
205 public:
206
207 // Iteration
208 void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
209 (Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
210 inline void operator ++() {operator ++(0);};
211 inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
212
213 // Comparison
214 inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
215 inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
216
217 // Accessors
218 inline Dependency *operator ->() {return Dep;};
219 inline Dependency const *operator ->() const {return Dep;};
220 inline Dependency &operator *() {return *Dep;};
221 inline Dependency const &operator *() const {return *Dep;};
222 inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
223 inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
224 inline pkgCache *Cache() {return Owner;};
225
226 inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
227 inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
228 inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
229 inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
230 inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
231 inline bool Reverse() {return Type == DepRev;};
232 inline unsigned long Index() const {return Dep - Owner->DepP;};
233 bool IsCritical();
234 void GlobOr(DepIterator &Start,DepIterator &End);
235 Version **AllTargets();
236 bool SmartTargetPkg(PkgIterator &Result);
237 inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
238 inline const char *DepType() {return Owner->DepType(Dep->Type);};
239
240 inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
241 Dep(Trg), Type(DepVer), Owner(&Owner)
242 {
243 if (Dep == 0)
244 Dep = Owner.DepP;
245 };
246 inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
247 Dep(Trg), Type(DepRev), Owner(&Owner)
248 {
249 if (Dep == 0)
250 Dep = Owner.DepP;
251 };
252 inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
253 };
254
255 // Provides iterator
256 class pkgCache::PrvIterator
257 {
258 Provides *Prv;
259 enum {PrvVer, PrvPkg} Type;
260 pkgCache *Owner;
261
262 void _dummy();
263
264 public:
265
266 // Iteration
267 void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
268 (Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
269 inline void operator ++() {operator ++(0);};
270 inline bool end() const {return Prv == Owner->ProvideP?true:false;};
271
272 // Comparison
273 inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
274 inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
275
276 // Accessors
277 inline Provides *operator ->() {return Prv;};
278 inline Provides const *operator ->() const {return Prv;};
279 inline Provides &operator *() {return *Prv;};
280 inline Provides const &operator *() const {return *Prv;};
281 inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
282 inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
283 inline pkgCache *Cache() {return Owner;};
284
285 inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
286 inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
287 inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
288 inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
289 inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
290 inline unsigned long Index() const {return Prv - Owner->ProvideP;};
291
292 inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
293 Prv(Trg), Type(PrvVer), Owner(&Owner)
294 {
295 if (Prv == 0)
296 Prv = Owner.ProvideP;
297 };
298 inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) :
299 Prv(Trg), Type(PrvPkg), Owner(&Owner)
300 {
301 if (Prv == 0)
302 Prv = Owner.ProvideP;
303 };
304 };
305
306 // Package file
307 class pkgCache::PkgFileIterator
308 {
309 pkgCache *Owner;
310 PackageFile *File;
311
312 public:
313
314 // Iteration
315 void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
316 inline void operator ++() {operator ++(0);};
317 inline bool end() const {return File == Owner->PkgFileP?true:false;};
318
319 // Comparison
320 inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
321 inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
322
323 // Accessors
324 inline PackageFile *operator ->() {return File;};
325 inline PackageFile const *operator ->() const {return File;};
326 inline PackageFile const &operator *() const {return *File;};
327 inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
328 inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
329 inline pkgCache *Cache() {return Owner;};
330
331 inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
332 inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
333 inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
334 inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
335 inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
336 inline const char *Label() const {return File->Label == 0?0:Owner->StrP + File->Label;};
337 inline const char *Site() const {return File->Site == 0?0:Owner->StrP + File->Site;};
338 inline const char *Architecture() const {return File->Architecture == 0?0:Owner->StrP + File->Architecture;};
339 inline const char *IndexType() const {return File->IndexType == 0?0:Owner->StrP + File->IndexType;};
340
341 inline unsigned long Index() const {return File - Owner->PkgFileP;};
342
343 bool IsOk();
344 string RelStr();
345
346 // Constructors
347 inline PkgFileIterator() : Owner(0), File(0) {};
348 inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
349 inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
350 };
351
352 // Version File
353 class pkgCache::VerFileIterator
354 {
355 pkgCache *Owner;
356 VerFile *FileP;
357
358 public:
359
360 // Iteration
361 void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
362 inline void operator ++() {operator ++(0);};
363 inline bool end() const {return FileP == Owner->VerFileP?true:false;};
364
365 // Comparison
366 inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
367 inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
368
369 // Accessors
370 inline VerFile *operator ->() {return FileP;};
371 inline VerFile const *operator ->() const {return FileP;};
372 inline VerFile const &operator *() const {return *FileP;};
373 inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
374 inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
375 inline pkgCache *Cache() {return Owner;};
376
377 inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
378 inline unsigned long Index() const {return FileP - Owner->VerFileP;};
379
380 inline VerFileIterator() : Owner(0), FileP(0) {};
381 inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
382 };
383
384 // Description File
385 class pkgCache::DescFileIterator
386 {
387 pkgCache *Owner;
388 DescFile *FileP;
389
390 public:
391
392 // Iteration
393 void operator ++(int) {if (FileP != Owner->DescFileP) FileP = Owner->DescFileP + FileP->NextFile;};
394 inline void operator ++() {operator ++(0);};
395 inline bool end() const {return FileP == Owner->DescFileP?true:false;};
396
397 // Comparison
398 inline bool operator ==(const DescFileIterator &B) const {return FileP == B.FileP;};
399 inline bool operator !=(const DescFileIterator &B) const {return FileP != B.FileP;};
400
401 // Accessors
402 inline DescFile *operator ->() {return FileP;};
403 inline DescFile const *operator ->() const {return FileP;};
404 inline DescFile const &operator *() const {return *FileP;};
405 inline operator DescFile *() {return FileP == Owner->DescFileP?0:FileP;};
406 inline operator DescFile const *() const {return FileP == Owner->DescFileP?0:FileP;};
407 inline pkgCache *Cache() {return Owner;};
408
409 inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
410 inline unsigned long Index() const {return FileP - Owner->DescFileP;};
411
412 inline DescFileIterator() : Owner(0), FileP(0) {};
413 inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Owner(&Owner), FileP(Trg) {};
414 };
415
416 // Inlined Begin functions cant be in the class because of order problems
417 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
418 {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
419 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
420 {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
421 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
422 {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
423 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
424 {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
425 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
426 {return DescIterator(*Owner,Owner->DescP + Ver->DescriptionList);};
427 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
428 {return PrvIterator(*Owner,Owner->ProvideP + Ver->ProvidesList,Ver);};
429 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
430 {return DepIterator(*Owner,Owner->DepP + Ver->DependsList,Ver);};
431 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
432 {return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);};
433 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
434 {return DescFileIterator(*Owner,Owner->DescFileP + Desc->FileList);};
435
436 #endif