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