]> git.saurik.com Git - apt.git/blame - apt-pkg/cacheiterators.h
Added a RmFlag function to remvoe the loop flag, this should prevent any errors or...
[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
b3fdb998 32#include<iterator>
8ceeb9d6
DK
33
34#include<string.h>
773e2c1f
DK
35// abstract Iterator template /*{{{*/
36/* This template provides the very basic iterator methods we
5bf15716 37 need to have for doing some walk-over-the-cache magic */
b3fdb998
DK
38template<typename Str, typename Itr> class pkgCache::Iterator :
39 public std::iterator<std::forward_iterator_tag, Str> {
773e2c1f
DK
40 protected:
41 Str *S;
42 pkgCache *Owner;
43
44 /** \brief Returns the Pointer for this struct in the owner
45 * The implementation of this method should be pretty short
46 * as it will only return the Pointer into the mmap stored
47 * in the owner but the name of this pointer is different for
48 * each stucture and we want to abstract here at least for the
49 * basic methods from the actual structure.
50 * \return Pointer to the first structure of this type
51 */
52 virtual Str* OwnerPointer() const = 0;
53
54 public:
55 // Iteration
56 virtual void operator ++(int) = 0;
57 virtual void operator ++() = 0; // Should be {operator ++(0);};
58 inline bool end() const {return Owner == 0 || S == OwnerPointer();};
59
60 // Comparison
61 inline bool operator ==(const Itr &B) const {return S == B.S;};
62 inline bool operator !=(const Itr &B) const {return S != B.S;};
63
64 // Accessors
65 inline Str *operator ->() {return S;};
66 inline Str const *operator ->() const {return S;};
67 inline operator Str *() {return S == OwnerPointer() ? 0 : S;};
68 inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;};
9552aeeb 69 inline Str &operator *() {return *S;};
773e2c1f 70 inline Str const &operator *() const {return *S;};
ffee1c2b 71 inline pkgCache *Cache() const {return Owner;};
773e2c1f
DK
72
73 // Mixed stuff
74 inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;};
75 inline bool IsGood() const { return S && Owner && ! end();};
76 inline unsigned long Index() const {return S - OwnerPointer();};
77
f7a35f2e
DK
78 void ReMap(void const * const oldMap, void const * const newMap) {
79 if (Owner == 0 || S == 0)
a9fe5928
DK
80 return;
81 S += (Str*)(newMap) - (Str*)(oldMap);
82 }
83
773e2c1f
DK
84 // Constructors - look out for the variable assigning
85 inline Iterator() : S(0), Owner(0) {};
86 inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {};
5bf15716
DK
87};
88 /*}}}*/
89// Group Iterator /*{{{*/
90/* Packages with the same name are collected in a Group so someone only
91 interest in package names can iterate easily over the names, so the
92 different architectures can be treated as of the "same" package
93 (apt internally treat them as totally different packages) */
94class pkgCache::GrpIterator: public Iterator<Group, GrpIterator> {
25396fb0
DK
95 long HashIndex;
96
5bf15716
DK
97 protected:
98 inline Group* OwnerPointer() const {
c55b8a54 99 return (Owner != 0) ? Owner->GrpP : 0;
5bf15716
DK
100 };
101
102 public:
25396fb0
DK
103 // This constructor is the 'begin' constructor, never use it.
104 inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
105 S = OwnerPointer();
106 operator ++(0);
107 };
108
109 virtual void operator ++(int);
5bf15716
DK
110 virtual void operator ++() {operator ++(0);};
111
112 inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
113 inline PkgIterator PackageList() const;
e841200b 114 PkgIterator FindPkg(string Arch = "any") const;
bd2fb30a
DK
115 /** \brief find the package with the "best" architecture
116
117 The best architecture is either the "native" or the first
3db58cf4
DK
118 in the list of Architectures which is not an end-Pointer
119
120 \param PreferNonVirtual tries to respond with a non-virtual package
121 and only if this fails returns the best virtual package */
122 PkgIterator FindPreferredPkg(bool const &PreferNonVirtual = true) const;
e841200b 123 PkgIterator NextPkg(PkgIterator const &Pkg) const;
5bf15716
DK
124
125 // Constructors
25396fb0 126 inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
5bf15716
DK
127 if (S == 0)
128 S = OwnerPointer();
129 };
25396fb0 130 inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {};
5bf15716 131
773e2c1f
DK
132};
133 /*}}}*/
92fcbfc1 134// Package Iterator /*{{{*/
773e2c1f
DK
135class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
136 long HashIndex;
137
138 protected:
139 inline Package* OwnerPointer() const {
c55b8a54 140 return (Owner != 0) ? Owner->PkgP : 0;
773e2c1f
DK
141 };
142
143 public:
144 // This constructor is the 'begin' constructor, never use it.
145 inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
146 S = OwnerPointer();
147 operator ++(0);
148 };
149
150 virtual void operator ++(int);
151 virtual void operator ++() {operator ++(0);};
152
153 enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
154
155 // Accessors
156 inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
157 inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
158 inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
159 (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);};
5bf15716
DK
160 inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;};
161 inline GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);};
773e2c1f
DK
162
163 inline VerIterator VersionList() const;
164 inline VerIterator CurrentVer() const;
165 inline DepIterator RevDependsList() const;
166 inline PrvIterator ProvidesList() const;
167 OkState State() const;
168 const char *CandVersion() const;
169 const char *CurVersion() const;
170
171 //Nice printable representation
172 friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
75ce2062 173 std::string FullName(bool const &Pretty = false) const;
773e2c1f
DK
174
175 // Constructors
176 inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
177 if (S == 0)
178 S = OwnerPointer();
179 };
180 inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
578bfd0a 181};
92fcbfc1
DK
182 /*}}}*/
183// Version Iterator /*{{{*/
773e2c1f
DK
184class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
185 protected:
186 inline Version* OwnerPointer() const {
c55b8a54 187 return (Owner != 0) ? Owner->VerP : 0;
773e2c1f
DK
188 };
189
190 public:
191 // Iteration
192 void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
193 inline void operator ++() {operator ++(0);};
194
195 // Comparison
196 int CompareVer(const VerIterator &B) const;
8ceeb9d6
DK
197 /** \brief compares two version and returns if they are similar
198
199 This method should be used to identify if two pseudo versions are
200 refering to the same "real" version */
201 inline bool SimilarVer(const VerIterator &B) const {
202 return (B.end() == false && S->Hash == B->Hash && strcmp(VerStr(), B.VerStr()) == 0);
203 };
773e2c1f
DK
204
205 // Accessors
206 inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;};
207 inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
c5dac10c 208 inline const char *Arch() const {
ca238ede
DK
209 if (S->MultiArch == pkgCache::Version::All ||
210 S->MultiArch == pkgCache::Version::AllForeign ||
211 S->MultiArch == pkgCache::Version::AllAllowed)
212 return "all";
c5dac10c
DK
213 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
214 };
28166356 215 __deprecated inline const char *Arch(bool const pseudo) const {
c5dac10c
DK
216 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
217 };
773e2c1f
DK
218 inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
219
220 inline DescIterator DescriptionList() const;
221 DescIterator TranslatedDescription() const;
222 inline DepIterator DependsList() const;
223 inline PrvIterator ProvidesList() const;
224 inline VerFileIterator FileList() const;
225 bool Downloadable() const;
d4489d49
DK
226 inline const char *PriorityType() const {return Owner->Priority(S->Priority);};
227 string RelStr() const;
773e2c1f
DK
228
229 bool Automatic() const;
28166356 230 __deprecated bool Pseudo() const;
773e2c1f
DK
231 VerFileIterator NewestFile() const;
232
233 inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
234 if (S == 0)
235 S = OwnerPointer();
236 };
237 inline VerIterator() : Iterator<Version, VerIterator>() {};
578bfd0a 238};
92fcbfc1
DK
239 /*}}}*/
240// Description Iterator /*{{{*/
773e2c1f
DK
241class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
242 protected:
243 inline Description* OwnerPointer() const {
c55b8a54 244 return (Owner != 0) ? Owner->DescP : 0;
773e2c1f
DK
245 };
246
247 public:
248 // Iteration
249 void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
250 inline void operator ++() {operator ++(0);};
251
252 // Comparison
253 int CompareDesc(const DescIterator &B) const;
254
255 // Accessors
256 inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
257 inline const char *md5() const {return Owner->StrP + S->md5sum;};
258 inline DescFileIterator FileList() const;
259
260 inline DescIterator() : Iterator<Description, DescIterator>() {};
261 inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
262 if (S == 0)
263 S = Owner.DescP;
264 };
a52f938b 265};
92fcbfc1
DK
266 /*}}}*/
267// Dependency iterator /*{{{*/
773e2c1f
DK
268class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
269 enum {DepVer, DepRev} Type;
270
271 protected:
272 inline Dependency* OwnerPointer() const {
c55b8a54 273 return (Owner != 0) ? Owner->DepP : 0;
773e2c1f
DK
274 };
275
276 public:
277 // Iteration
278 void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
279 (Type == DepVer ? S->NextDepends : S->NextRevDepends);};
280 inline void operator ++() {operator ++(0);};
281
282 // Accessors
283 inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
e841200b
DK
284 inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
285 inline PkgIterator SmartTargetPkg() const {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
286 inline VerIterator ParentVer() const {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
287 inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
288 inline bool Reverse() const {return Type == DepRev;};
289 bool IsCritical() const;
df77d8a5 290 bool IsNegative() const;
773e2c1f 291 void GlobOr(DepIterator &Start,DepIterator &End);
e841200b
DK
292 Version **AllTargets() const;
293 bool SmartTargetPkg(PkgIterator &Result) const;
294 inline const char *CompType() const {return Owner->CompType(S->CompareOp);};
295 inline const char *DepType() const {return Owner->DepType(S->Type);};
773e2c1f 296
47f6d1b7
DK
297 //Nice printable representation
298 friend std::ostream& operator <<(std::ostream& out, DepIterator D);
299
773e2c1f
DK
300 inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
301 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
302 if (S == 0)
303 S = Owner.DepP;
304 };
305 inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
306 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
307 if (S == 0)
308 S = Owner.DepP;
309 };
310 inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
578bfd0a 311};
92fcbfc1
DK
312 /*}}}*/
313// Provides iterator /*{{{*/
773e2c1f
DK
314class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
315 enum {PrvVer, PrvPkg} Type;
316
317 protected:
318 inline Provides* OwnerPointer() const {
c55b8a54 319 return (Owner != 0) ? Owner->ProvideP : 0;
773e2c1f
DK
320 };
321
322 public:
323 // Iteration
324 void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
325 (Type == PrvVer?S->NextPkgProv:S->NextProvides);};
326 inline void operator ++() {operator ++(0);};
327
328 // Accessors
329 inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
330 inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
e841200b
DK
331 inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
332 inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);};
333 inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};
773e2c1f
DK
334
335 inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
336
337 inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
338 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
339 if (S == 0)
340 S = Owner.ProvideP;
341 };
342 inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
343 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
344 if (S == 0)
345 S = Owner.ProvideP;
346 };
578bfd0a 347};
92fcbfc1
DK
348 /*}}}*/
349// Package file /*{{{*/
773e2c1f
DK
350class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
351 protected:
352 inline PackageFile* OwnerPointer() const {
c55b8a54 353 return (Owner != 0) ? Owner->PkgFileP : 0;
773e2c1f
DK
354 };
355
356 public:
357 // Iteration
358 void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
359 inline void operator ++() {operator ++(0);};
360
361 // Accessors
362 inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
363 inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
364 inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
365 inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
366 inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
367 inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
368 inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
369 inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
370 inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
371 inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
372
373 bool IsOk();
374 string RelStr();
375
376 // Constructors
377 inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
a04cd1f9
DK
378 inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {};
379 inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
578bfd0a 380};
92fcbfc1
DK
381 /*}}}*/
382// Version File /*{{{*/
773e2c1f
DK
383class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
384 protected:
385 inline VerFile* OwnerPointer() const {
c55b8a54 386 return (Owner != 0) ? Owner->VerFileP : 0;
773e2c1f
DK
387 };
388
389 public:
390 // Iteration
391 void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
392 inline void operator ++() {operator ++(0);};
393
394 // Accessors
395 inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
396
397 inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
398 inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
dcb79bae 399};
92fcbfc1
DK
400 /*}}}*/
401// Description File /*{{{*/
773e2c1f
DK
402class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
403 protected:
404 inline DescFile* OwnerPointer() const {
c55b8a54 405 return (Owner != 0) ? Owner->DescFileP : 0;
773e2c1f
DK
406 };
407
408 public:
409 // Iteration
410 void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
411 inline void operator ++() {operator ++(0);};
412
413 // Accessors
414 inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
415
416 inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
417 inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
a52f938b 418};
92fcbfc1
DK
419 /*}}}*/
420// Inlined Begin functions cant be in the class because of order problems /*{{{*/
5bf15716
DK
421inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
422 {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);};
578bfd0a 423inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
773e2c1f 424 {return VerIterator(*Owner,Owner->VerP + S->VersionList);};
578bfd0a 425inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
773e2c1f 426 {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
578bfd0a 427inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
773e2c1f 428 {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
578bfd0a 429inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
773e2c1f 430 {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
a52f938b 431inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
773e2c1f 432 {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
578bfd0a 433inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
773e2c1f 434 {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
578bfd0a 435inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
773e2c1f 436 {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
dcb79bae 437inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
773e2c1f 438 {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
a52f938b 439inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
773e2c1f 440 {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
92fcbfc1 441 /*}}}*/
578bfd0a 442#endif