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         bool IsMultiArchImplicit() const APT_PURE;
 299         bool IsSatisfied(VerIterator const &Ver) const APT_PURE;
 300         bool IsSatisfied(PrvIterator const &Prv) const APT_PURE;
 301         void GlobOr(DepIterator &Start,DepIterator &End);
 302         Version **AllTargets() const;
 303         bool SmartTargetPkg(PkgIterator &Result) const;
 304         inline const char *CompType() const {return Owner->CompType(S2->CompareOp);}
 305         inline const char *DepType() const {return Owner->DepType(S2->Type);}
 306
 307         // overrides because we are special
 308         struct DependencyProxy
 309         {
 310            map_stringitem_t &Version;
 311            map_pointer_t &Package;
 312            map_id_t &ID;
 313            unsigned char &Type;
 314            unsigned char &CompareOp;
 315            map_pointer_t &ParentVer;
 316            map_pointer_t &DependencyData;
 317            map_pointer_t &NextRevDepends;
 318            map_pointer_t &NextDepends;
 319            map_pointer_t &NextData;
 320            DependencyProxy const * operator->() const { return this; }
 321            DependencyProxy * operator->() { return this; }
 322         };
 323         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 };}
 324         inline DependencyProxy operator->() {return { S2->Version, S2->Package, S->ID, S2->Type, S2->CompareOp, S->ParentVer, S->DependencyData, S->NextRevDepends, S->NextDepends, S2->NextData };}
 325         void ReMap(void const * const oldMap, void const * const newMap)
 326         {
 327                 Iterator<Dependency, DepIterator>::ReMap(oldMap, newMap);
 328                 if (Owner == 0 || S == 0 || S2 == 0)
 329                         return;
 330                 S2 += (DependencyData const * const)(newMap) - (DependencyData const * const)(oldMap);
 331         }
 332
 333         //Nice printable representation
 334         friend std::ostream& operator <<(std::ostream& out, DepIterator D);
 335
 336         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 337                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 338                 if (S == 0)
 339                         S = Owner.DepP;
 340         }
 341         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 342                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 343                 if (S == 0)
 344                         S = Owner.DepP;
 345         }
 346         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer), S2(0) {}
 347 };
 348                                                                         /*}}}*/
 349 // Provides iterator                                                    /*{{{*/
 350 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 351         enum {PrvVer, PrvPkg} Type;
 352
 353         public:
 354         inline Provides* OwnerPointer() const {
 355                 return (Owner != 0) ? Owner->ProvideP : 0;
 356         }
 357
 358         // Iteration
 359         inline PrvIterator& operator ++() {if (S != Owner->ProvideP) S = Owner->ProvideP +
 360            (Type == PrvVer?S->NextPkgProv:S->NextProvides); return *this;}
 361         inline PrvIterator operator++(int) { PrvIterator const tmp(*this); operator++(); return tmp; }
 362
 363         // Accessors
 364         inline const char *Name() const {return ParentPkg().Name();}
 365         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;}
 366         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 367         inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);}
 368         inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);}
 369
 370         bool IsMultiArchImplicit() const APT_PURE;
 371
 372         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {}
 373         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 374                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 375                 if (S == 0)
 376                         S = Owner.ProvideP;
 377         }
 378         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 379                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 380                 if (S == 0)
 381                         S = Owner.ProvideP;
 382         }
 383 };
 384                                                                         /*}}}*/
 385 // Release file                                                         /*{{{*/
 386 class pkgCache::RlsFileIterator : public Iterator<ReleaseFile, RlsFileIterator> {
 387         public:
 388         inline ReleaseFile* OwnerPointer() const {
 389                 return (Owner != 0) ? Owner->RlsFileP : 0;
 390         }
 391
 392         // Iteration
 393         inline RlsFileIterator& operator++() {if (S != Owner->RlsFileP) S = Owner->RlsFileP + S->NextFile;return *this;}
 394         inline RlsFileIterator operator++(int) { RlsFileIterator const tmp(*this); operator++(); return tmp; }
 395
 396         // Accessors
 397         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 398         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;}
 399         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;}
 400         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;}
 401         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;}
 402         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;}
 403         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;}
 404         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return (S->Flags & flag) == flag; }
 405
 406         bool IsOk();
 407         std::string RelStr();
 408
 409         // Constructors
 410         inline RlsFileIterator() : Iterator<ReleaseFile, RlsFileIterator>() {}
 411         explicit inline RlsFileIterator(pkgCache &Owner) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Owner.RlsFileP) {}
 412         inline RlsFileIterator(pkgCache &Owner,ReleaseFile *Trg) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Trg) {}
 413 };
 414                                                                         /*}}}*/
 415 // Package file                                                         /*{{{*/
 416 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 417         public:
 418         inline PackageFile* OwnerPointer() const {
 419                 return (Owner != 0) ? Owner->PkgFileP : 0;
 420         }
 421
 422         // Iteration
 423         inline PkgFileIterator& operator++() {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile; return *this;}
 424         inline PkgFileIterator operator++(int) { PkgFileIterator const tmp(*this); operator++(); return tmp; }
 425
 426         // Accessors
 427         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 428         inline pkgCache::RlsFileIterator ReleaseFile() const {return RlsFileIterator(*Owner, Owner->RlsFileP + S->Release);}
 429         inline const char *Archive() const {return S->Release == 0 ? Component() : ReleaseFile().Archive();}
 430         inline const char *Version() const {return S->Release == 0 ? NULL : ReleaseFile().Version();}
 431         inline const char *Origin() const {return S->Release == 0 ? NULL : ReleaseFile().Origin();}
 432         inline const char *Codename() const {return S->Release == 0 ? NULL : ReleaseFile().Codename();}
 433         inline const char *Label() const {return S->Release == 0 ? NULL : ReleaseFile().Label();}
 434         inline const char *Site() const {return S->Release == 0 ? NULL : ReleaseFile().Site();}
 435         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return S->Release== 0 ? false : ReleaseFile().Flagged(flag);}
 436         inline bool Flagged(pkgCache::Flag::PkgFFlags const flag) const {return (S->Flags & flag) == flag;}
 437         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;}
 438         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;}
 439         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;}
 440
 441         bool IsOk();
 442         std::string RelStr();
 443
 444         // Constructors
 445         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {}
 446         explicit inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {}
 447         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {}
 448 };
 449                                                                         /*}}}*/
 450 // Version File                                                         /*{{{*/
 451 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 452         public:
 453         inline VerFile* OwnerPointer() const {
 454                 return (Owner != 0) ? Owner->VerFileP : 0;
 455         }
 456
 457         // Iteration
 458         inline VerFileIterator& operator++() {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile; return *this;}
 459         inline VerFileIterator operator++(int) { VerFileIterator const tmp(*this); operator++(); return tmp; }
 460
 461         // Accessors
 462         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 463
 464         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {}
 465         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {}
 466 };
 467                                                                         /*}}}*/
 468 // Description File                                                     /*{{{*/
 469 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 470         public:
 471         inline DescFile* OwnerPointer() const {
 472                 return (Owner != 0) ? Owner->DescFileP : 0;
 473         }
 474
 475         // Iteration
 476         inline DescFileIterator& operator++() {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile; return *this;}
 477         inline DescFileIterator operator++(int) { DescFileIterator const tmp(*this); operator++(); return tmp; }
 478
 479         // Accessors
 480         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 481
 482         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {}
 483         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {}
 484 };
 485                                                                         /*}}}*/
 486 // Inlined Begin functions can't be in the class because of order problems /*{{{*/
 487 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 488        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);}
 489 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 490        {return VerIterator(*Owner,Owner->VerP + S->VersionList);}
 491 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 492        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);}
 493 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 494        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);}
 495 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 496        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 497 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 498        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);}
 499 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 500        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 501 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 502        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);}
 503 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 504        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);}
 505 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 506        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);}
 507                                                                         /*}}}*/
 508 #endif