]> git.saurik.com Git - apt.git/blame - apt-pkg/cacheiterators.h
Two little bug fixes
[apt.git] / apt-pkg / cacheiterators.h
CommitLineData
578bfd0a
AL
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
c9807169 3// $Id: cacheiterators.h,v 1.9 1998/11/27 00:07:23 jgg Exp $
578bfd0a
AL
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
6c139d6e
AL
24 that has the depends pointer as a member. The provide iterator has the
25 same system.
578bfd0a 26
094a497d 27 This header is not user includable, please use apt-pkg/pkgcache.h
578bfd0a
AL
28
29 ##################################################################### */
30 /*}}}*/
31// Header section: pkglib
32#ifndef PKGLIB_CACHEITERATORS_H
33#define PKGLIB_CACHEITERATORS_H
34
6c139d6e 35#ifdef __GNUG__
094a497d 36#pragma interface "apt-pkg/cacheiterators.h"
6c139d6e
AL
37#endif
38
578bfd0a
AL
39// Package Iterator
40class pkgCache::PkgIterator
41{
42 Package *Pkg;
43 pkgCache *Owner;
44 long HashIndex;
45
46 public:
47
48 enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
49
50 // Iteration
51 void operator ++(int);
52 inline void operator ++() {operator ++(0);};
53 inline bool end() const {return Owner == 0 || Pkg == Owner->PkgP?true:false;};
54
55 // Comparison
56 inline bool operator ==(const PkgIterator &B) const {return Pkg == B.Pkg;};
57 inline bool operator !=(const PkgIterator &B) const {return Pkg != B.Pkg;};
58
59 // Accessors
60 inline Package *operator ->() {return Pkg;};
61 inline Package const *operator ->() const {return Pkg;};
62 inline Package const &operator *() const {return *Pkg;};
63 inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
64 inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
6c139d6e 65
578bfd0a
AL
66 inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
67 inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
68 inline const char *TargetDist() const {return Pkg->TargetDist == 0?0:Owner->StrP + Pkg->TargetDist;};
69 inline VerIterator VersionList() const;
70 inline VerIterator TargetVer() const;
71 inline VerIterator CurrentVer() const;
72 inline DepIterator RevDependsList() const;
73 inline PrvIterator ProvidesList() const;
f55a958f 74 inline unsigned long Index() const {return Pkg - Owner->PkgP;};
578bfd0a
AL
75 OkState State() const;
76
77 // Constructors
78 inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
79 {
80 Pkg = Owner.PkgP;
81 operator ++(0);
82 };
83 inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
84 HashIndex(0)
85 {
86 if (Pkg == 0)
87 Pkg = Owner.PkgP;
88 };
89 inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
90};
91
92// Version Iterator
93class pkgCache::VerIterator
94{
95 Version *Ver;
96 pkgCache &Owner;
97
98 void _dummy();
99
100 public:
101
102 // Iteration
103 void operator ++(int) {if (Ver != Owner.VerP) Ver = Owner.VerP + Ver->NextVer;};
104 inline void operator ++() {operator ++(0);};
105 inline bool end() const {return Ver == Owner.VerP?true:false;};
106 inline void operator =(const VerIterator &B) {Ver = B.Ver;};
107
108 // Comparison
109 inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
110 inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
111 int CompareVer(const VerIterator &B) const;
112
113 // Accessors
114 inline Version *operator ->() {return Ver;};
115 inline Version const *operator ->() const {return Ver;};
116 inline Version &operator *() {return *Ver;};
117 inline Version const &operator *() const {return *Ver;};
118 inline operator Version *() {return Ver == Owner.VerP?0:Ver;};
119 inline operator Version const *() const {return Ver == Owner.VerP?0:Ver;};
c9807169 120
578bfd0a
AL
121 inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner.StrP + Ver->VerStr;};
122 inline const char *Section() const {return Ver->Section == 0?0:Owner.StrP + Ver->Section;};
578bfd0a
AL
123 inline PkgIterator ParentPkg() const {return PkgIterator(Owner,Owner.PkgP + Ver->ParentPkg);};
124 inline DepIterator DependsList() const;
125 inline PrvIterator ProvidesList() const;
dcb79bae 126 inline VerFileIterator FileList() const;
6c139d6e 127 inline unsigned long Index() const {return Ver - Owner.VerP;};
b518cca6 128 bool Downloadable() const;
c9807169
AL
129 const char *PriorityType();
130
f55a958f 131 inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), Owner(Owner)
578bfd0a
AL
132 {
133 if (Ver == 0)
134 Ver = Owner.VerP;
135 };
136};
137
138// Dependency iterator
139class pkgCache::DepIterator
140{
141 Dependency *Dep;
142 enum {DepVer, DepRev} Type;
143 pkgCache *Owner;
144
145 void _dummy();
146
147 public:
148
149 // Iteration
150 void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
151 (Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
152 inline void operator ++() {operator ++(0);};
153 inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
154
155 // Comparison
156 inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
157 inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
158
159 // Accessors
160 inline Dependency *operator ->() {return Dep;};
161 inline Dependency const *operator ->() const {return Dep;};
162 inline Dependency &operator *() {return *Dep;};
163 inline Dependency const &operator *() const {return *Dep;};
164 inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
165 inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
6c139d6e 166
578bfd0a
AL
167 inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
168 inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
578bfd0a
AL
169 inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner);SmartTargetPkg(R);return R;};
170 inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
171 inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
578bfd0a 172 inline bool Reverse() {return Type == DepRev;};
f55a958f 173 inline unsigned long Index() const {return Dep - Owner->DepP;};
6c139d6e 174 bool IsCritical();
43d017d6 175 void GlobOr(DepIterator &Start,DepIterator &End);
6c139d6e
AL
176 Version **AllTargets();
177 bool SmartTargetPkg(PkgIterator &Result);
0a8e3465 178 const char *CompType();
43d017d6 179 const char *DepType();
0a8e3465 180
578bfd0a
AL
181 inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
182 Dep(Trg), Type(DepVer), Owner(&Owner)
183 {
184 if (Dep == 0)
185 Dep = Owner.DepP;
186 };
187 inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
188 Dep(Trg), Type(DepRev), Owner(&Owner)
189 {
190 if (Dep == 0)
191 Dep = Owner.DepP;
192 };
193 inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
194};
195
196// Provides iterator
197class pkgCache::PrvIterator
198{
199 Provides *Prv;
200 enum {PrvVer, PrvPkg} Type;
201 pkgCache *Owner;
202
203 void _dummy();
204
205 public:
206
207 // Iteration
208 void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
209 (Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
210 inline void operator ++() {operator ++(0);};
211 inline bool end() const {return Prv == Owner->ProvideP?true:false;};
212
213 // Comparison
214 inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
215 inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
216
217 // Accessors
218 inline Provides *operator ->() {return Prv;};
219 inline Provides const *operator ->() const {return Prv;};
220 inline Provides &operator *() {return *Prv;};
221 inline Provides const &operator *() const {return *Prv;};
222 inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
223 inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
6c139d6e 224
578bfd0a
AL
225 inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
226 inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
227 inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
228 inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
229 inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
f55a958f 230 inline unsigned long Index() const {return Prv - Owner->ProvideP;};
578bfd0a
AL
231
232 inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
233 Prv(Trg), Type(PrvVer), Owner(&Owner)
234 {
235 if (Prv == 0)
236 Prv = Owner.ProvideP;
237 };
238 inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) :
239 Prv(Trg), Type(PrvPkg), Owner(&Owner)
240 {
241 if (Prv == 0)
242 Prv = Owner.ProvideP;
243 };
244};
245
246// Package file
247class pkgCache::PkgFileIterator
248{
249 pkgCache *Owner;
250 PackageFile *File;
251
252 public:
253
254 // Iteration
255 void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
256 inline void operator ++() {operator ++(0);};
257 inline bool end() const {return File == Owner->PkgFileP?true:false;};
258
259 // Comparison
260 inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
261 inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
262
263 // Accessors
264 inline PackageFile *operator ->() {return File;};
265 inline PackageFile const *operator ->() const {return File;};
266 inline PackageFile const &operator *() const {return *File;};
267 inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
268 inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
269
270 inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
271 inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
272 inline const char *Distribution() const {return File->Distribution == 0?0:Owner->StrP + File->Distribution;};
f55a958f 273 inline unsigned long Index() const {return File - Owner->PkgFileP;};
578bfd0a
AL
274
275 bool IsOk();
276
277 // Constructors
278 inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP + Owner.Head().FileList) {};
279 inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
280};
281
dcb79bae
AL
282// Version File
283class pkgCache::VerFileIterator
284{
285 pkgCache *Owner;
286 VerFile *FileP;
287
288 public:
289
290 // Iteration
291 void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
292 inline void operator ++() {operator ++(0);};
293 inline bool end() const {return FileP == Owner->VerFileP?true:false;};
294
295 // Comparison
296 inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
297 inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
298
299 // Accessors
300 inline VerFile *operator ->() {return FileP;};
301 inline VerFile const *operator ->() const {return FileP;};
302 inline VerFile const &operator *() const {return *FileP;};
303 inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
304 inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
305
306 inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
307 inline unsigned long Index() const {return FileP - Owner->VerFileP;};
b518cca6 308
dcb79bae
AL
309 inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
310};
311
578bfd0a
AL
312// Inlined Begin functions cant be in the class because of order problems
313inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
314 {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
315inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
316 {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
317inline pkgCache::VerIterator pkgCache::PkgIterator::TargetVer() const
318 {return VerIterator(*Owner,Owner->VerP + Pkg->TargetVer);};
319inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
320 {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
321inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
322 {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
323inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
324 {return PrvIterator(Owner,Owner.ProvideP + Ver->ProvidesList,Ver);};
325inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
326 {return DepIterator(Owner,Owner.DepP + Ver->DependsList,Ver);};
dcb79bae
AL
327inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
328 {return VerFileIterator(Owner,Owner.VerFileP + Ver->FileList);};
578bfd0a
AL
329
330#endif