← Back to branch summary

~ubuntu-branches/ubuntu/trusty/apt/trusty

« back to all changes in this revision

Viewing changes to apt-pkg/cacheiterators.h

  • Committer: Package Import Robot
  • Author(s): Michael Vogt
  • Date: 2014-04-01 17:48:58 UTC
  • mfrom: (1.4.87 sid)
  • Revision ID: package-import@ubuntu.com-20140401174858-4mv29mm29zu22fn1
Tags: 1.0.1ubuntu1
https://launchpad.net/bugs/1302033
merge with the debian/sid 1.0.1 version
(LP: #1302033)

Show diffs side-by-side

added added

removed removed

Lines of Context:
apt-pkg/cacheiterators.h
29
29
                                                                        /*}}}*/
30
30
#ifndef PKGLIB_CACHEITERATORS_H
31
31
#define PKGLIB_CACHEITERATORS_H
 
32
#include<apt-pkg/pkgcache.h>
 
33
#include<apt-pkg/macros.h>
 
34
 
32
35
#include<iterator>
 
36
#include <iosfwd>
 
37
#include <string>
33
38
 
34
39
#include<string.h>
35
40
 
55
60
        public:
56
61
        // Iteration
57
62
        virtual void operator ++(int) = 0;
58
 
        virtual void operator ++() = 0; // Should be {operator ++(0);};
59
 
        inline bool end() const {return Owner == 0 || S == OwnerPointer();};
 
63
        virtual void operator ++() = 0; // Should be {operator ++(0);}
 
64
        inline bool end() const {return Owner == 0 || S == OwnerPointer();}
60
65
 
61
66
        // 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;};
 
67
        inline bool operator ==(const Itr &B) const {return S == B.S;}
 
68
        inline bool operator !=(const Itr &B) const {return S != B.S;}
64
69
 
65
70
        // 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;};
70
 
        inline Str &operator *() {return *S;};
71
 
        inline Str const &operator *() const {return *S;};
72
 
        inline pkgCache *Cache() const {return Owner;};
 
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;}
73
78
 
74
79
        // 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();};
 
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();}
78
83
 
79
84
        void ReMap(void const * const oldMap, void const * const newMap) {
80
85
                if (Owner == 0 || S == 0)
81
86
                        return;
82
 
                S += (Str*)(newMap) - (Str*)(oldMap);
 
87
                S += (Str const * const)(newMap) - (Str const * const)(oldMap);
83
88
        }
84
89
 
85
90
        // 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) {};
 
91
        inline Iterator() : S(0), Owner(0) {}
 
92
        inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {}
88
93
};
89
94
                                                                        /*}}}*/
90
95
// Group Iterator                                                       /*{{{*/
98
103
        protected:
99
104
        inline Group* OwnerPointer() const {
100
105
                return (Owner != 0) ? Owner->GrpP : 0;
101
 
        };
 
106
        }
102
107
 
103
108
        public:
104
109
        // This constructor is the 'begin' constructor, never use it.
105
110
        inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
106
111
                S = OwnerPointer();
107
112
                operator ++(0);
108
 
        };
 
113
        }
109
114
 
110
115
        virtual void operator ++(int);
111
 
        virtual void operator ++() {operator ++(0);};
 
116
        virtual void operator ++() {operator ++(0);}
112
117
 
113
 
        inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
 
118
        inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;}
114
119
        inline PkgIterator PackageList() const;
115
120
        PkgIterator FindPkg(std::string Arch = "any") const;
116
121
        /** \brief find the package with the "best" architecture
127
132
        inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
128
133
                if (S == 0)
129
134
                        S = OwnerPointer();
130
 
        };
131
 
        inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {};
 
135
        }
 
136
        inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {}
132
137
 
133
138
};
134
139
                                                                        /*}}}*/
139
144
        protected:
140
145
        inline Package* OwnerPointer() const {
141
146
                return (Owner != 0) ? Owner->PkgP : 0;
142
 
        };
 
147
        }
143
148
 
