]> git.saurik.com Git - apt.git/blame - apt-pkg/cacheiterators.h
merge MultiArch-ABI. We don't support MultiArch yet (as most other tools),
[apt.git] / apt-pkg / cacheiterators.h
CommitLineData
578bfd0a
AL
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
578bfd0a
AL
3/* ######################################################################
4
5 Cache Iterators - Iterators for navigating the cache structure
6
7 The iterators all provides ++,==,!=,->,* and end for their type.
8 The end function can be used to tell if the list has been fully
9 traversed.
10
11 Unlike STL iterators these contain helper functions to access the data
12 that is being iterated over. This is because the data structures can't
13 be formed in a manner that is intuitive to use and also mmapable.
14
15 For each variable in the target structure that would need a translation
16 to be accessed correctly a translating function of the same name is
17 present in the iterator. If applicable the translating function will
18 return an iterator.
19
20 The DepIterator can iterate over two lists, a list of 'version depends'
21 or a list of 'package reverse depends'. The type is determined by the
22 structure passed to the constructor, which should be the structure
6c139d6e
AL
23 that has the depends pointer as a member. The provide iterator has the
24 same system.
578bfd0a 25
094a497d 26 This header is not user includable, please use apt-pkg/pkgcache.h
578bfd0a
AL
27
28 ##################################################################### */
29 /*}}}*/
578bfd0a
AL
30#ifndef PKGLIB_CACHEITERATORS_H
31#define PKGLIB_CACHEITERATORS_H
773e2c1f
DK
32// abstract Iterator template /*{{{*/
33/* This template provides the very basic iterator methods we
5bf15716 34 need to have for doing some walk-over-the-cache magic */
773e2c1f 35template<typename Str, typename Itr> class pkgCache::Iterator {
773e2c1f
DK
36 protected:
37 Str *S;
38 pkgCache *Owner;
39
40 /** \brief Returns the Pointer for this struct in the owner
41 * The implementation of this method should be pretty short
42 * as it will only return the Pointer into the mmap stored
43 * in the owner but the name of this pointer is different for
44 * each stucture and we want to abstract here at least for the
45 * basic methods from the actual structure.
46 * \return Pointer to the first structure of this type
47 */
48 virtual Str* OwnerPointer() const = 0;
49
50 public:
51 // Iteration
52 virtual void operator ++(int) = 0;
53 virtual void operator ++() = 0; // Should be {operator ++(0);};
54 inline bool end() const {return Owner == 0 || S == OwnerPointer();};
55
56 // Comparison
57 inline bool operator ==(const Itr &B) const {return S == B.S;};
58 inline bool operator !=(const Itr &B) const {return S != B.S;};
59
60 // Accessors
61 inline Str *operator ->() {return S;};
62 inline Str const *operator ->() const {return S;};
63 inline operator Str *() {return S == OwnerPointer() ? 0 : S;};
64 inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;};
65 inline Str const &operator *() const {return *S;};
66 inline pkgCache *Cache() {return Owner;};
67
68 // Mixed stuff
69 inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;};
70 inline bool IsGood() const { return S && Owner && ! end();};
71 inline unsigned long Index() const {return S - OwnerPointer();};
72
73 // Constructors - look out for the variable assigning
74 inline Iterator() : S(0), Owner(0) {};
75 inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {};
5bf15716
DK
76};
77 /*}}}*/
78// Group Iterator /*{{{*/
79/* Packages with the same name are collected in a Group so someone only
80 interest in package names can iterate easily over the names, so the
81 different architectures can be treated as of the "same" package
82 (apt internally treat them as totally different packages) */
83class pkgCache::GrpIterator: public Iterator<Group, GrpIterator> {
25396fb0
DK
84 long HashIndex;
85
5bf15716
DK
86 protected:
87 inline Group* OwnerPointer() const {
88 return Owner->GrpP;
89 };
90
91 public:
25396fb0
DK
92 // This constructor is the 'begin' constructor, never use it.
93 inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
94 S = OwnerPointer();
95 operator ++(0);
96 };
97
98 virtual void operator ++(int);
5bf15716
DK
99 virtual void operator ++() {operator ++(0);};
100
101 inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
102 inline PkgIterator PackageList() const;
103 PkgIterator FindPkg(string Arch = "any");
104 PkgIterator NextPkg(PkgIterator const &Pkg);
105
106 // Constructors
25396fb0 107 inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
5bf15716
DK
108 if (S == 0)
109 S = OwnerPointer();
110 };
25396fb0 111 inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {};
5bf15716 112
773e2c1f
DK
113};
114 /*}}}*/
92fcbfc1 115// Package Iterator /*{{{*/
773e2c1f
DK
116class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
117 long HashIndex;
118
119 protected:
120 inline Package* OwnerPointer() const {
121 return Owner->PkgP;
122 };
123
124 public:
125 // This constructor is the 'begin' constructor, never use it.
126 inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
127 S = OwnerPointer();
128 operator ++(0);
129 };
130
131 virtual void operator ++(int);
132 virtual void operator ++() {operator ++(0);};
133
134 enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
135
136 // Accessors
137 inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
138 inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
139 inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
140 (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);};
5bf15716
DK
141 inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;};
142 inline GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);};
773e2c1f
DK
143
144 inline VerIterator VersionList() const;
145 inline VerIterator CurrentVer() const;
146 inline DepIterator RevDependsList() const;
147 inline PrvIterator ProvidesList() const;
148 OkState State() const;
149 const char *CandVersion() const;
150 const char *CurVersion() const;
151
152 //Nice printable representation
153 friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
75ce2062 154 std::string FullName(bool const &Pretty = false) const;
773e2c1f
DK
155
156 // Constructors
157 inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
158 if (S == 0)
159 S = OwnerPointer();
160 };
161 inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
578bfd0a 162};
92fcbfc1
DK
163 /*}}}*/
164// Version Iterator /*{{{*/
773e2c1f
DK
165class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
166 protected:
167 inline Version* OwnerPointer() const {
168 return Owner->VerP;
169 };
170
171 public:
172 // Iteration
173 void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
174 inline void operator ++() {operator ++(0);};
175
176 // Comparison
177 int CompareVer(const VerIterator &B) const;
178
179 // Accessors
180 inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;};
181 inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
c5dac10c
DK
182 inline const char *Arch() const {
183 if(S->MultiArch == pkgCache::Version::All)
184 return "all";
185 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
186 };
187 inline const char *Arch(bool const pseudo) const {
188 if(pseudo == false)
189 return Arch();
190 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
191 };
773e2c1f
DK
192 inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
193
194 inline DescIterator DescriptionList() const;
195 DescIterator TranslatedDescription() const;
196 inline DepIterator DependsList() const;
197 inline PrvIterator ProvidesList() const;
198 inline VerFileIterator FileList() const;
199 bool Downloadable() const;
200 inline const char *PriorityType() {return Owner->Priority(S->Priority);};
201 string RelStr();
202
203 bool Automatic() const;
803ea2a8 204 bool Pseudo() const;
773e2c1f
DK
205 VerFileIterator NewestFile() const;
206
207 inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
208 if (S == 0)
209 S = OwnerPointer();
210 };
211 inline VerIterator() : Iterator<Version, VerIterator>() {};
578bfd0a 212};
92fcbfc1
DK
213 /*}}}*/
214// Description Iterator /*{{{*/
773e2c1f
DK
215class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
216 protected:
217 inline Description* OwnerPointer() const {
218 return Owner->DescP;
219 };
220
221 public:
222 // Iteration
223 void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
224 inline void operator ++() {operator ++(0);};
225
226 // Comparison
227 int CompareDesc(const DescIterator &B) const;
228
229 // Accessors
230 inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
231 inline const char *md5() const {return Owner->StrP + S->md5sum;};
232 inline DescFileIterator FileList() const;
233
234 inline DescIterator() : Iterator<Description, DescIterator>() {};
235 inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
236 if (S == 0)
237 S = Owner.DescP;
238 };
a52f938b 239};
92fcbfc1
DK
240 /*}}}*/
241// Dependency iterator /*{{{*/
773e2c1f
DK
242class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
243 enum {DepVer, DepRev} Type;
244
245 protected:
246 inline Dependency* OwnerPointer() const {
247 return Owner->DepP;
248 };
249
250 public:
251 // Iteration
252 void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
253 (Type == DepVer ? S->NextDepends : S->NextRevDepends);};
254 inline void operator ++() {operator ++(0);};
255
256 // Accessors
257 inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
258 inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
259 inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
260 inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
261 inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
262 inline bool Reverse() {return Type == DepRev;};
263 bool IsCritical();
264 void GlobOr(DepIterator &Start,DepIterator &End);
265 Version **AllTargets();
266 bool SmartTargetPkg(PkgIterator &Result);
267 inline const char *CompType() {return Owner->CompType(S->CompareOp);};
268 inline const char *DepType() {return Owner->DepType(S->Type);};
269
270 inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
271 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
272 if (S == 0)
273 S = Owner.DepP;
274 };
275 inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
276 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
277 if (S == 0)
278 S = Owner.DepP;
279 };
280 inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
578bfd0a 281};
92fcbfc1
DK
282 /*}}}*/
283// Provides iterator /*{{{*/
773e2c1f
DK
284class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
285 enum {PrvVer, PrvPkg} Type;
286
287 protected:
288 inline Provides* OwnerPointer() const {
289 return Owner->ProvideP;
290 };
291
292 public:
293 // Iteration
294 void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
295 (Type == PrvVer?S->NextPkgProv:S->NextProvides);};
296 inline void operator ++() {operator ++(0);};
297
298 // Accessors
299 inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
300 inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
301 inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
302 inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + S->Version);};
303 inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};
304
305 inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
306
307 inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
308 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
309 if (S == 0)
310 S = Owner.ProvideP;
311 };
312 inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
313 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
314 if (S == 0)
315 S = Owner.ProvideP;
316 };
578bfd0a 317};
92fcbfc1
DK
318 /*}}}*/
319// Package file /*{{{*/
773e2c1f
DK
320class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
321 protected:
322 inline PackageFile* OwnerPointer() const {
323 return Owner->PkgFileP;
324 };
325
326 public:
327 // Iteration
328 void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
329 inline void operator ++() {operator ++(0);};
330
331 // Accessors
332 inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
333 inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
334 inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
335 inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
336 inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
337 inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
338 inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
339 inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
340 inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
341 inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
342
343 bool IsOk();
344 string RelStr();
345
346 // Constructors
347 inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
a04cd1f9
DK
348 inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {};
349 inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
578bfd0a 350};
92fcbfc1
DK
351 /*}}}*/
352// Version File /*{{{*/
773e2c1f
DK
353class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
354 protected:
355 inline VerFile* OwnerPointer() const {
356 return Owner->VerFileP;
357 };
358
359 public:
360 // Iteration
361 void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
362 inline void operator ++() {operator ++(0);};
363
364 // Accessors
365 inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
366
367 inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
368 inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
dcb79bae 369};
92fcbfc1
DK
370 /*}}}*/
371// Description File /*{{{*/
773e2c1f
DK
372class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
373 protected:
374 inline DescFile* OwnerPointer() const {
375 return Owner->DescFileP;
376 };
377
378 public:
379 // Iteration
380 void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
381 inline void operator ++() {operator ++(0);};
382
383 // Accessors
384 inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
385
386 inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
387 inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
a52f938b 388};
92fcbfc1
DK
389 /*}}}*/
390// Inlined Begin functions cant be in the class because of order problems /*{{{*/
5bf15716
DK
391inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
392 {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);};
578bfd0a 393inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
773e2c1f 394 {return VerIterator(*Owner,Owner->VerP + S->VersionList);};
578bfd0a 395inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
773e2c1f 396 {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
578bfd0a 397inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
773e2c1f 398 {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
578bfd0a 399inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
773e2c1f 400 {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
a52f938b 401inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
773e2c1f 402 {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
578bfd0a 403inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
773e2c1f 404 {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
578bfd0a 405inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
773e2c1f 406 {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
dcb79bae 407inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
773e2c1f 408 {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
a52f938b 409inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
773e2c1f 410 {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
92fcbfc1 411 /*}}}*/
578bfd0a 412#endif