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            APT_IGNORE_DEPRECATED_PUSH
 162            return S->Section == 0?0:Owner->StrP + S->Section;
 163            APT_IGNORE_DEPRECATED_POP
 164         }
 165         inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
 166                 (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);}
 167         inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;}
 168         inline APT_PURE GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);}
 169
 170         inline VerIterator VersionList() const APT_PURE;
 171         inline VerIterator CurrentVer() const APT_PURE;
 172         inline DepIterator RevDependsList() const APT_PURE;
 173         inline PrvIterator ProvidesList() const APT_PURE;
 174         OkState State() const APT_PURE;
 175         const char *CandVersion() const APT_PURE;
 176         const char *CurVersion() const APT_PURE;
 177
 178         //Nice printable representation
 179         friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
 180         std::string FullName(bool const &Pretty = false) const;
 181
 182         // Constructors
 183         inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
 184                 if (S == 0)
 185                         S = OwnerPointer();
 186         }
 187         inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {}
 188 };
 189                                                                         /*}}}*/
 190 // Version Iterator                                                     /*{{{*/
 191 class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
 192         public:
 193         inline Version* OwnerPointer() const {
 194                 return (Owner != 0) ? Owner->VerP : 0;
 195         }
 196
 197         // Iteration
 198         inline VerIterator& operator++() {if (S != Owner->VerP) S = Owner->VerP + S->NextVer; return *this;}
 199         inline VerIterator operator++(int) { VerIterator const tmp(*this); operator++(); return tmp; }
 200
 201         // Comparison
 202         int CompareVer(const VerIterator &B) const;
 203         /** \brief compares two version and returns if they are similar
 204
 205             This method should be used to identify if two pseudo versions are
 206             referring to the same "real" version */
 207         inline bool SimilarVer(const VerIterator &B) const {
 208                 return (B.end() == false && S->Hash == B->Hash && strcmp(VerStr(), B.VerStr()) == 0);
 209         }
 210
 211         // Accessors
 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;}
 214         /** \brief source package name this version comes from
 215            Always contains the name, even if it is the same as the binary name */
 216         inline const char *SourcePkgName() const {return Owner->StrP + S->SourcePkgName;}
 217         /** \brief source version this version comes from
 218            Always contains the version string, even if it is the same as the binary version */
 219         inline const char *SourceVerStr() const {return Owner->StrP + S->SourceVerStr;}
 220         inline const char *Arch() const {
 221                 if ((S->MultiArch & pkgCache::Version::All) == pkgCache::Version::All)
 222                         return "all";
 223                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 224         }
 225         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 226
 227         inline DescIterator DescriptionList() const;
 228         DescIterator TranslatedDescription() const;
 229         inline DepIterator DependsList() const;
 230         inline PrvIterator ProvidesList() const;
 231         inline VerFileIterator FileList() const;
 232         bool Downloadable() const;
 233         inline const char *PriorityType() const {return Owner->Priority(S->Priority);}
 234         const char *MultiArchType() const APT_PURE;
 235         std::string RelStr() const;
 236
 237         bool Automatic() const;
 238         VerFileIterator NewestFile() const;
 239
 240         inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
 241                 if (S == 0)
 242                         S = OwnerPointer();
 243         }
 244         inline VerIterator() : Iterator<Version, VerIterator>() {}
 245 };
 246                                                                         /*}}}*/
 247 // Description Iterator                                                 /*{{{*/
 248 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 249         public:
 250         inline Description* OwnerPointer() const {
 251                 return (Owner != 0) ? Owner->DescP : 0;
 252         }
 253
 254         // Iteration
 255         inline DescIterator& operator++() {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc; return *this;}
 256         inline DescIterator operator++(int) { DescIterator const tmp(*this); operator++(); return tmp; }
 257
 258         // Comparison
 259         int CompareDesc(const DescIterator &B) const;
 260
 261         // Accessors
 262         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;}
 263         inline const char *md5() const {return Owner->StrP + S->md5sum;}
 264         inline DescFileIterator FileList() const;
 265
 266         inline DescIterator() : Iterator<Description, DescIterator>() {}
 267         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 268                 if (S == 0)
 269                         S = Owner.DescP;
 270         }
 271 };
 272                                                                         /*}}}*/
 273 // Dependency iterator                                                  /*{{{*/
 274 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 275         enum {DepVer, DepRev} Type;
 276         DependencyData * S2;
 277
 278         public:
 279         inline Dependency* OwnerPointer() const {
 280                 return (Owner != 0) ? Owner->DepP : 0;
 281         }
 282
 283         // Iteration
 284         DepIterator& operator++();
 285         inline DepIterator operator++(int) { DepIterator const tmp(*this); operator++(); return tmp; }
 286
 287         // Accessors
 288         inline const char *TargetVer() const {return S2->Version == 0?0:Owner->StrP + S2->Version;}
 289         inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S2->Package);}
 290         inline PkgIterator SmartTargetPkg() const {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;}
 291         inline VerIterator ParentVer() const {return VerIterator(*Owner,Owner->VerP + S->ParentVer);}
 292         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);}
 293         inline bool Reverse() const {return Type == DepRev;}
 294         bool IsCritical() const APT_PURE;
 295         bool IsNegative() const APT_PURE;
 296         bool IsIgnorable(PrvIterator const &Prv) const APT_PURE;
 297         bool IsIgnorable(PkgIterator const &Pkg) const APT_PURE;
 298         /* MultiArch can be translated to SingleArch for an resolver and we did so,
 299            by adding dependencies to help the resolver understand the problem, but
 300            sometimes it is needed to identify these to ignore them… */
 301         inline bool IsMultiArchImplicit() const APT_PURE {
 302                 return (S2->CompareOp & pkgCache::Dep::MultiArchImplicit) == pkgCache::Dep::MultiArchImplicit;
 303         }
 304         /* This covers additionally negative dependencies, which aren't arch-specific,
 305            but change architecture nontheless as a Conflicts: foo does applies for all archs */
 306         bool IsImplicit() const APT_PURE;
 307
 308         bool IsSatisfied(VerIterator const &Ver) const APT_PURE;
 309         bool IsSatisfied(PrvIterator const &Prv) const APT_PURE;
 310         void GlobOr(DepIterator &Start,DepIterator &End);
 311         Version **AllTargets() const;
 312         bool SmartTargetPkg(PkgIterator &Result) const;
 313         inline const char *CompType() const {return Owner->CompType(S2->CompareOp);}
 314         inline const char *DepType() const {return Owner->DepType(S2->Type);}
 315
 316         // overrides because we are special
 317         struct DependencyProxy
 318         {
 319            map_stringitem_t &Version;
 320            map_pointer_t &Package;
 321            map_id_t &ID;
 322            unsigned char &Type;
 323            unsigned char &CompareOp;
 324            map_pointer_t &ParentVer;
 325            map_pointer_t &DependencyData;
 326            map_pointer_t &NextRevDepends;
 327            map_pointer_t &NextDepends;
 328            map_pointer_t &NextData;
 329            DependencyProxy const * operator->() const { return this; }
 330            DependencyProxy * operator->() { return this; }
 331         };
 332         inline DependencyProxy operator->() const {return { S2->Version, S2->Package, S->ID, S2->Type, S2->CompareOp, S->ParentVer, S->DependencyData, S->NextRevDepends, S->NextDepends, S2->NextData };}
 333         inline DependencyProxy operator->() {return { S2->Version, S2->Package, S->ID, S2->Type, S2->CompareOp, S->ParentVer, S->DependencyData, S->NextRevDepends, S->NextDepends, S2->NextData };}
 334         void ReMap(void const * const oldMap, void const * const newMap)
 335         {
 336                 Iterator<Dependency, DepIterator>::ReMap(oldMap, newMap);
 337                 if (Owner == 0 || S == 0 || S2 == 0)
 338                         return;
 339                 S2 += (DependencyData const * const)(newMap) - (DependencyData const * const)(oldMap);
 340         }
 341
 342         //Nice printable representation
 343         friend std::ostream& operator <<(std::ostream& out, DepIterator D);
 344
 345         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 346                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 347                 if (S == 0)
 348                         S = Owner.DepP;
 349         }
 350         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 351                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 352                 if (S == 0)
 353                         S = Owner.DepP;
 354         }
 355         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer), S2(0) {}
 356 };
 357                                                                         /*}}}*/
 358 // Provides iterator                                                    /*{{{*/
 359 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 360         enum {PrvVer, PrvPkg} Type;
 361
 362         public:
 363         inline Provides* OwnerPointer() const {
 364                 return (Owner != 0) ? Owner->ProvideP : 0;
 365         }
 366
 367         // Iteration
 368         inline PrvIterator& operator ++() {if (S != Owner->ProvideP) S = Owner->ProvideP +
 369            (Type == PrvVer?S->NextPkgProv:S->NextProvides); return *this;}
 370         inline PrvIterator operator++(int) { PrvIterator const tmp(*this); operator++(); return tmp; }
 371
 372         // Accessors
 373         inline const char *Name() const {return ParentPkg().Name();}
 374         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;}
 375         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 376         inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);}
 377         inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);}
 378
 379         /* MultiArch can be translated to SingleArch for an resolver and we did so,
 380            by adding provides to help the resolver understand the problem, but
 381            sometimes it is needed to identify these to ignore them… */
 382         bool IsMultiArchImplicit() const APT_PURE
 383         { return (S->Flags & pkgCache::Flag::MultiArchImplicit) == pkgCache::Flag::MultiArchImplicit; }
 384
 385
 386         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {}
 387         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 388                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 389                 if (S == 0)
 390                         S = Owner.ProvideP;
 391         }
 392         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 393                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 394                 if (S == 0)
 395                         S = Owner.ProvideP;
 396         }
 397 };
 398                                                                         /*}}}*/
 399 // Release file                                                         /*{{{*/
 400 class pkgCache::RlsFileIterator : public Iterator<ReleaseFile, RlsFileIterator> {
 401         public:
 402         inline ReleaseFile* OwnerPointer() const {
 403                 return (Owner != 0) ? Owner->RlsFileP : 0;
 404         }
 405
 406         // Iteration
 407         inline RlsFileIterator& operator++() {if (S != Owner->RlsFileP) S = Owner->RlsFileP + S->NextFile;return *this;}
 408         inline RlsFileIterator operator++(int) { RlsFileIterator const tmp(*this); operator++(); return tmp; }
 409
 410         // Accessors
 411         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 412         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;}
 413         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;}
 414         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;}
 415         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;}
 416         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;}
 417         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;}
 418         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return (S->Flags & flag) == flag; }
 419
 420         bool IsOk();
 421         std::string RelStr();
 422
 423         // Constructors
 424         inline RlsFileIterator() : Iterator<ReleaseFile, RlsFileIterator>() {}
 425         explicit inline RlsFileIterator(pkgCache &Owner) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Owner.RlsFileP) {}
 426         inline RlsFileIterator(pkgCache &Owner,ReleaseFile *Trg) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Trg) {}
 427 };
 428                                                                         /*}}}*/
 429 // Package file                                                         /*{{{*/
 430 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 431         public:
 432         inline PackageFile* OwnerPointer() const {
 433                 return (Owner != 0) ? Owner->PkgFileP : 0;
 434         }
 435
 436         // Iteration
 437         inline PkgFileIterator& operator++() {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile; return *this;}
 438         inline PkgFileIterator operator++(int) { PkgFileIterator const tmp(*this); operator++(); return tmp; }
 439
 440         // Accessors
 441         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 442         inline pkgCache::RlsFileIterator ReleaseFile() const {return RlsFileIterator(*Owner, Owner->RlsFileP + S->Release);}
 443         inline const char *Archive() const {return S->Release == 0 ? Component() : ReleaseFile().Archive();}
 444         inline const char *Version() const {return S->Release == 0 ? NULL : ReleaseFile().Version();}
 445         inline const char *Origin() const {return S->Release == 0 ? NULL : ReleaseFile().Origin();}
 446         inline const char *Codename() const {return S->Release == 0 ? NULL : ReleaseFile().Codename();}
 447         inline const char *Label() const {return S->Release == 0 ? NULL : ReleaseFile().Label();}
 448         inline const char *Site() const {return S->Release == 0 ? NULL : ReleaseFile().Site();}
 449         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return S->Release== 0 ? false : ReleaseFile().Flagged(flag);}
 450         inline bool Flagged(pkgCache::Flag::PkgFFlags const flag) const {return (S->Flags & flag) == flag;}
 451         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;}
 452         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;}
 453         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;}
 454
 455         bool IsOk();
 456         std::string RelStr();
 457
 458         // Constructors
 459         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {}
 460         explicit inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {}
 461         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {}
 462 };
 463                                                                         /*}}}*/
 464 // Version File                                                         /*{{{*/
 465 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 466         public:
 467         inline VerFile* OwnerPointer() const {
 468                 return (Owner != 0) ? Owner->VerFileP : 0;
 469         }
 470
 471         // Iteration
 472         inline VerFileIterator& operator++() {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile; return *this;}
 473         inline VerFileIterator operator++(int) { VerFileIterator const tmp(*this); operator++(); return tmp; }
 474
 475         // Accessors
 476         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 477
 478         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {}
 479         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {}
 480 };
 481                                                                         /*}}}*/
 482 // Description File                                                     /*{{{*/
 483 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 484         public:
 485         inline DescFile* OwnerPointer() const {
 486                 return (Owner != 0) ? Owner->DescFileP : 0;
 487         }
 488
 489         // Iteration
 490         inline DescFileIterator& operator++() {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile; return *this;}
 491         inline DescFileIterator operator++(int) { DescFileIterator const tmp(*this); operator++(); return tmp; }
 492
 493         // Accessors
 494         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 495
 496         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {}
 497         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {}
 498 };
 499                                                                         /*}}}*/
 500 // Inlined Begin functions can't be in the class because of order problems /*{{{*/
 501 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 502        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);}
 503 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 504        {return VerIterator(*Owner,Owner->VerP + S->VersionList);}
 505 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 506        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);}
 507 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 508        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);}
 509 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 510        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 511 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 512        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);}
 513 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 514        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 515 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 516        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);}
 517 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 518        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);}
 519 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 520        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);}
 521                                                                         /*}}}*/
 522 #endif