144
149
        public:
145
150
        // This constructor is the 'begin' constructor, never use it.
146
151
        inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
147
152
                S = OwnerPointer();
148
153
                operator ++(0);
149
 
        };
 
154
        }
150
155
 
151
156
        virtual void operator ++(int);
152
 
        virtual void operator ++() {operator ++(0);};
 
157
        virtual void operator ++() {operator ++(0);}
153
158
 
154
159
        enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
155
160
 
156
161
        // 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;};
 
162
        inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;}
 
163
        inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;}
159
164
        inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
160
 
                (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);};
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);};
 
165
                (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);}
 
166
        inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;}
 
167
        inline APT_PURE GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);}
163
168
 
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;
 
169
        inline VerIterator VersionList() const APT_PURE;
 
170
        inline VerIterator CurrentVer() const APT_PURE;
 
171
        inline DepIterator RevDependsList() const APT_PURE;
 
172
        inline PrvIterator ProvidesList() const APT_PURE;
 
173
        OkState State() const APT_PURE;
 
174
        const char *CandVersion() const APT_PURE;
 
175
        const char *CurVersion() const APT_PURE;
171
176
 
172
177
        //Nice printable representation
173
178
        friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
177
182
        inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
178
183
                if (S == 0)
179
184
                        S = OwnerPointer();
180
 
        };
181
 
        inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
 
185
        }
 
186
        inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {}
182
187
};
183
188
                                                                        /*}}}*/
184
189
// Version Iterator                                                     /*{{{*/
186
191
        protected:
187
192
        inline Version* OwnerPointer() const {
188
193
                return (Owner != 0) ? Owner->VerP : 0;
189
 
        };
 
194
        }
190
195
 
191
196
        public:
192
197
        // Iteration
193
 
        void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
194
 
        inline void operator ++() {operator ++(0);};
 
198
        void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;}
 
199
        inline void operator ++() {operator ++(0);}
195
200
 
196
201
        // Comparison
197
202
        int CompareVer(const VerIterator &B) const;
201
206
            referring to the same "real" version */
202
207
        inline bool SimilarVer(const VerIterator &B) const {
203
208
                return (B.end() == false && S->Hash == B->Hash && strcmp(VerStr(), B.VerStr()) == 0);
204
 
        };
 
209
        }
205
210
 
206
211
        // 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;};
 
212
        inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;}
 
213
        inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;}
209
214
        inline const char *Arch() const {
210
215
                if ((S->MultiArch & pkgCache::Version::All) == pkgCache::Version::All)
211
216
                        return "all";
212
217
                return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
213
 
        };
214
 
        inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 
218
        }
 
219
        inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
215
220
 
216
221
        inline DescIterator DescriptionList() const;
217
222
        DescIterator TranslatedDescription() const;
219
224
        inline PrvIterator ProvidesList() const;
220
225
        inline VerFileIterator FileList() const;
221
226
        bool Downloadable() const;
222
 
        inline const char *PriorityType() const {return Owner->Priority(S->Priority);};
223
 
        const char *MultiArchType() const;
 
227
        inline const char *PriorityType() const {return Owner->Priority(S->Priority);}
 
228
        const char *MultiArchType() const APT_PURE;
224
229
        std::string RelStr() const;
225
230
 
226
231
        bool Automatic() const;
229
234
        inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
230
235
                if (S == 0)
231
236
                        S = OwnerPointer();
232
 
        };
233
 
        inline VerIterator() : Iterator<Version, VerIterator>() {};
 
237
        }
 
238
        inline VerIterator() : Iterator<Version, VerIterator>() {}
234
239
};
235
240
                                                                        /*}}}*/
236
241
// Description Iterator                                                 /*{{{*/
238
243
        protected:
239
244
        inline Description* OwnerPointer() const {
240
245
                return (Owner != 0) ? Owner->DescP : 0;
241
 
        };
 
246
        }
242
247
 
243
248
        public:
244
249
        // Iteration
245
 
        void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
246
 
        inline void operator ++() {operator ++(0);};
 
