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