]> git.saurik.com Git - apt.git/blob - apt-pkg/cacheiterators.h
* apt-pkg/indexfile.cc:
[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 Owner == NULL || (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 DescIterator TranslatedDescription() const;
133 inline DepIterator DependsList() const;
134 inline PrvIterator ProvidesList() const;
135 inline VerFileIterator FileList() const;
136 inline unsigned long Index() const {return Ver - Owner->VerP;};
137 bool Downloadable() const;
138 inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
139 string RelStr();
140
141 bool Automatic() const;
142 VerFileIterator NewestFile() const;
143
144 inline VerIterator() : Ver(0), Owner(0) {};
145 inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg),
146 Owner(&Owner)
147 {
148 if (Ver == 0)
149 Ver = Owner.VerP;
150 };
151 };
152
153 // Description Iterator
154 class pkgCache::DescIterator
155 {
156 Description *Desc;
157 pkgCache *Owner;
158
159 void _dummy();
160
161 public:
162
163 // Iteration
164 void operator ++(int) {if (Desc != Owner->DescP) Desc = Owner->DescP + Desc->NextDesc;};
165 inline void operator ++() {operator ++(0);};
166 inline bool end() const {return Desc == Owner->DescP?true:false;};
167 inline void operator =(const DescIterator &B) {Desc = B.Desc; Owner = B.Owner;};
168
169 // Comparison
170 inline bool operator ==(const DescIterator &B) const {return Desc == B.Desc;};
171 inline bool operator !=(const DescIterator &B) const {return Desc != B.Desc;};
172 int CompareDesc(const DescIterator &B) const;
173
174 // Accessors
175 inline Description *operator ->() {return Desc;};
176 inline Description const *operator ->() const {return Desc;};
177 inline Description &operator *() {return *Desc;};
178 inline Description const &operator *() const {return *Desc;};
179 inline operator Description *() {return Desc == Owner->DescP?0:Desc;};
180 inline operator Description const *() const {return Desc == Owner->DescP?0:Desc;};
181 inline pkgCache *Cache() {return Owner;};
182
183 inline const char *LanguageCode() const {return Owner->StrP + Desc->language_code;};
184 inline const char *md5() const {return Owner->StrP + Desc->md5sum;};
185 inline DescFileIterator FileList() const;
186 inline unsigned long Index() const {return Desc - Owner->DescP;};
187
188 inline DescIterator() : Desc(0), Owner(0) {};
189 inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Desc(Trg),
190 Owner(&Owner)
191 {
192 if (Desc == 0)
193 Desc = Owner.DescP;
194 };
195 };
196
197 // Dependency iterator
198 class pkgCache::DepIterator
199 {
200 Dependency *Dep;
201 enum {DepVer, DepRev} Type;
202 pkgCache *Owner;
203
204 void _dummy();
205
206 public:
207
208 // Iteration
209 void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
210 (Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
211 inline void operator ++() {operator ++(0);};
212 inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
213
214 // Comparison
215 inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
216 inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
217
218 // Accessors
219 inline Dependency *operator ->() {return Dep;};
220 inline Dependency const *operator ->() const {return Dep;};
221 inline Dependency &operator *() {return *Dep;};
222 inline Dependency const &operator *() const {return *Dep;};
223 inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
224 inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
225 inline pkgCache *Cache() {return Owner;};
226
227 inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
228 inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
229 inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
230 inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
231 inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
232 inline bool Reverse() {return Type == DepRev;};
233 inline unsigned long Index() const {return Dep - Owner->DepP;};
234 bool IsCritical();
235 void GlobOr(DepIterator &Start,DepIterator &End);
236 Version **AllTargets();
237 bool SmartTargetPkg(PkgIterator &Result);
238 inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
239 inline const char *DepType() {return Owner->DepType(Dep->Type);};
240
241 inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
242 Dep(Trg), Type(DepVer), Owner(&Owner)
243 {
244 if (Dep == 0)
245 Dep = Owner.DepP;
246 };
247 inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
248 Dep(Trg), Type(DepRev), Owner(&Owner)
249 {
250 if (Dep == 0)
251 Dep = Owner.DepP;
252 };
253 inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
254 };
255
256 // Provides iterator
257 class pkgCache::PrvIterator
258 {
259 Provides *Prv;
260 enum {PrvVer, PrvPkg} Type;
261 pkgCache *Owner;
262
263 void _dummy();
264
265 public:
266
267 // Iteration
268 void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
269 (Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
270 inline void operator ++() {operator ++(0);};
271 inline bool end() const {return Owner == 0 || Prv == Owner->ProvideP?true:false;};
272
273 // Comparison
274 inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
275 inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
276
277 // Accessors
278 inline Provides *operator ->() {return Prv;};
279 inline Provides const *operator ->() const {return Prv;};
280 inline Provides &operator *() {return *Prv;};
281 inline Provides const &operator *() const {return *Prv;};
282 inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
283 inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
284 inline pkgCache *Cache() {return Owner;};
285
286 inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
287 inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
288 inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
289 inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
290 inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
291 inline unsigned long Index() const {return Prv - Owner->ProvideP;};
292
293 inline PrvIterator() : Prv(0), Type(PrvVer), Owner(0) {};
294
295 inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
296 Prv(Trg), Type(PrvVer), Owner(&Owner)
297 {
298 if (Prv == 0)
299 Prv = Owner.ProvideP;
300 };
301 inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) :
302 Prv(Trg), Type(PrvPkg), Owner(&Owner)
303 {
304 if (Prv == 0)
305 Prv = Owner.ProvideP;
306 };
307 };
308
309 // Package file
310 class pkgCache::PkgFileIterator
311 {
312 pkgCache *Owner;
313 PackageFile *File;
314
315 public:
316
317 // Iteration
318 void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
319 inline void operator ++() {operator ++(0);};
320 inline bool end() const {return File == Owner->PkgFileP?true:false;};
321
322 // Comparison
323 inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
324 inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
325
326 // Accessors
327 inline PackageFile *operator ->() {return File;};
328 inline PackageFile const *operator ->() const {return File;};
329 inline PackageFile const &operator *() const {return *File;};
330 inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
331 inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
332 inline pkgCache *Cache() {return Owner;};
333
334 inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
335 inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
336 inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
337 inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
338 inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
339 inline const char *Label() const {return File->Label == 0?0:Owner->StrP + File->Label;};
340 inline const char *Site() const {return File->Site == 0?0:Owner->StrP + File->Site;};
341 inline const char *Architecture() const {return File->Architecture == 0?0:Owner->StrP + File->Architecture;};
342 inline const char *IndexType() const {return File->IndexType == 0?0:Owner->StrP + File->IndexType;};
343
344 inline unsigned long Index() const {return File - Owner->PkgFileP;};
345
346 bool IsOk();
347 string RelStr();
348
349 // Constructors
350 inline PkgFileIterator() : Owner(0), File(0) {};
351 inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
352 inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
353 };
354
355 // Version File
356 class pkgCache::VerFileIterator
357 {
358 pkgCache *Owner;
359 VerFile *FileP;
360
361 public:
362
363 // Iteration
364 void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
365 inline void operator ++() {operator ++(0);};
366 inline bool end() const {return FileP == Owner->VerFileP?true:false;};
367
368 // Comparison
369 inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
370 inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
371
372 // Accessors
373 inline VerFile *operator ->() {return FileP;};
374 inline VerFile const *operator ->() const {return FileP;};
375 inline VerFile const &operator *() const {return *FileP;};
376 inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
377 inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
378 inline pkgCache *Cache() {return Owner;};
379
380 inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
381 inline unsigned long Index() const {return FileP - Owner->VerFileP;};
382
383 inline VerFileIterator() : Owner(0), FileP(0) {};
384 inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
385 };
386
387 // Description File
388 class pkgCache::DescFileIterator
389 {
390 pkgCache *Owner;
391 DescFile *FileP;
392
393 public:
394
395 // Iteration
396 void operator ++(int) {if (FileP != Owner->DescFileP) FileP = Owner->DescFileP + FileP->NextFile;};
397 inline void operator ++() {operator ++(0);};
398 inline bool end() const {return FileP == Owner->DescFileP?true:false;};
399
400 // Comparison
401 inline bool operator ==(const DescFileIterator &B) const {return FileP == B.FileP;};
402 inline bool operator !=(const DescFileIterator &B) const {return FileP != B.FileP;};
403
404 // Accessors
405 inline DescFile *operator ->() {return FileP;};
406 inline DescFile const *operator ->() const {return FileP;};
407 inline DescFile const &operator *() const {return *FileP;};
408 inline operator DescFile *() {return FileP == Owner->DescFileP?0:FileP;};
409 inline operator DescFile const *() const {return FileP == Owner->DescFileP?0:FileP;};
410 inline pkgCache *Cache() {return Owner;};
411
412 inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
413 inline unsigned long Index() const {return FileP - Owner->DescFileP;};
414
415 inline DescFileIterator() : Owner(0), FileP(0) {};
416 inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Owner(&Owner), FileP(Trg) {};
417 };
418
419 // Inlined Begin functions cant be in the class because of order problems
420 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
421 {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
422 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
423 {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
424 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
425 {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
426 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
427 {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
428 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
429 {return DescIterator(*Owner,Owner->DescP + Ver->DescriptionList);};
430 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
431 {return PrvIterator(*Owner,Owner->ProvideP + Ver->ProvidesList,Ver);};
432 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
433 {return DepIterator(*Owner,Owner->DepP + Ver->DependsList,Ver);};
434 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
435 {return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);};
436 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
437 {return DescFileIterator(*Owner,Owner->DescFileP + Desc->FileList);};
438
439 #endif