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