250
        void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;}
 
251
        inline void operator ++() {operator ++(0);}
247
252
 
248
253
        // Comparison
249
254
        int CompareDesc(const DescIterator &B) const;
250
255
 
251
256
        // Accessors
252
 
        inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
253
 
        inline const char *md5() const {return Owner->StrP + S->md5sum;};
 
257
        inline const char *LanguageCode() const {return Owner->StrP + S->language_code;}
 
258
        inline const char *md5() const {return Owner->StrP + S->md5sum;}
254
259
        inline DescFileIterator FileList() const;
255
260
 
256
 
        inline DescIterator() : Iterator<Description, DescIterator>() {};
 
261
        inline DescIterator() : Iterator<Description, DescIterator>() {}
257
262
        inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
258
263
                if (S == 0)
259
264
                        S = Owner.DescP;
260
 
        };
 
265
        }
261
266
};
262
267
                                                                        /*}}}*/
263
268
// Dependency iterator                                                  /*{{{*/
267
272
        protected:
268
273
        inline Dependency* OwnerPointer() const {
269
274
                return (Owner != 0) ? Owner->DepP : 0;
270
 
        };
 
275
        }
271
276
 
272
277
        public:
273
278
        // Iteration
274
279
        void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
275
 
                (Type == DepVer ? S->NextDepends : S->NextRevDepends);};
276
 
        inline void operator ++() {operator ++(0);};
 
280
                (Type == DepVer ? S->NextDepends : S->NextRevDepends);}
 
281
        inline void operator ++() {operator ++(0);}
277
282
 
278
283
        // Accessors
279
 
        inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
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;
286
 
        bool IsNegative() const;
287
 
        bool IsIgnorable(PrvIterator const &Prv) const;
288
 
        bool IsIgnorable(PkgIterator const &Pkg) const;
289
 
        bool IsMultiArchImplicit() const;
290
 
        bool IsSatisfied(VerIterator const &Ver) const;
291
 
        bool IsSatisfied(PrvIterator const &Prv) const;
 
284
        inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;}
 
285
        inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->Package);}
 
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;}
 
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;
 
294
        bool IsMultiArchImplicit() const APT_PURE;
 
295
        bool IsSatisfied(VerIterator const &Ver) const APT_PURE;
 
296
        bool IsSatisfied(PrvIterator const &Prv) const APT_PURE;
292
297
        void GlobOr(DepIterator &Start,DepIterator &End);
293
298
        Version **AllTargets() const;
294
299
        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);};
 
300
        inline const char *CompType() const {return Owner->CompType(S->CompareOp);}
 
301
        inline const char *DepType() const {return Owner->DepType(S->Type);}
297
302
 
298
303
        //Nice printable representation
299
304
        friend std::ostream& operator <<(std::ostream& out, DepIterator D);
302
307
                Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
303
308
                if (S == 0)
304
309
                        S = Owner.DepP;
305
 
        };
 
310
        }
306
311
        inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
307
312
                Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
308
313
                if (S == 0)
309
314
                        S = Owner.DepP;
310
 
        };
311
 
        inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
 
315
        }
 
316
        inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {}
312
317
};
313
318
                                                                        /*}}}*/
314
319
// Provides iterator                                                    /*{{{*/
318
323
        protected:
319
324
        inline Provides* OwnerPointer() const {
320
325
                return (Owner != 0) ? Owner->ProvideP : 0;
321
 
        };
 
326
        }
322
327
 
323
328
        public:
324
329
        // Iteration
325
330
        void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
326
 
                (Type == PrvVer?S->NextPkgProv:S->NextProvides);};
327
 
        inline void operator ++() {operator ++(0);};
 
331
                (Type == PrvVer?S->NextPkgProv:S->NextProvides);}
 
332
        inline void operator ++() {operator ++(0);}
328
333
 
329
334
        // 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;};
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);};
335
 
 
336
 
        bool IsMultiArchImplicit() const;
337
 
 
338
 
        inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
 
