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