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<apt-pkg/pkgcache.h>
  33 #include<apt-pkg/macros.h>
  34
  35 #include<iterator>
  36 #include <iosfwd>
  37 #include <string>
  38
  39 #include<string.h>
  40
  41 // abstract Iterator template                                           /*{{{*/
  42 /* This template provides the very basic iterator methods we
  43    need to have for doing some walk-over-the-cache magic */
  44 template<typename Str, typename Itr> class pkgCache::Iterator :
  45                         public std::iterator<std::forward_iterator_tag, Str> {
  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
  50          *  each structure and we want to abstract here at least for the
  51          *  basic methods from the actual structure.
  52          *  \return Pointer to the first structure of this type
  53          */
  54         Str* OwnerPointer() const { return static_cast<Itr const*>(this)->OwnerPointer(); }
  55
  56         protected:
  57         Str *S;
  58         pkgCache *Owner;
  59
  60         public:
  61         // Iteration
  62         inline bool end() const {return Owner == 0 || S == OwnerPointer();}
  63
  64         // Comparison
  65         inline bool operator ==(const Itr &B) const {return S == B.S;}
  66         inline bool operator !=(const Itr &B) const {return S != B.S;}
  67
  68         // Accessors
  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;}
  76
  77         // Mixed stuff
  78         inline bool IsGood() const { return S && Owner && ! end();}
  79         inline unsigned long Index() const {return S - OwnerPointer();}
  80
  81         void ReMap(void const * const oldMap, void const * const newMap) {
  82                 if (Owner == 0 || S == 0)
  83                         return;
  84                 S += (Str const * const)(newMap) - (Str const * const)(oldMap);
  85         }
  86
  87         // Constructors - look out for the variable assigning
  88         inline Iterator() : S(0), Owner(0) {}
  89         inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {}
  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) */
  97 class pkgCache::GrpIterator: public Iterator<Group, GrpIterator> {
  98         long HashIndex;
  99
 100         public:
 101         inline Group* OwnerPointer() const {
 102                 return (Owner != 0) ? Owner->GrpP : 0;
 103         }
 104
 105         // This constructor is the 'begin' constructor, never use it.
 106         explicit inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
 107                 S = OwnerPointer();
 108                 operator++();
 109         }
 110
 111         GrpIterator& operator++();
 112         inline GrpIterator operator++(int) { GrpIterator const tmp(*this); operator++(); return tmp; }
 113
 114         inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;}
 115         inline PkgIterator PackageList() const;
 116         PkgIterator FindPkg(std::string Arch = "any") const;
 117         /** \brief find the package with the "best" architecture
 118
 119             The best architecture is either the "native" or the first
 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;
 125         PkgIterator NextPkg(PkgIterator const &Pkg) const;
 126
 127         // Constructors
 128         inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
 129                 if (S == 0)
 130                         S = OwnerPointer();
 131         }
 132         inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {}
 133
 134 };
 135                                                                         /*}}}*/
 136 // Package Iterator                                                     /*{{{*/
 137 class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
 138         long HashIndex;
 139
 140         public:
 141         inline Package* OwnerPointer() const {
 142                 return (Owner != 0) ? Owner->PkgP : 0;
 143         }
 144
 145         // This constructor is the 'begin' constructor, never use it.
 146         explicit inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
 147                 S = OwnerPointer();
 148                 operator++();
 149         }
 150
 151         PkgIterator& operator++();
 152         inline PkgIterator operator++(int) { PkgIterator const tmp(*this); operator++(); return tmp; }
 153
 154         enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
 155
 156         // Accessors
 157         inline const char *Name() const { return Group().Name(); }
 158         // Versions have sections - and packages can have different versions with different sections
 159         // so this interface is broken by design. Run as fast as you can to Version.Section().
 160         APT_DEPRECATED inline const char *Section() const;
 161         inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
 162                 (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);}
 163         inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;}
 164         inline APT_PURE GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);}
 165
 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;
 173
 174         //Nice printable representation
 175         friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
 176         std::string FullName(bool const &Pretty = false) const;
 177
 178         // Constructors
 179         inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
 180                 if (S == 0)
 181                         S = OwnerPointer();
 182         }
 183         inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {}
 184 };
 185                                                                         /*}}}*/
 186 // Version Iterator                                                     /*{{{*/
 187 class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
 188         public:
 189         inline Version* OwnerPointer() const {
 190                 return (Owner != 0) ? Owner->VerP : 0;
 191         }
 192
 193         // Iteration
 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; }
 196
 197         // Comparison
 198         int CompareVer(const VerIterator &B) const;
 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
 202             referring to the same "real" version */
 203         inline bool SimilarVer(const VerIterator &B) const {
 204                 return (B.end() == false && S->Hash == B->Hash && strcmp(VerStr(), B.VerStr()) == 0);
 205         }
 206
 207         // Accessors
 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;}
 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;}
 216         inline const char *Arch() const {
 217                 if ((S->MultiArch & pkgCache::Version::All) == pkgCache::Version::All)
 218                         return "all";
 219                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 220         }
 221         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 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;
 229         inline const char *PriorityType() const {return Owner->Priority(S->Priority);}
 230         const char *MultiArchType() const APT_PURE;
 231         std::string RelStr() const;
 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();
 239         }
 240         inline VerIterator() : Iterator<Version, VerIterator>() {}
 241 };
 242                                                                         /*}}}*/
 243 // Description Iterator                                                 /*{{{*/
 244 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 245         public:
 246         inline Description* OwnerPointer() const {
 247                 return (Owner != 0) ? Owner->DescP : 0;
 248         }
 249
 250         // Iteration
 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; }
 253
 254         // Comparison
 255         int CompareDesc(const DescIterator &B) const;
 256
 257         // Accessors
 258         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;}
 259         inline const char *md5() const {return Owner->StrP + S->md5sum;}
 260         inline DescFileIterator FileList() const;
 261
 262         inline DescIterator() : Iterator<Description, DescIterator>() {}
 263         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 264                 if (S == 0)
 265                         S = Owner.DescP;
 266         }
 267 };
 268                                                                         /*}}}*/
 269 // Dependency iterator                                                  /*{{{*/
 270 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 271         enum {DepVer, DepRev} Type;
 272         DependencyData * S2;
 273
 274         public:
 275         inline Dependency* OwnerPointer() const {
 276                 return (Owner != 0) ? Owner->DepP : 0;
 277         }
 278
 279         // Iteration
 280         DepIterator& operator++();
 281         inline DepIterator operator++(int) { DepIterator const tmp(*this); operator++(); return tmp; }
 282
 283         // Accessors
 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);}
 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         /* 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,
 301            but change architecture nonetheless as a Conflicts: foo does applies for all archs */
 302         bool IsImplicit() const APT_PURE;
 303
 304         bool IsSatisfied(VerIterator const &Ver) const APT_PURE;
 305         bool IsSatisfied(PrvIterator const &Prv) const APT_PURE;
 306         void GlobOr(DepIterator &Start,DepIterator &End);
 307         Version **AllTargets() const;
 308         bool SmartTargetPkg(PkgIterator &Result) const;
 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;
 317            map_id_t &ID;
 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;
 324            map_pointer_t &NextData;
 325            DependencyProxy const * operator->() const { return this; }
 326            DependencyProxy * operator->() { return this; }
 327         };
 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 };}
 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         }
 337
 338         //Nice printable representation
 339         friend std::ostream& operator <<(std::ostream& out, DepIterator D);
 340
 341         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 342                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 343                 if (S == 0)
 344                         S = Owner.DepP;
 345         }
 346         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 347                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 348                 if (S == 0)
 349                         S = Owner.DepP;
 350         }
 351         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer), S2(0) {}
 352 };
 353                                                                         /*}}}*/
 354 // Provides iterator                                                    /*{{{*/
 355 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 356         enum {PrvVer, PrvPkg} Type;
 357
 358         public:
 359         inline Provides* OwnerPointer() const {
 360                 return (Owner != 0) ? Owner->ProvideP : 0;
 361         }
 362
 363         // Iteration
 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; }
 367
 368         // Accessors
 369         inline const char *Name() const {return ParentPkg().Name();}
 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);}
 374
 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
 381
 382         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {}
 383         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 384                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 385                 if (S == 0)
 386                         S = Owner.ProvideP;
 387         }
 388         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 389                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 390                 if (S == 0)
 391                         S = Owner.ProvideP;
 392         }
 393 };
 394                                                                         /*}}}*/
 395 // Release file                                                         /*{{{*/
 396 class pkgCache::RlsFileIterator : public Iterator<ReleaseFile, RlsFileIterator> {
 397         public:
 398         inline ReleaseFile* OwnerPointer() const {
 399                 return (Owner != 0) ? Owner->RlsFileP : 0;
 400         }
 401
 402         // Iteration
 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; }
 405
 406         // Accessors
 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;}
 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;}
 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>() {}
 421         explicit inline RlsFileIterator(pkgCache &Owner) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Owner.RlsFileP) {}
 422         inline RlsFileIterator(pkgCache &Owner,ReleaseFile *Trg) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Trg) {}
 423 };
 424                                                                         /*}}}*/
 425 // Package file                                                         /*{{{*/
 426 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 427         public:
 428         inline PackageFile* OwnerPointer() const {
 429                 return (Owner != 0) ? Owner->PkgFileP : 0;
 430         }
 431
 432         // Iteration
 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; }
 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;}
 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;}
 450
 451         bool IsOk();
 452         std::string RelStr();
 453
 454         // Constructors
 455         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {}
 456         explicit inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {}
 457         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {}
 458 };
 459                                                                         /*}}}*/
 460 // Version File                                                         /*{{{*/
 461 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 462         public:
 463         inline VerFile* OwnerPointer() const {
 464                 return (Owner != 0) ? Owner->VerFileP : 0;
 465         }
 466
 467         // Iteration
 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; }
 470
 471         // Accessors
 472         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 473
 474         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {}
 475         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {}
 476 };
 477                                                                         /*}}}*/
 478 // Description File                                                     /*{{{*/
 479 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 480         public:
 481         inline DescFile* OwnerPointer() const {
 482                 return (Owner != 0) ? Owner->DescFileP : 0;
 483         }
 484
 485         // Iteration
 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; }
 488
 489         // Accessors
 490         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 491
 492         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {}
 493         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {}
 494 };
 495                                                                         /*}}}*/
 496 // Inlined Begin functions can't be in the class because of order problems /*{{{*/
 497 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 498        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);}
 499 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 500        {return VerIterator(*Owner,Owner->VerP + S->VersionList);}
 501 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 502        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);}
 503 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 504        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);}
 505 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 506        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 507 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 508        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);}
 509 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 510        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 511 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 512        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);}
 513 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 514        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);}
 515 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 516        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);}
 517 APT_DEPRECATED inline const char * pkgCache::PkgIterator::Section() const
 518        {return S->VersionList == 0 ? 0 : VersionList().Section();}
 519                                                                         /*}}}*/
 520 #endif