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