]>
git.saurik.com Git - apt.git/blob - apt-pkg/cacheiterators.h
1 // -*- mode: cpp; mode: fold -*-
3 // $Id: cacheiterators.h,v 1.18.2.1 2004/05/08 22:44:27 mdz Exp $
4 /* ######################################################################
6 Cache Iterators - Iterators for navigating the cache structure
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
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.
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
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
27 This header is not user includable, please use apt-pkg/pkgcache.h
29 ##################################################################### */
31 #ifndef PKGLIB_CACHEITERATORS_H
32 #define PKGLIB_CACHEITERATORS_H
35 // Package Iterator /*{{{*/
36 class pkgCache::PkgIterator
38 friend class pkgCache
;
45 // This constructor is the 'begin' constructor, never use it.
46 inline PkgIterator(pkgCache
&Owner
) : Owner(&Owner
), HashIndex(-1)
54 enum OkState
{NeedsNothing
,NeedsUnpack
,NeedsConfigure
};
57 void operator ++(int);
58 inline void operator ++() {operator ++(0);};
59 inline bool end() const {return Owner
== 0 || Pkg
== Owner
->PkgP
?true:false;};
62 inline bool operator ==(const PkgIterator
&B
) const {return Pkg
== B
.Pkg
;};
63 inline bool operator !=(const PkgIterator
&B
) const {return Pkg
!= B
.Pkg
;};
66 inline Package
*operator ->() {return Pkg
;};
67 inline Package
const *operator ->() const {return Pkg
;};
68 inline Package
const &operator *() const {return *Pkg
;};
69 inline operator Package
*() {return Pkg
== Owner
->PkgP
?0:Pkg
;};
70 inline operator Package
const *() const {return Pkg
== Owner
->PkgP
?0:Pkg
;};
71 inline pkgCache
*Cache() {return Owner
;};
73 inline const char *Name() const {return Pkg
->Name
== 0?0:Owner
->StrP
+ Pkg
->Name
;};
74 inline const char *Section() const {return Pkg
->Section
== 0?0:Owner
->StrP
+ Pkg
->Section
;};
75 inline bool Purge() const {return Pkg
->CurrentState
== pkgCache::State::Purge
||
76 (Pkg
->CurrentVer
== 0 && Pkg
->CurrentState
== pkgCache::State::NotInstalled
);};
77 inline VerIterator
VersionList() const;
78 inline VerIterator
CurrentVer() const;
79 inline DepIterator
RevDependsList() const;
80 inline PrvIterator
ProvidesList() const;
81 inline unsigned long Index() const {return Pkg
- Owner
->PkgP
;};
82 OkState
State() const;
84 //Nice printable representation
85 friend std::ostream
& operator<<(std::ostream
& out
, pkgCache::PkgIterator Pkg
);
87 const char *CandVersion() const;
88 const char *CurVersion() const;
91 inline PkgIterator(pkgCache
&Owner
,Package
*Trg
) : Pkg(Trg
), Owner(&Owner
),
97 inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
100 // Version Iterator /*{{{*/
101 class pkgCache::VerIterator
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 Owner
== NULL
|| (Ver
== Owner
->VerP
?true:false);};
114 inline void operator =(const VerIterator
&B
) {Ver
= B
.Ver
; Owner
= B
.Owner
;};
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;
122 inline bool IsGood() const { return Ver
&& Owner
&& ! end();};
125 inline Version
*operator ->() {return Ver
;};
126 inline Version
const *operator ->() const {return Ver
;};
127 inline Version
&operator *() {return *Ver
;};
128 inline Version
const &operator *() const {return *Ver
;};
129 inline operator Version
*() {return Ver
== Owner
->VerP
?0:Ver
;};
130 inline operator Version
const *() const {return Ver
== Owner
->VerP
?0:Ver
;};
131 inline pkgCache
*Cache() {return Owner
;};
133 inline const char *VerStr() const {return Ver
->VerStr
== 0?0:Owner
->StrP
+ Ver
->VerStr
;};
134 inline const char *Section() const {return Ver
->Section
== 0?0:Owner
->StrP
+ Ver
->Section
;};
135 inline const char *Arch() const {return Ver
->Arch
== 0?0:Owner
->StrP
+ Ver
->Arch
;};
136 inline PkgIterator
ParentPkg() const {return PkgIterator(*Owner
,Owner
->PkgP
+ Ver
->ParentPkg
);};
137 inline DescIterator
DescriptionList() const;
138 DescIterator
TranslatedDescription() const;
139 inline DepIterator
DependsList() const;
140 inline PrvIterator
ProvidesList() const;
141 inline VerFileIterator
FileList() const;
142 inline unsigned long Index() const {return Ver
- Owner
->VerP
;};
143 bool Downloadable() const;
144 inline const char *PriorityType() {return Owner
->Priority(Ver
->Priority
);};
147 bool Automatic() const;
148 VerFileIterator
NewestFile() const;
150 inline VerIterator() : Ver(0), Owner(0) {};
151 inline VerIterator(pkgCache
&Owner
,Version
*Trg
= 0) : Ver(Trg
),
159 // Description Iterator /*{{{*/
160 class pkgCache::DescIterator
170 void operator ++(int) {if (Desc
!= Owner
->DescP
) Desc
= Owner
->DescP
+ Desc
->NextDesc
;};
171 inline void operator ++() {operator ++(0);};
172 inline bool end() const {return Desc
== Owner
->DescP
?true:false;};
173 inline void operator =(const DescIterator
&B
) {Desc
= B
.Desc
; Owner
= B
.Owner
;};
176 inline bool operator ==(const DescIterator
&B
) const {return Desc
== B
.Desc
;};
177 inline bool operator !=(const DescIterator
&B
) const {return Desc
!= B
.Desc
;};
178 int CompareDesc(const DescIterator
&B
) const;
181 inline Description
*operator ->() {return Desc
;};
182 inline Description
const *operator ->() const {return Desc
;};
183 inline Description
&operator *() {return *Desc
;};
184 inline Description
const &operator *() const {return *Desc
;};
185 inline operator Description
*() {return Desc
== Owner
->DescP
?0:Desc
;};
186 inline operator Description
const *() const {return Desc
== Owner
->DescP
?0:Desc
;};
187 inline pkgCache
*Cache() {return Owner
;};
189 inline const char *LanguageCode() const {return Owner
->StrP
+ Desc
->language_code
;};
190 inline const char *md5() const {return Owner
->StrP
+ Desc
->md5sum
;};
191 inline DescFileIterator
FileList() const;
192 inline unsigned long Index() const {return Desc
- Owner
->DescP
;};
194 inline DescIterator() : Desc(0), Owner(0) {};
195 inline DescIterator(pkgCache
&Owner
,Description
*Trg
= 0) : Desc(Trg
),
203 // Dependency iterator /*{{{*/
204 class pkgCache::DepIterator
207 enum {DepVer
, DepRev
} Type
;
215 void operator ++(int) {if (Dep
!= Owner
->DepP
) Dep
= Owner
->DepP
+
216 (Type
== DepVer
?Dep
->NextDepends
:Dep
->NextRevDepends
);};
217 inline void operator ++() {operator ++(0);};
218 inline bool end() const {return Owner
== 0 || Dep
== Owner
->DepP
?true:false;};
221 inline bool operator ==(const DepIterator
&B
) const {return Dep
== B
.Dep
;};
222 inline bool operator !=(const DepIterator
&B
) const {return Dep
!= B
.Dep
;};
225 inline Dependency
*operator ->() {return Dep
;};
226 inline Dependency
const *operator ->() const {return Dep
;};
227 inline Dependency
&operator *() {return *Dep
;};
228 inline Dependency
const &operator *() const {return *Dep
;};
229 inline operator Dependency
*() {return Dep
== Owner
->DepP
?0:Dep
;};
230 inline operator Dependency
const *() const {return Dep
== Owner
->DepP
?0:Dep
;};
231 inline pkgCache
*Cache() {return Owner
;};
233 inline const char *TargetVer() const {return Dep
->Version
== 0?0:Owner
->StrP
+ Dep
->Version
;};
234 inline PkgIterator
TargetPkg() {return PkgIterator(*Owner
,Owner
->PkgP
+ Dep
->Package
);};
235 inline PkgIterator
SmartTargetPkg() {PkgIterator
R(*Owner
,0);SmartTargetPkg(R
);return R
;};
236 inline VerIterator
ParentVer() {return VerIterator(*Owner
,Owner
->VerP
+ Dep
->ParentVer
);};
237 inline PkgIterator
ParentPkg() {return PkgIterator(*Owner
,Owner
->PkgP
+ Owner
->VerP
[Dep
->ParentVer
].ParentPkg
);};
238 inline bool Reverse() {return Type
== DepRev
;};
239 inline unsigned long Index() const {return Dep
- Owner
->DepP
;};
241 void GlobOr(DepIterator
&Start
,DepIterator
&End
);
242 Version
**AllTargets();
243 bool SmartTargetPkg(PkgIterator
&Result
);
244 inline const char *CompType() {return Owner
->CompType(Dep
->CompareOp
);};
245 inline const char *DepType() {return Owner
->DepType(Dep
->Type
);};
247 inline DepIterator(pkgCache
&Owner
,Dependency
*Trg
,Version
* = 0) :
248 Dep(Trg
), Type(DepVer
), Owner(&Owner
)
253 inline DepIterator(pkgCache
&Owner
,Dependency
*Trg
,Package
*) :
254 Dep(Trg
), Type(DepRev
), Owner(&Owner
)
259 inline DepIterator() : Dep(0), Type(DepVer
), Owner(0) {};
262 // Provides iterator /*{{{*/
263 class pkgCache::PrvIterator
266 enum {PrvVer
, PrvPkg
} Type
;
274 void operator ++(int) {if (Prv
!= Owner
->ProvideP
) Prv
= Owner
->ProvideP
+
275 (Type
== PrvVer
?Prv
->NextPkgProv
:Prv
->NextProvides
);};
276 inline void operator ++() {operator ++(0);};
277 inline bool end() const {return Owner
== 0 || Prv
== Owner
->ProvideP
?true:false;};
280 inline bool operator ==(const PrvIterator
&B
) const {return Prv
== B
.Prv
;};
281 inline bool operator !=(const PrvIterator
&B
) const {return Prv
!= B
.Prv
;};
284 inline Provides
*operator ->() {return Prv
;};
285 inline Provides
const *operator ->() const {return Prv
;};
286 inline Provides
&operator *() {return *Prv
;};
287 inline Provides
const &operator *() const {return *Prv
;};
288 inline operator Provides
*() {return Prv
== Owner
->ProvideP
?0:Prv
;};
289 inline operator Provides
const *() const {return Prv
== Owner
->ProvideP
?0:Prv
;};
290 inline pkgCache
*Cache() {return Owner
;};
292 inline const char *Name() const {return Owner
->StrP
+ Owner
->PkgP
[Prv
->ParentPkg
].Name
;};
293 inline const char *ProvideVersion() const {return Prv
->ProvideVersion
== 0?0:Owner
->StrP
+ Prv
->ProvideVersion
;};
294 inline PkgIterator
ParentPkg() {return PkgIterator(*Owner
,Owner
->PkgP
+ Prv
->ParentPkg
);};
295 inline VerIterator
OwnerVer() {return VerIterator(*Owner
,Owner
->VerP
+ Prv
->Version
);};
296 inline PkgIterator
OwnerPkg() {return PkgIterator(*Owner
,Owner
->PkgP
+ Owner
->VerP
[Prv
->Version
].ParentPkg
);};
297 inline unsigned long Index() const {return Prv
- Owner
->ProvideP
;};
299 inline PrvIterator() : Prv(0), Type(PrvVer
), Owner(0) {};
301 inline PrvIterator(pkgCache
&Owner
,Provides
*Trg
,Version
*) :
302 Prv(Trg
), Type(PrvVer
), Owner(&Owner
)
305 Prv
= Owner
.ProvideP
;
307 inline PrvIterator(pkgCache
&Owner
,Provides
*Trg
,Package
*) :
308 Prv(Trg
), Type(PrvPkg
), Owner(&Owner
)
311 Prv
= Owner
.ProvideP
;
315 // Package file /*{{{*/
316 class pkgCache::PkgFileIterator
324 void operator ++(int) {if (File
!= Owner
->PkgFileP
) File
= Owner
->PkgFileP
+ File
->NextFile
;};
325 inline void operator ++() {operator ++(0);};
326 inline bool end() const {return File
== Owner
->PkgFileP
?true:false;};
329 inline bool operator ==(const PkgFileIterator
&B
) const {return File
== B
.File
;};
330 inline bool operator !=(const PkgFileIterator
&B
) const {return File
!= B
.File
;};
333 inline PackageFile
*operator ->() {return File
;};
334 inline PackageFile
const *operator ->() const {return File
;};
335 inline PackageFile
const &operator *() const {return *File
;};
336 inline operator PackageFile
*() {return File
== Owner
->PkgFileP
?0:File
;};
337 inline operator PackageFile
const *() const {return File
== Owner
->PkgFileP
?0:File
;};
338 inline pkgCache
*Cache() {return Owner
;};
340 inline const char *FileName() const {return File
->FileName
== 0?0:Owner
->StrP
+ File
->FileName
;};
341 inline const char *Archive() const {return File
->Archive
== 0?0:Owner
->StrP
+ File
->Archive
;};
342 inline const char *Component() const {return File
->Component
== 0?0:Owner
->StrP
+ File
->Component
;};
343 inline const char *Version() const {return File
->Version
== 0?0:Owner
->StrP
+ File
->Version
;};
344 inline const char *Origin() const {return File
->Origin
== 0?0:Owner
->StrP
+ File
->Origin
;};
345 inline const char *Codename() const {return File
->Codename
==0?0:Owner
->StrP
+ File
->Codename
;};
346 inline const char *Label() const {return File
->Label
== 0?0:Owner
->StrP
+ File
->Label
;};
347 inline const char *Site() const {return File
->Site
== 0?0:Owner
->StrP
+ File
->Site
;};
348 inline const char *Architecture() const {return File
->Architecture
== 0?0:Owner
->StrP
+ File
->Architecture
;};
349 inline const char *IndexType() const {return File
->IndexType
== 0?0:Owner
->StrP
+ File
->IndexType
;};
351 inline unsigned long Index() const {return File
- Owner
->PkgFileP
;};
357 inline PkgFileIterator() : Owner(0), File(0) {};
358 inline PkgFileIterator(pkgCache
&Owner
) : Owner(&Owner
), File(Owner
.PkgFileP
) {};
359 inline PkgFileIterator(pkgCache
&Owner
,PackageFile
*Trg
) : Owner(&Owner
), File(Trg
) {};
362 // Version File /*{{{*/
363 class pkgCache::VerFileIterator
371 void operator ++(int) {if (FileP
!= Owner
->VerFileP
) FileP
= Owner
->VerFileP
+ FileP
->NextFile
;};
372 inline void operator ++() {operator ++(0);};
373 inline bool end() const {return FileP
== Owner
->VerFileP
?true:false;};
376 inline bool operator ==(const VerFileIterator
&B
) const {return FileP
== B
.FileP
;};
377 inline bool operator !=(const VerFileIterator
&B
) const {return FileP
!= B
.FileP
;};
380 inline VerFile
*operator ->() {return FileP
;};
381 inline VerFile
const *operator ->() const {return FileP
;};
382 inline VerFile
const &operator *() const {return *FileP
;};
383 inline operator VerFile
*() {return FileP
== Owner
->VerFileP
?0:FileP
;};
384 inline operator VerFile
const *() const {return FileP
== Owner
->VerFileP
?0:FileP
;};
385 inline pkgCache
*Cache() {return Owner
;};
387 inline PkgFileIterator
File() const {return PkgFileIterator(*Owner
,FileP
->File
+ Owner
->PkgFileP
);};
388 inline unsigned long Index() const {return FileP
- Owner
->VerFileP
;};
390 inline VerFileIterator() : Owner(0), FileP(0) {};
391 inline VerFileIterator(pkgCache
&Owner
,VerFile
*Trg
) : Owner(&Owner
), FileP(Trg
) {};
394 // Description File /*{{{*/
395 class pkgCache::DescFileIterator
403 void operator ++(int) {if (FileP
!= Owner
->DescFileP
) FileP
= Owner
->DescFileP
+ FileP
->NextFile
;};
404 inline void operator ++() {operator ++(0);};
405 inline bool end() const {return FileP
== Owner
->DescFileP
?true:false;};
408 inline bool operator ==(const DescFileIterator
&B
) const {return FileP
== B
.FileP
;};
409 inline bool operator !=(const DescFileIterator
&B
) const {return FileP
!= B
.FileP
;};
412 inline DescFile
*operator ->() {return FileP
;};
413 inline DescFile
const *operator ->() const {return FileP
;};
414 inline DescFile
const &operator *() const {return *FileP
;};
415 inline operator DescFile
*() {return FileP
== Owner
->DescFileP
?0:FileP
;};
416 inline operator DescFile
const *() const {return FileP
== Owner
->DescFileP
?0:FileP
;};
417 inline pkgCache
*Cache() {return Owner
;};
419 inline PkgFileIterator
File() const {return PkgFileIterator(*Owner
,FileP
->File
+ Owner
->PkgFileP
);};
420 inline unsigned long Index() const {return FileP
- Owner
->DescFileP
;};
422 inline DescFileIterator() : Owner(0), FileP(0) {};
423 inline DescFileIterator(pkgCache
&Owner
,DescFile
*Trg
) : Owner(&Owner
), FileP(Trg
) {};
426 // Inlined Begin functions cant be in the class because of order problems /*{{{*/
427 inline pkgCache::VerIterator
pkgCache::PkgIterator::VersionList() const
428 {return VerIterator(*Owner
,Owner
->VerP
+ Pkg
->VersionList
);};
429 inline pkgCache::VerIterator
pkgCache::PkgIterator::CurrentVer() const
430 {return VerIterator(*Owner
,Owner
->VerP
+ Pkg
->CurrentVer
);};
431 inline pkgCache::DepIterator
pkgCache::PkgIterator::RevDependsList() const
432 {return DepIterator(*Owner
,Owner
->DepP
+ Pkg
->RevDepends
,Pkg
);};
433 inline pkgCache::PrvIterator
pkgCache::PkgIterator::ProvidesList() const
434 {return PrvIterator(*Owner
,Owner
->ProvideP
+ Pkg
->ProvidesList
,Pkg
);};
435 inline pkgCache::DescIterator
pkgCache::VerIterator::DescriptionList() const
436 {return DescIterator(*Owner
,Owner
->DescP
+ Ver
->DescriptionList
);};
437 inline pkgCache::PrvIterator
pkgCache::VerIterator::ProvidesList() const
438 {return PrvIterator(*Owner
,Owner
->ProvideP
+ Ver
->ProvidesList
,Ver
);};
439 inline pkgCache::DepIterator
pkgCache::VerIterator::DependsList() const
440 {return DepIterator(*Owner
,Owner
->DepP
+ Ver
->DependsList
,Ver
);};
441 inline pkgCache::VerFileIterator
pkgCache::VerIterator::FileList() const
442 {return VerFileIterator(*Owner
,Owner
->VerFileP
+ Ver
->FileList
);};
443 inline pkgCache::DescFileIterator
pkgCache::DescIterator::FileList() const
444 {return DescFileIterator(*Owner
,Owner
->DescFileP
+ Desc
->FileList
);};