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