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