335
        inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;}
 
336
        inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;}
 
337
        inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 
338
        inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);}
 
339
        inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);}
 
340
 
 
341
        bool IsMultiArchImplicit() const APT_PURE;
 
342
 
 
343
        inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {}
339
344
        inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
340
345
                Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
341
346
                if (S == 0)
342
347
                        S = Owner.ProvideP;
343
 
        };
 
348
        }
344
349
        inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
345
350
                Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
346
351
                if (S == 0)
347
352
                        S = Owner.ProvideP;
348
 
        };
 
353
        }
349
354
};
350
355
                                                                        /*}}}*/
351
356
// Package file                                                         /*{{{*/
353
358
        protected:
354
359
        inline PackageFile* OwnerPointer() const {
355
360
                return (Owner != 0) ? Owner->PkgFileP : 0;
356
 
        };
 
361
        }
357
362
 
358
363
        public:
359
364
        // Iteration
360
 
        void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
361
 
        inline void operator ++() {operator ++(0);};
 
365
        void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;}
 
366
        inline void operator ++() {operator ++(0);}
362
367
 
363
368
        // 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;};
 
369
        inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 
370
        inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;}
 
371
        inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;}
 
372
        inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;}
 
373
        inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;}
 
374
        inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;}
 
375
        inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;}
 
376
        inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;}
 
377
        inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;}
 
378
        inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;}
374
379
 
375
380
        bool IsOk();
376
381
        std::string RelStr();
377
382
 
378
383
        // Constructors
379
 
        inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
380
 
        inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {};
381
 
        inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
 
384
        inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {}
 
385
        inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {}
 
386
        inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {}
382
387
};
383
388
                                                                        /*}}}*/
384
389
// Version File                                                         /*{{{*/
386
391
        protected:
387
392
        inline VerFile* OwnerPointer() const {
388
393
                return (Owner != 0) ? Owner->VerFileP : 0;
389
 
        };
 
394
        }
390
395
 
391
396
        public:
392
397
        // Iteration
393
 
        void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
394
 
        inline void operator ++() {operator ++(0);};
 
398
        void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;}
 
399
        inline void operator ++() {operator ++(0);}
395
400
 
396
401
        // Accessors
397
 
        inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 
402
        inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
398
403
 
399
 
        inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
400
 
        inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
 
404
        inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {}
 
405
        inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {}
401
406
};
402
407
                                                                        /*}}}*/
403
408
// Description File                                                     /*{{{*/
405
410
        protected:
406
411
        inline DescFile* OwnerPointer() const {
407
412
                return (Owner != 0) ? Owner->DescFileP : 0;
408
 
        };
 
413
        }
409
414
 
410
415
        public:
411
416
        // Iteration
412
 
        void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
413
 
        inline void operator ++() {operator ++(0);};
 
417
        void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;}
 
418
        inline void operator ++() {operator ++(0);}
414
419
 
415
420
        // Accessors
416
 
        inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 
421
        inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
417
422
 
418
 
        inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
419
 
        inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
 
423
        inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {}
 
424
        inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {}
420
425
};
421
426
                                                                        /*}}}*/
422
427
// Inlined Begin functions can't be in the class because of order problems /*{{{*/
423
428
inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
424
 
       {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);};
 
429
       {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);}
425
430
inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
426
 
       {return VerIterator(*Owner,Owner->VerP + S->VersionList);};
 
431
       {return VerIterator(*Owner,Owner->VerP + S->VersionList);}
427
432
inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
428
 
       {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
 
433
       {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);}
429
434
inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
430
 
       {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
 
435
       {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);}
431
436
inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
432
 
       {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 
437
       {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
433
438
inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
434
 
       {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
 
439
       {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);}
435
440
inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
436
 
       {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 
441
       {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
437
442
inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
438
 
       {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
 
443
       {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);}
439
444
inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
440
 
       {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
 
445
       {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);}
441
446
inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
442
 
       {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
 
447
       {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);}
443
448
                                                                        /*}}}*/
444
449
#endif