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 #if APT_PKG_ABI >= 413
 215         /** \brief source package name this version comes from
 216            Always contains the name, even if it is the same as the binary name */
 217         inline const char *SourcePkgName() const {return Owner->StrP + S->SourcePkgName;}
 218         /** \brief source version this version comes from
 219            Always contains the version string, even if it is the same as the binary version */
 220         inline const char *SourceVerStr() const {return Owner->StrP + S->SourceVerStr;}
 221 #endif
 222         inline const char *Arch() const {
 223                 if ((S->MultiArch & pkgCache::Version::All) == pkgCache::Version::All)
 224                         return "all";
 225                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 226         }
 227         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 228
 229         inline DescIterator DescriptionList() const;
 230         DescIterator TranslatedDescription() const;
 231         inline DepIterator DependsList() const;
 232         inline PrvIterator ProvidesList() const;
 233         inline VerFileIterator FileList() const;
 234         bool Downloadable() const;
 235         inline const char *PriorityType() const {return Owner->Priority(S->Priority);}
 236         const char *MultiArchType() const APT_PURE;
 237         std::string RelStr() const;
 238
 239         bool Automatic() const;
 240         VerFileIterator NewestFile() const;
 241
 242         inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
 243                 if (S == 0)
 244                         S = OwnerPointer();
 245         }
 246         inline VerIterator() : Iterator<Version, VerIterator>() {}
 247 };
 248                                                                         /*}}}*/
 249 // Description Iterator                                                 /*{{{*/
 250 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 251         public:
 252         inline Description* OwnerPointer() const {
 253                 return (Owner != 0) ? Owner->DescP : 0;
 254         }
 255
 256         // Iteration
 257         inline DescIterator& operator++() {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc; return *this;}
 258         inline DescIterator operator++(int) { DescIterator const tmp(*this); operator++(); return tmp; }
 259
 260         // Comparison
 261         int CompareDesc(const DescIterator &B) const;
 262
 263         // Accessors
 264         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;}
 265         inline const char *md5() const {return Owner->StrP + S->md5sum;}
 266         inline DescFileIterator FileList() const;
 267
 268         inline DescIterator() : Iterator<Description, DescIterator>() {}
 269         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 270                 if (S == 0)
 271                         S = Owner.DescP;
 272         }
 273 };
 274                                                                         /*}}}*/
 275 // Dependency iterator                                                  /*{{{*/
 276 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 277         enum {DepVer, DepRev} Type;
 278         DependencyData * S2;
 279
 280         public:
 281         inline Dependency* OwnerPointer() const {
 282                 return (Owner != 0) ? Owner->DepP : 0;
 283         }
 284
 285         // Iteration
 286         DepIterator& operator++();
 287         inline DepIterator operator++(int) { DepIterator const tmp(*this); operator++(); return tmp; }
 288
 289         // Accessors
 290         inline const char *TargetVer() const {return S2->Version == 0?0:Owner->StrP + S2->Version;}
 291         inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S2->Package);}
 292         inline PkgIterator SmartTargetPkg() const {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;}
 293         inline VerIterator ParentVer() const {return VerIterator(*Owner,Owner->VerP + S->ParentVer);}
 294         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);}
 295         inline bool Reverse() const {return Type == DepRev;}
 296         bool IsCritical() const APT_PURE;
 297         bool IsNegative() const APT_PURE;
 298         bool IsIgnorable(PrvIterator const &Prv) const APT_PURE;
 299         bool IsIgnorable(PkgIterator const &Pkg) const APT_PURE;
 300         bool IsMultiArchImplicit() const APT_PURE;
 301         bool IsSatisfied(VerIterator const &Ver) const APT_PURE;
 302         bool IsSatisfied(PrvIterator const &Prv) const APT_PURE;
 303         void GlobOr(DepIterator &Start,DepIterator &End);
 304         Version **AllTargets() const;
 305         bool SmartTargetPkg(PkgIterator &Result) const;
 306         inline const char *CompType() const {return Owner->CompType(S2->CompareOp);}
 307         inline const char *DepType() const {return Owner->DepType(S2->Type);}
 308
 309         // overrides because we are special
 310         struct DependencyProxy
 311         {
 312            map_stringitem_t &Version;
 313            map_pointer_t &Package;
 314            should_be_map_id_t &ID;
 315            unsigned char &Type;
 316            unsigned char &CompareOp;
 317            map_pointer_t &ParentVer;
 318            map_pointer_t &DependencyData;
 319            map_pointer_t &NextRevDepends;
 320            map_pointer_t &NextDepends;
 321            DependencyProxy const * operator->() const { return this; }
 322            DependencyProxy * operator->() { return this; }
 323         };
 324         inline DependencyProxy operator->() const {return { S2->Version, S2->Package, S->ID, S2->Type, S2->CompareOp, S->ParentVer, S->DependencyData, S->NextRevDepends, S->NextDepends };}
 325         inline DependencyProxy operator->() {return { S2->Version, S2->Package, S->ID, S2->Type, S2->CompareOp, S->ParentVer, S->DependencyData, S->NextRevDepends, S->NextDepends };}
 326         void ReMap(void const * const oldMap, void const * const newMap)
 327         {
 328                 Iterator<Dependency, DepIterator>::ReMap(oldMap, newMap);
 329                 if (Owner == 0 || S == 0 || S2 == 0)
 330                         return;
 331                 S2 += (DependencyData const * const)(newMap) - (DependencyData const * const)(oldMap);
 332         }
 333
 334         //Nice printable representation
 335         friend std::ostream& operator <<(std::ostream& out, DepIterator D);
 336
 337         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 338                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 339                 if (S == 0)
 340                         S = Owner.DepP;
 341         }
 342         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 343                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 344                 if (S == 0)
 345                         S = Owner.DepP;
 346         }
 347         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer), S2(0) {}
 348 };
 349                                                                         /*}}}*/
 350 // Provides iterator                                                    /*{{{*/
 351 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 352         enum {PrvVer, PrvPkg} Type;
 353
 354         public:
 355         inline Provides* OwnerPointer() const {
 356                 return (Owner != 0) ? Owner->ProvideP : 0;
 357         }
 358
 359         // Iteration
 360         inline PrvIterator& operator ++() {if (S != Owner->ProvideP) S = Owner->ProvideP +
 361            (Type == PrvVer?S->NextPkgProv:S->NextProvides); return *this;}
 362         inline PrvIterator operator++(int) { PrvIterator const tmp(*this); operator++(); return tmp; }
 363
 364         // Accessors
 365         inline const char *Name() const {return ParentPkg().Name();}
 366         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;}
 367         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 368         inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);}
 369         inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);}
 370
 371         bool IsMultiArchImplicit() const APT_PURE;
 372
 373         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {}
 374         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 375                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 376                 if (S == 0)
 377                         S = Owner.ProvideP;
 378         }
 379         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 380                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 381                 if (S == 0)
 382                         S = Owner.ProvideP;
 383         }
 384 };
 385                                                                         /*}}}*/
 386 // Release file                                                         /*{{{*/
 387 class pkgCache::RlsFileIterator : public Iterator<ReleaseFile, RlsFileIterator> {
 388         public:
 389         inline ReleaseFile* OwnerPointer() const {
 390                 return (Owner != 0) ? Owner->RlsFileP : 0;
 391         }
 392
 393         // Iteration
 394         inline RlsFileIterator& operator++() {if (S != Owner->RlsFileP) S = Owner->RlsFileP + S->NextFile;return *this;}
 395         inline RlsFileIterator operator++(int) { RlsFileIterator const tmp(*this); operator++(); return tmp; }
 396
 397         // Accessors
 398         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 399         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;}
 400         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;}
 401         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;}
 402         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;}
 403         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;}
 404         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;}
 405         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return (S->Flags & flag) == flag; }
 406
 407         bool IsOk();
 408         std::string RelStr();
 409
 410         // Constructors
 411         inline RlsFileIterator() : Iterator<ReleaseFile, RlsFileIterator>() {}
 412         explicit inline RlsFileIterator(pkgCache &Owner) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Owner.RlsFileP) {}
 413         inline RlsFileIterator(pkgCache &Owner,ReleaseFile *Trg) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Trg) {}
 414 };
 415                                                                         /*}}}*/
 416 // Package file                                                         /*{{{*/
 417 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 418         public:
 419         inline PackageFile* OwnerPointer() const {
 420                 return (Owner != 0) ? Owner->PkgFileP : 0;
 421         }
 422
 423         // Iteration
 424         inline PkgFileIterator& operator++() {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile; return *this;}
 425         inline PkgFileIterator operator++(int) { PkgFileIterator const tmp(*this); operator++(); return tmp; }
 426
 427         // Accessors
 428         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 429         inline pkgCache::RlsFileIterator ReleaseFile() const {return RlsFileIterator(*Owner, Owner->RlsFileP + S->Release);}
 430         inline const char *Archive() const {return S->Release == 0 ? Component() : ReleaseFile().Archive();}
 431         inline const char *Version() const {return S->Release == 0 ? NULL : ReleaseFile().Version();}
 432         inline const char *Origin() const {return S->Release == 0 ? NULL : ReleaseFile().Origin();}
 433         inline const char *Codename() const {return S->Release == 0 ? NULL : ReleaseFile().Codename();}
 434         inline const char *Label() const {return S->Release == 0 ? NULL : ReleaseFile().Label();}
 435         inline const char *Site() const {return S->Release == 0 ? NULL : ReleaseFile().Site();}
 436         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return S->Release== 0 ? false : ReleaseFile().Flagged(flag);}
 437         inline bool Flagged(pkgCache::Flag::PkgFFlags const flag) const {return (S->Flags & flag) == flag;}
 438         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;}
 439         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;}
 440         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;}
 441
 442         bool IsOk();
 443         std::string RelStr();
 444
 445         // Constructors
 446         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {}
 447         explicit inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {}
 448         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {}
 449 };
 450                                                                         /*}}}*/
 451 // Version File                                                         /*{{{*/
 452 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 453         public:
 454         inline VerFile* OwnerPointer() const {
 455                 return (Owner != 0) ? Owner->VerFileP : 0;
 456         }
 457
 458         // Iteration
 459         inline VerFileIterator& operator++() {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile; return *this;}
 460         inline VerFileIterator operator++(int) { VerFileIterator const tmp(*this); operator++(); return tmp; }
 461
 462         // Accessors
 463         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 464
 465         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {}
 466         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {}
 467 };
 468                                                                         /*}}}*/
 469 // Description File                                                     /*{{{*/
 470 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 471         public:
 472         inline DescFile* OwnerPointer() const {
 473                 return (Owner != 0) ? Owner->DescFileP : 0;
 474         }
 475
 476         // Iteration
 477         inline DescFileIterator& operator++() {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile; return *this;}
 478         inline DescFileIterator operator++(int) { DescFileIterator const tmp(*this); operator++(); return tmp; }
 479
 480         // Accessors
 481         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 482
 483         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {}
 484         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {}
 485 };
 486                                                                         /*}}}*/
 487 // Inlined Begin functions can't be in the class because of order problems /*{{{*/
 488 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 489        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);}
 490 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 491        {return VerIterator(*Owner,Owner->VerP + S->VersionList);}
 492 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 493        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);}
 494 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 495        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);}
 496 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 497        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 498 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 499        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);}
 500 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 501        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 502 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 503        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);}
 504 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 505        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);}
 506 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 507        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);}
 508                                                                         /*}}}*/
 509 #endif