1 // -*- mode: cpp; mode: fold -*-
3 /* ######################################################################
5 Cache Iterators - Iterators for navigating the cache structure
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
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.
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
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
23 that has the depends pointer as a member. The provide iterator has the
26 This header is not user includable, please use apt-pkg/pkgcache.h
28 ##################################################################### */
30 #ifndef PKGLIB_CACHEITERATORS_H
31 #define PKGLIB_CACHEITERATORS_H
32 #include<apt-pkg/pkgcache.h>
33 #include<apt-pkg/macros.h>
38 #ifdef APT_PKG_EXPOSE_STRING_VIEW
39 #include <apt-pkg/string_view.h>
44 // abstract Iterator template /*{{{*/
45 /* This template provides the very basic iterator methods we
46 need to have for doing some walk-over-the-cache magic */
47 template<typename Str
, typename Itr
> class pkgCache::Iterator
:
48 public std::iterator
<std::forward_iterator_tag
, Str
> {
49 /** \brief Returns the Pointer for this struct in the owner
50 * The implementation of this method should be pretty short
51 * as it will only return the Pointer into the mmap stored
52 * in the owner but the name of this pointer is different for
53 * each structure and we want to abstract here at least for the
54 * basic methods from the actual structure.
55 * \return Pointer to the first structure of this type
57 Str
* OwnerPointer() const { return static_cast<Itr
const*>(this)->OwnerPointer(); }
65 inline bool end() const {return Owner
== 0 || S
== OwnerPointer();}
68 inline bool operator ==(const Itr
&B
) const {return S
== B
.S
;}
69 inline bool operator !=(const Itr
&B
) const {return S
!= B
.S
;}
72 inline Str
*operator ->() {return S
;}
73 inline Str
const *operator ->() const {return S
;}
74 inline operator Str
*() {return S
== OwnerPointer() ? 0 : S
;}
75 inline operator Str
const *() const {return S
== OwnerPointer() ? 0 : S
;}
76 inline Str
&operator *() {return *S
;}
77 inline Str
const &operator *() const {return *S
;}
78 inline pkgCache
*Cache() const {return Owner
;}
81 inline bool IsGood() const { return S
&& Owner
&& ! end();}
82 inline unsigned long Index() const {return S
- OwnerPointer();}
84 void ReMap(void const * const oldMap
, void const * const newMap
) {
85 if (Owner
== 0 || S
== 0)
87 S
+= (Str
const * const)(newMap
) - (Str
const * const)(oldMap
);
90 // Constructors - look out for the variable assigning
91 inline Iterator() : S(0), Owner(0) {}
92 inline Iterator(pkgCache
&Owner
,Str
*T
= 0) : S(T
), Owner(&Owner
) {}
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) */
100 class pkgCache::GrpIterator
: public Iterator
<Group
, GrpIterator
> {
104 inline Group
* OwnerPointer() const {
105 return (Owner
!= 0) ? Owner
->GrpP
: 0;
108 // This constructor is the 'begin' constructor, never use it.
109 explicit inline GrpIterator(pkgCache
&Owner
) : Iterator
<Group
, GrpIterator
>(Owner
), HashIndex(-1) {
114 GrpIterator
& operator++();
115 inline GrpIterator
operator++(int) { GrpIterator
const tmp(*this); operator++(); return tmp
; }
117 inline const char *Name() const {return S
->Name
== 0?0:Owner
->StrP
+ S
->Name
;}
118 inline PkgIterator
PackageList() const;
119 PkgIterator
FindPkg(std::string Arch
= "any") const;
120 #ifdef APT_PKG_EXPOSE_STRING_VIEW
121 APT_HIDDEN PkgIterator
FindPkg(APT::StringView Arch
= APT::StringView("any", 3)) const;
122 APT_HIDDEN PkgIterator
FindPkg(const char *Arch
) const;
124 /** \brief find the package with the "best" architecture
126 The best architecture is either the "native" or the first
127 in the list of Architectures which is not an end-Pointer
129 \param PreferNonVirtual tries to respond with a non-virtual package
130 and only if this fails returns the best virtual package */
131 PkgIterator
FindPreferredPkg(bool const &PreferNonVirtual
= true) const;
132 PkgIterator
NextPkg(PkgIterator
const &Pkg
) const;
135 inline GrpIterator(pkgCache
&Owner
, Group
*Trg
) : Iterator
<Group
, GrpIterator
>(Owner
, Trg
), HashIndex(0) {
139 inline GrpIterator() : Iterator
<Group
, GrpIterator
>(), HashIndex(0) {}
143 // Package Iterator /*{{{*/
144 class pkgCache::PkgIterator
: public Iterator
<Package
, PkgIterator
> {
148 inline Package
* OwnerPointer() const {
149 return (Owner
!= 0) ? Owner
->PkgP
: 0;
152 // This constructor is the 'begin' constructor, never use it.
153 explicit inline PkgIterator(pkgCache
&Owner
) : Iterator
<Package
, PkgIterator
>(Owner
), HashIndex(-1) {
158 PkgIterator
& operator++();
159 inline PkgIterator
operator++(int) { PkgIterator
const tmp(*this); operator++(); return tmp
; }
161 enum OkState
{NeedsNothing
,NeedsUnpack
,NeedsConfigure
};
164 inline const char *Name() const { return Group().Name(); }
165 // Versions have sections - and packages can have different versions with different sections
166 // so this interface is broken by design. Run as fast as you can to Version.Section().
167 APT_DEPRECATED_MSG("Use the .Section method of VerIterator instead") inline const char *Section() const;
168 inline bool Purge() const {return S
->CurrentState
== pkgCache::State::Purge
||
169 (S
->CurrentVer
== 0 && S
->CurrentState
== pkgCache::State::NotInstalled
);}
170 inline const char *Arch() const {return S
->Arch
== 0?0:Owner
->StrP
+ S
->Arch
;}
171 inline APT_PURE GrpIterator
Group() const { return GrpIterator(*Owner
, Owner
->GrpP
+ S
->Group
);}
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 APT_DEPRECATED_MSG("This method does not respect apt_preferences! Use pkgDepCache::GetCandidateVersion(Pkg)") const char *CandVersion() const APT_PURE
;
179 const char *CurVersion() const APT_PURE
;
181 //Nice printable representation
182 APT_DEPRECATED_MSG("Use APT::PrettyPkg instead") friend std::ostream
& operator <<(std::ostream
& out
, PkgIterator i
);
183 std::string
FullName(bool const &Pretty
= false) const;
186 inline PkgIterator(pkgCache
&Owner
,Package
*Trg
) : Iterator
<Package
, PkgIterator
>(Owner
, Trg
), HashIndex(0) {
190 inline PkgIterator() : Iterator
<Package
, PkgIterator
>(), HashIndex(0) {}
193 // Version Iterator /*{{{*/
194 class pkgCache::VerIterator
: public Iterator
<Version
, VerIterator
> {
196 inline Version
* OwnerPointer() const {
197 return (Owner
!= 0) ? Owner
->VerP
: 0;
201 inline VerIterator
& operator++() {if (S
!= Owner
->VerP
) S
= Owner
->VerP
+ S
->NextVer
; return *this;}
202 inline VerIterator
operator++(int) { VerIterator
const tmp(*this); operator++(); return tmp
; }
205 int CompareVer(const VerIterator
&B
) const;
206 /** \brief compares two version and returns if they are similar
208 This method should be used to identify if two pseudo versions are
209 referring to the same "real" version */
210 inline bool SimilarVer(const VerIterator
&B
) const {
211 return (B
.end() == false && S
->Hash
== B
->Hash
&& strcmp(VerStr(), B
.VerStr()) == 0);
215 inline const char *VerStr() const {return S
->VerStr
== 0?0:Owner
->StrP
+ S
->VerStr
;}
216 inline const char *Section() const {return S
->Section
== 0?0:Owner
->StrP
+ S
->Section
;}
217 /** \brief source package name this version comes from
218 Always contains the name, even if it is the same as the binary name */
219 inline const char *SourcePkgName() const {return Owner
->StrP
+ S
->SourcePkgName
;}
220 /** \brief source version this version comes from
221 Always contains the version string, even if it is the same as the binary version */
222 inline const char *SourceVerStr() const {return Owner
->StrP
+ S
->SourceVerStr
;}
223 inline const char *Arch() const {
224 if ((S
->MultiArch
& pkgCache::Version::All
) == pkgCache::Version::All
)
226 return S
->ParentPkg
== 0?0:Owner
->StrP
+ ParentPkg()->Arch
;
228 inline PkgIterator
ParentPkg() const {return PkgIterator(*Owner
,Owner
->PkgP
+ S
->ParentPkg
);}
230 inline DescIterator
DescriptionList() const;
231 DescIterator
TranslatedDescription() const;
232 inline DepIterator
DependsList() const;
233 inline PrvIterator
ProvidesList() const;
234 inline VerFileIterator
FileList() const;
235 bool Downloadable() const;
236 inline const char *PriorityType() const {return Owner
->Priority(S
->Priority
);}
237 const char *MultiArchType() const APT_PURE
;
238 std::string
RelStr() const;
240 bool Automatic() const;
241 VerFileIterator
NewestFile() const;
243 inline VerIterator(pkgCache
&Owner
,Version
*Trg
= 0) : Iterator
<Version
, VerIterator
>(Owner
, Trg
) {
247 inline VerIterator() : Iterator
<Version
, VerIterator
>() {}
250 // Description Iterator /*{{{*/
251 class pkgCache::DescIterator
: public Iterator
<Description
, DescIterator
> {
253 inline Description
* OwnerPointer() const {
254 return (Owner
!= 0) ? Owner
->DescP
: 0;
258 inline DescIterator
& operator++() {if (S
!= Owner
->DescP
) S
= Owner
->DescP
+ S
->NextDesc
; return *this;}
259 inline DescIterator
operator++(int) { DescIterator
const tmp(*this); operator++(); return tmp
; }
262 int CompareDesc(const DescIterator
&B
) const;
265 inline const char *LanguageCode() const {return Owner
->StrP
+ S
->language_code
;}
266 inline const char *md5() const {return Owner
->StrP
+ S
->md5sum
;}
267 inline DescFileIterator
FileList() const;
269 inline DescIterator() : Iterator
<Description
, DescIterator
>() {}
270 inline DescIterator(pkgCache
&Owner
,Description
*Trg
= 0) : Iterator
<Description
, DescIterator
>(Owner
, Trg
) {
276 // Dependency iterator /*{{{*/
277 class pkgCache::DepIterator
: public Iterator
<Dependency
, DepIterator
> {
278 enum {DepVer
, DepRev
} Type
;
282 inline Dependency
* OwnerPointer() const {
283 return (Owner
!= 0) ? Owner
->DepP
: 0;
287 DepIterator
& operator++();
288 inline DepIterator
operator++(int) { DepIterator
const tmp(*this); operator++(); return tmp
; }
291 inline const char *TargetVer() const {return S2
->Version
== 0?0:Owner
->StrP
+ S2
->Version
;}
292 inline PkgIterator
TargetPkg() const {return PkgIterator(*Owner
,Owner
->PkgP
+ S2
->Package
);}
293 inline PkgIterator
SmartTargetPkg() const {PkgIterator
R(*Owner
,0);SmartTargetPkg(R
);return R
;}
294 inline VerIterator
ParentVer() const {return VerIterator(*Owner
,Owner
->VerP
+ S
->ParentVer
);}
295 inline PkgIterator
ParentPkg() const {return PkgIterator(*Owner
,Owner
->PkgP
+ Owner
->VerP
[S
->ParentVer
].ParentPkg
);}
296 inline bool Reverse() const {return Type
== DepRev
;}
297 bool IsCritical() const APT_PURE
;
298 bool IsNegative() const APT_PURE
;
299 bool IsIgnorable(PrvIterator
const &Prv
) const APT_PURE
;
300 bool IsIgnorable(PkgIterator
const &Pkg
) const APT_PURE
;
301 /* MultiArch can be translated to SingleArch for an resolver and we did so,
302 by adding dependencies to help the resolver understand the problem, but
303 sometimes it is needed to identify these to ignore them… */
304 inline bool IsMultiArchImplicit() const APT_PURE
{
305 return (S2
->CompareOp
& pkgCache::Dep::MultiArchImplicit
) == pkgCache::Dep::MultiArchImplicit
;
307 /* This covers additionally negative dependencies, which aren't arch-specific,
308 but change architecture nonetheless as a Conflicts: foo does applies for all archs */
309 bool IsImplicit() const APT_PURE
;
311 bool IsSatisfied(VerIterator
const &Ver
) const APT_PURE
;
312 bool IsSatisfied(PrvIterator
const &Prv
) const APT_PURE
;
313 void GlobOr(DepIterator
&Start
,DepIterator
&End
);
314 Version
**AllTargets() const;
315 bool SmartTargetPkg(PkgIterator
&Result
) const;
316 inline const char *CompType() const {return Owner
->CompType(S2
->CompareOp
);}
317 inline const char *DepType() const {return Owner
->DepType(S2
->Type
);}
319 // overrides because we are special
320 struct DependencyProxy
322 map_stringitem_t
&Version
;
323 map_pointer_t
&Package
;
326 unsigned char &CompareOp
;
327 map_pointer_t
&ParentVer
;
328 map_pointer_t
&DependencyData
;
329 map_pointer_t
&NextRevDepends
;
330 map_pointer_t
&NextDepends
;
331 map_pointer_t
&NextData
;
332 DependencyProxy
const * operator->() const { return this; }
333 DependencyProxy
* operator->() { return this; }
335 inline DependencyProxy
operator->() const {return (DependencyProxy
) { S2
->Version
, S2
->Package
, S
->ID
, S2
->Type
, S2
->CompareOp
, S
->ParentVer
, S
->DependencyData
, S
->NextRevDepends
, S
->NextDepends
, S2
->NextData
};}
336 inline DependencyProxy
operator->() {return (DependencyProxy
) { S2
->Version
, S2
->Package
, S
->ID
, S2
->Type
, S2
->CompareOp
, S
->ParentVer
, S
->DependencyData
, S
->NextRevDepends
, S
->NextDepends
, S2
->NextData
};}
337 void ReMap(void const * const oldMap
, void const * const newMap
)
339 Iterator
<Dependency
, DepIterator
>::ReMap(oldMap
, newMap
);
340 if (Owner
== 0 || S
== 0 || S2
== 0)
342 S2
+= (DependencyData
const * const)(newMap
) - (DependencyData
const * const)(oldMap
);
345 //Nice printable representation
346 APT_DEPRECATED_MSG("Use APT::PrettyDep instead") friend std::ostream
& operator <<(std::ostream
& out
, DepIterator D
);
348 inline DepIterator(pkgCache
&Owner
, Dependency
*Trg
, Version
* = 0) :
349 Iterator
<Dependency
, DepIterator
>(Owner
, Trg
), Type(DepVer
), S2(Trg
== 0 ? Owner
.DepDataP
: (Owner
.DepDataP
+ Trg
->DependencyData
)) {
353 inline DepIterator(pkgCache
&Owner
, Dependency
*Trg
, Package
*) :
354 Iterator
<Dependency
, DepIterator
>(Owner
, Trg
), Type(DepRev
), S2(Trg
== 0 ? Owner
.DepDataP
: (Owner
.DepDataP
+ Trg
->DependencyData
)) {
358 inline DepIterator() : Iterator
<Dependency
, DepIterator
>(), Type(DepVer
), S2(0) {}
361 // Provides iterator /*{{{*/
362 class pkgCache::PrvIterator
: public Iterator
<Provides
, PrvIterator
> {
363 enum {PrvVer
, PrvPkg
} Type
;
366 inline Provides
* OwnerPointer() const {
367 return (Owner
!= 0) ? Owner
->ProvideP
: 0;
371 inline PrvIterator
& operator ++() {if (S
!= Owner
->ProvideP
) S
= Owner
->ProvideP
+
372 (Type
== PrvVer
?S
->NextPkgProv
:S
->NextProvides
); return *this;}
373 inline PrvIterator
operator++(int) { PrvIterator
const tmp(*this); operator++(); return tmp
; }
376 inline const char *Name() const {return ParentPkg().Name();}
377 inline const char *ProvideVersion() const {return S
->ProvideVersion
== 0?0:Owner
->StrP
+ S
->ProvideVersion
;}
378 inline PkgIterator
ParentPkg() const {return PkgIterator(*Owner
,Owner
->PkgP
+ S
->ParentPkg
);}
379 inline VerIterator
OwnerVer() const {return VerIterator(*Owner
,Owner
->VerP
+ S
->Version
);}
380 inline PkgIterator
OwnerPkg() const {return PkgIterator(*Owner
,Owner
->PkgP
+ Owner
->VerP
[S
->Version
].ParentPkg
);}
382 /* MultiArch can be translated to SingleArch for an resolver and we did so,
383 by adding provides to help the resolver understand the problem, but
384 sometimes it is needed to identify these to ignore them… */
385 bool IsMultiArchImplicit() const APT_PURE
386 { return (S
->Flags
& pkgCache::Flag::MultiArchImplicit
) == pkgCache::Flag::MultiArchImplicit
; }
389 inline PrvIterator() : Iterator
<Provides
, PrvIterator
>(), Type(PrvVer
) {}
390 inline PrvIterator(pkgCache
&Owner
, Provides
*Trg
, Version
*) :
391 Iterator
<Provides
, PrvIterator
>(Owner
, Trg
), Type(PrvVer
) {
395 inline PrvIterator(pkgCache
&Owner
, Provides
*Trg
, Package
*) :
396 Iterator
<Provides
, PrvIterator
>(Owner
, Trg
), Type(PrvPkg
) {
402 // Release file /*{{{*/
403 class pkgCache::RlsFileIterator
: public Iterator
<ReleaseFile
, RlsFileIterator
> {
405 inline ReleaseFile
* OwnerPointer() const {
406 return (Owner
!= 0) ? Owner
->RlsFileP
: 0;
410 inline RlsFileIterator
& operator++() {if (S
!= Owner
->RlsFileP
) S
= Owner
->RlsFileP
+ S
->NextFile
;return *this;}
411 inline RlsFileIterator
operator++(int) { RlsFileIterator
const tmp(*this); operator++(); return tmp
; }
414 inline const char *FileName() const {return S
->FileName
== 0?0:Owner
->StrP
+ S
->FileName
;}
415 inline const char *Archive() const {return S
->Archive
== 0?0:Owner
->StrP
+ S
->Archive
;}
416 inline const char *Version() const {return S
->Version
== 0?0:Owner
->StrP
+ S
->Version
;}
417 inline const char *Origin() const {return S
->Origin
== 0?0:Owner
->StrP
+ S
->Origin
;}
418 inline const char *Codename() const {return S
->Codename
==0?0:Owner
->StrP
+ S
->Codename
;}
419 inline const char *Label() const {return S
->Label
== 0?0:Owner
->StrP
+ S
->Label
;}
420 inline const char *Site() const {return S
->Site
== 0?0:Owner
->StrP
+ S
->Site
;}
421 inline bool Flagged(pkgCache::Flag::ReleaseFileFlags
const flag
) const {return (S
->Flags
& flag
) == flag
; }
424 std::string
RelStr();
427 inline RlsFileIterator() : Iterator
<ReleaseFile
, RlsFileIterator
>() {}
428 explicit inline RlsFileIterator(pkgCache
&Owner
) : Iterator
<ReleaseFile
, RlsFileIterator
>(Owner
, Owner
.RlsFileP
) {}
429 inline RlsFileIterator(pkgCache
&Owner
,ReleaseFile
*Trg
) : Iterator
<ReleaseFile
, RlsFileIterator
>(Owner
, Trg
) {}
432 // Package file /*{{{*/
433 class pkgCache::PkgFileIterator
: public Iterator
<PackageFile
, PkgFileIterator
> {
435 inline PackageFile
* OwnerPointer() const {
436 return (Owner
!= 0) ? Owner
->PkgFileP
: 0;
440 inline PkgFileIterator
& operator++() {if (S
!= Owner
->PkgFileP
) S
= Owner
->PkgFileP
+ S
->NextFile
; return *this;}
441 inline PkgFileIterator
operator++(int) { PkgFileIterator
const tmp(*this); operator++(); return tmp
; }
444 inline const char *FileName() const {return S
->FileName
== 0?0:Owner
->StrP
+ S
->FileName
;}
445 inline pkgCache::RlsFileIterator
ReleaseFile() const {return RlsFileIterator(*Owner
, Owner
->RlsFileP
+ S
->Release
);}
446 inline const char *Archive() const {return S
->Release
== 0 ? Component() : ReleaseFile().Archive();}
447 inline const char *Version() const {return S
->Release
== 0 ? NULL
: ReleaseFile().Version();}
448 inline const char *Origin() const {return S
->Release
== 0 ? NULL
: ReleaseFile().Origin();}
449 inline const char *Codename() const {return S
->Release
== 0 ? NULL
: ReleaseFile().Codename();}
450 inline const char *Label() const {return S
->Release
== 0 ? NULL
: ReleaseFile().Label();}
451 inline const char *Site() const {return S
->Release
== 0 ? NULL
: ReleaseFile().Site();}
452 inline bool Flagged(pkgCache::Flag::ReleaseFileFlags
const flag
) const {return S
->Release
== 0 ? false : ReleaseFile().Flagged(flag
);}
453 inline bool Flagged(pkgCache::Flag::PkgFFlags
const flag
) const {return (S
->Flags
& flag
) == flag
;}
454 inline const char *Component() const {return S
->Component
== 0?0:Owner
->StrP
+ S
->Component
;}
455 inline const char *Architecture() const {return S
->Architecture
== 0?0:Owner
->StrP
+ S
->Architecture
;}
456 inline const char *IndexType() const {return S
->IndexType
== 0?0:Owner
->StrP
+ S
->IndexType
;}
459 std::string
RelStr();
462 inline PkgFileIterator() : Iterator
<PackageFile
, PkgFileIterator
>() {}
463 explicit inline PkgFileIterator(pkgCache
&Owner
) : Iterator
<PackageFile
, PkgFileIterator
>(Owner
, Owner
.PkgFileP
) {}
464 inline PkgFileIterator(pkgCache
&Owner
,PackageFile
*Trg
) : Iterator
<PackageFile
, PkgFileIterator
>(Owner
, Trg
) {}
467 // Version File /*{{{*/
468 class pkgCache::VerFileIterator
: public pkgCache::Iterator
<VerFile
, VerFileIterator
> {
470 inline VerFile
* OwnerPointer() const {
471 return (Owner
!= 0) ? Owner
->VerFileP
: 0;
475 inline VerFileIterator
& operator++() {if (S
!= Owner
->VerFileP
) S
= Owner
->VerFileP
+ S
->NextFile
; return *this;}
476 inline VerFileIterator
operator++(int) { VerFileIterator
const tmp(*this); operator++(); return tmp
; }
479 inline PkgFileIterator
File() const {return PkgFileIterator(*Owner
,S
->File
+ Owner
->PkgFileP
);}
481 inline VerFileIterator() : Iterator
<VerFile
, VerFileIterator
>() {}
482 inline VerFileIterator(pkgCache
&Owner
,VerFile
*Trg
) : Iterator
<VerFile
, VerFileIterator
>(Owner
, Trg
) {}
485 // Description File /*{{{*/
486 class pkgCache::DescFileIterator
: public Iterator
<DescFile
, DescFileIterator
> {
488 inline DescFile
* OwnerPointer() const {
489 return (Owner
!= 0) ? Owner
->DescFileP
: 0;
493 inline DescFileIterator
& operator++() {if (S
!= Owner
->DescFileP
) S
= Owner
->DescFileP
+ S
->NextFile
; return *this;}
494 inline DescFileIterator
operator++(int) { DescFileIterator
const tmp(*this); operator++(); return tmp
; }
497 inline PkgFileIterator
File() const {return PkgFileIterator(*Owner
,S
->File
+ Owner
->PkgFileP
);}
499 inline DescFileIterator() : Iterator
<DescFile
, DescFileIterator
>() {}
500 inline DescFileIterator(pkgCache
&Owner
,DescFile
*Trg
) : Iterator
<DescFile
, DescFileIterator
>(Owner
, Trg
) {}
503 // Inlined Begin functions can't be in the class because of order problems /*{{{*/
504 inline pkgCache::PkgIterator
pkgCache::GrpIterator::PackageList() const
505 {return PkgIterator(*Owner
,Owner
->PkgP
+ S
->FirstPackage
);}
506 inline pkgCache::VerIterator
pkgCache::PkgIterator::VersionList() const
507 {return VerIterator(*Owner
,Owner
->VerP
+ S
->VersionList
);}
508 inline pkgCache::VerIterator
pkgCache::PkgIterator::CurrentVer() const
509 {return VerIterator(*Owner
,Owner
->VerP
+ S
->CurrentVer
);}
510 inline pkgCache::DepIterator
pkgCache::PkgIterator::RevDependsList() const
511 {return DepIterator(*Owner
,Owner
->DepP
+ S
->RevDepends
,S
);}
512 inline pkgCache::PrvIterator
pkgCache::PkgIterator::ProvidesList() const
513 {return PrvIterator(*Owner
,Owner
->ProvideP
+ S
->ProvidesList
,S
);}
514 inline pkgCache::DescIterator
pkgCache::VerIterator::DescriptionList() const
515 {return DescIterator(*Owner
,Owner
->DescP
+ S
->DescriptionList
);}
516 inline pkgCache::PrvIterator
pkgCache::VerIterator::ProvidesList() const
517 {return PrvIterator(*Owner
,Owner
->ProvideP
+ S
->ProvidesList
,S
);}
518 inline pkgCache::DepIterator
pkgCache::VerIterator::DependsList() const
519 {return DepIterator(*Owner
,Owner
->DepP
+ S
->DependsList
,S
);}
520 inline pkgCache::VerFileIterator
pkgCache::VerIterator::FileList() const
521 {return VerFileIterator(*Owner
,Owner
->VerFileP
+ S
->FileList
);}
522 inline pkgCache::DescFileIterator
pkgCache::DescIterator::FileList() const
523 {return DescFileIterator(*Owner
,Owner
->DescFileP
+ S
->FileList
);}
524 APT_DEPRECATED_MSG("Use the .Section method of VerIterator instead") inline const char * pkgCache::PkgIterator::Section() const
525 {return S
->VersionList
== 0 ? 0 : VersionList().Section();}