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 #ifdef APT_PKG_EXPOSE_STRING_VIEW
  39 #include <apt-pkg/string_view.h>
  40 #endif
  41
  42 #include<string.h>
  43
  44 // abstract Iterator template                                           /*{{{*/
  45 /* This template provides the very basic iterator methods we
  46    need to have for doing some walk-over-the-cache magic */
  47 template<typename Str, typename Itr> class pkgCache::Iterator :
  48                         public std::iterator<std::forward_iterator_tag, Str> {
  49         /** \brief Returns the Pointer for this struct in the owner
  50          *  The implementation of this method should be pretty short
  51          *  as it will only return the Pointer into the mmap stored
  52          *  in the owner but the name of this pointer is different for
  53          *  each structure and we want to abstract here at least for the
  54          *  basic methods from the actual structure.
  55          *  \return Pointer to the first structure of this type
  56          */
  57         Str* OwnerPointer() const { return static_cast<Itr const*>(this)->OwnerPointer(); }
  58
  59         protected:
  60         Str *S;
  61         pkgCache *Owner;
  62
  63         public:
  64         // Iteration
  65         inline bool end() const {return Owner == 0 || S == OwnerPointer();}
  66
  67         // Comparison
  68         inline bool operator ==(const Itr &B) const {return S == B.S;}
  69         inline bool operator !=(const Itr &B) const {return S != B.S;}
  70
  71         // Accessors
  72         inline Str *operator ->() {return S;}
  73         inline Str const *operator ->() const {return S;}
  74         inline operator Str *() {return S == OwnerPointer() ? 0 : S;}
  75         inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;}
  76         inline Str &operator *() {return *S;}
  77         inline Str const &operator *() const {return *S;}
  78         inline pkgCache *Cache() const {return Owner;}
  79
  80         // Mixed stuff
  81         inline bool IsGood() const { return S && Owner && ! end();}
  82         inline unsigned long Index() const {return S - OwnerPointer();}
  83
  84         void ReMap(void const * const oldMap, void const * const newMap) {
  85                 if (Owner == 0 || S == 0)
  86                         return;
  87                 S += (Str const * const)(newMap) - (Str const * const)(oldMap);
  88         }
  89
  90         // Constructors - look out for the variable assigning
  91         inline Iterator() : S(0), Owner(0) {}
  92         inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {}
  93 };
  94                                                                         /*}}}*/
  95 // Group Iterator                                                       /*{{{*/
  96 /* Packages with the same name are collected in a Group so someone only
  97    interest in package names can iterate easily over the names, so the
  98    different architectures can be treated as of the "same" package
  99    (apt internally treat them as totally different packages) */
 100 class pkgCache::GrpIterator: public Iterator<Group, GrpIterator> {
 101         long HashIndex;
 102
 103         public:
 104         inline Group* OwnerPointer() const {
 105                 return (Owner != 0) ? Owner->GrpP : 0;
 106         }
 107
 108         // This constructor is the 'begin' constructor, never use it.
 109         explicit inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
 110                 S = OwnerPointer();
 111                 operator++();
 112         }
 113
 114         GrpIterator& operator++();
 115         inline GrpIterator operator++(int) { GrpIterator const tmp(*this); operator++(); return tmp; }
 116
 117         inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;}
 118         inline PkgIterator PackageList() const;
 119         PkgIterator FindPkg(std::string Arch = "any") const;
 120 #ifdef APT_PKG_EXPOSE_STRING_VIEW
 121         APT_HIDDEN PkgIterator FindPkg(APT::StringView Arch = APT::StringView("any", 3)) const;
 122         APT_HIDDEN PkgIterator FindPkg(const char *Arch) const;
 123 #endif
 124         /** \brief find the package with the "best" architecture
 125
 126             The best architecture is either the "native" or the first
 127             in the list of Architectures which is not an end-Pointer
 128
 129             \param PreferNonVirtual tries to respond with a non-virtual package
 130                    and only if this fails returns the best virtual package */
 131         PkgIterator FindPreferredPkg(bool const &PreferNonVirtual = true) const;
 132         PkgIterator NextPkg(PkgIterator const &Pkg) const;
 133
 134         // Constructors
 135         inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
 136                 if (S == 0)
 137                         S = OwnerPointer();
 138         }
 139         inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {}
 140
 141 };
 142                                                                         /*}}}*/
 143 // Package Iterator                                                     /*{{{*/
 144 class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
 145         long HashIndex;
 146
 147         public:
 148         inline Package* OwnerPointer() const {
 149                 return (Owner != 0) ? Owner->PkgP : 0;
 150         }
 151
 152         // This constructor is the 'begin' constructor, never use it.
 153         explicit inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
 154                 S = OwnerPointer();
 155                 operator++();
 156         }
 157
 158         PkgIterator& operator++();
 159         inline PkgIterator operator++(int) { PkgIterator const tmp(*this); operator++(); return tmp; }
 160
 161         enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
 162
 163         // Accessors
 164         inline const char *Name() const { return Group().Name(); }
 165         // Versions have sections - and packages can have different versions with different sections
 166         // so this interface is broken by design. Run as fast as you can to Version.Section().
 167         APT_DEPRECATED_MSG("Use the .Section method of VerIterator instead") inline const char *Section() const;
 168         inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
 169                 (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);}
 170         inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;}
 171         inline APT_PURE GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);}
 172
 173         inline VerIterator VersionList() const APT_PURE;
 174         inline VerIterator CurrentVer() const APT_PURE;
 175         inline DepIterator RevDependsList() const APT_PURE;
 176         inline PrvIterator ProvidesList() const APT_PURE;
 177         OkState State() const APT_PURE;
 178         APT_DEPRECATED_MSG("This method does not respect apt_preferences! Use pkgDepCache::GetCandidateVersion(Pkg)") const char *CandVersion() const APT_PURE;
 179         const char *CurVersion() const APT_PURE;
 180
 181         //Nice printable representation
 182         APT_DEPRECATED_MSG("Use APT::PrettyPkg instead") friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
 183         std::string FullName(bool const &Pretty = false) const;
 184
 185         // Constructors
 186         inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
 187                 if (S == 0)
 188                         S = OwnerPointer();
 189         }
 190         inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {}
 191 };
 192                                                                         /*}}}*/
 193 // Version Iterator                                                     /*{{{*/
 194 class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
 195         public:
 196         inline Version* OwnerPointer() const {
 197                 return (Owner != 0) ? Owner->VerP : 0;
 198         }
 199
 200         // Iteration
 201         inline VerIterator& operator++() {if (S != Owner->VerP) S = Owner->VerP + S->NextVer; return *this;}
 202         inline VerIterator operator++(int) { VerIterator const tmp(*this); operator++(); return tmp; }
 203
 204         // Comparison
 205         int CompareVer(const VerIterator &B) const;
 206         /** \brief compares two version and returns if they are similar
 207
 208             This method should be used to identify if two pseudo versions are
 209             referring to the same "real" version */
 210         inline bool SimilarVer(const VerIterator &B) const {
 211                 return (B.end() == false && S->Hash == B->Hash && strcmp(VerStr(), B.VerStr()) == 0);
 212         }
 213
 214         // Accessors
 215         inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;}
 216         inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;}
 217         inline const char *Display() const {return S->Display == 0?0:Owner->StrP + S->Display;}
 218         /** \brief source package name this version comes from
 219            Always contains the name, even if it is the same as the binary name */
 220         inline const char *SourcePkgName() const {return Owner->StrP + S->SourcePkgName;}
 221         /** \brief source version this version comes from
 222            Always contains the version string, even if it is the same as the binary version */
 223         inline const char *SourceVerStr() const {return Owner->StrP + S->SourceVerStr;}
 224         inline const char *Arch() const {
 225                 if ((S->MultiArch & pkgCache::Version::All) == pkgCache::Version::All)
 226                         return "all";
 227                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 228         }
 229         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 230
 231         inline DescIterator DescriptionList() const;
 232         DescIterator TranslatedDescription() const;
 233         inline DepIterator DependsList() const;
 234         inline PrvIterator ProvidesList() const;
 235         inline TagIterator TagList() const;
 236         inline VerFileIterator FileList() const;
 237         bool Downloadable() const;
 238         inline const char *PriorityType() const {return Owner->Priority(S->Priority);}
 239         const char *MultiArchType() const APT_PURE;
 240         std::string RelStr() const;
 241
 242         bool Automatic() const;
 243         VerFileIterator NewestFile() const;
 244
 245         inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
 246                 if (S == 0)
 247                         S = OwnerPointer();
 248         }
 249         inline VerIterator() : Iterator<Version, VerIterator>() {}
 250 };
 251                                                                         /*}}}*/
 252 // Tag Iterator                                                         /*{{{*/
 253 class pkgCache::TagIterator
 254 {
 255    Tag *Tg;
 256    pkgCache *Owner;
 257
 258    void _dummy();
 259
 260    public:
 261
 262    // Iteration
 263    void operator ++(int) {if (Tg != Owner->TagP) Tg = Owner->TagP + Tg->NextTag;};
 264    inline void operator ++() {operator ++(0);};
 265    inline bool end() const {return Tg == Owner->TagP?true:false;};
 266    inline void operator =(const TagIterator &B) {Tg = B.Tg; Owner = B.Owner;};
 267
 268    // Comparison
 269    inline bool operator ==(const TagIterator &B) const {return Tg == B.Tg;};
 270    inline bool operator !=(const TagIterator &B) const {return Tg != B.Tg;};
 271    int CompareTag(const TagIterator &B) const;
 272
 273    // Accessors
 274    inline Tag *operator ->() {return Tg;};
 275    inline Tag const *operator ->() const {return Tg;};
 276    inline Tag &operator *() {return *Tg;};
 277    inline Tag const &operator *() const {return *Tg;};
 278    inline operator Tag *() {return Tg == Owner->TagP?0:Tg;};
 279    inline operator Tag const *() const {return Tg == Owner->TagP?0:Tg;};
 280    inline pkgCache *Cache() {return Owner;};
 281
 282    inline const char *Name() const {return Owner->StrP + Tg->Name;};
 283    inline unsigned long Index() const {return Tg - Owner->TagP;};
 284
 285    inline TagIterator() : Tg(0), Owner(0) {};
 286    inline TagIterator(pkgCache &Owner,Tag *Trg = 0) : Tg(Trg),
 287               Owner(&Owner)
 288    {
 289       if (Tg == 0)
 290          Tg = Owner.TagP;
 291    };
 292 };
 293                                                                         /*}}}*/
 294 // Description Iterator                                                 /*{{{*/
 295 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 296         public:
 297         inline Description* OwnerPointer() const {
 298                 return (Owner != 0) ? Owner->DescP : 0;
 299         }
 300
 301         // Iteration
 302         inline DescIterator& operator++() {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc; return *this;}
 303         inline DescIterator operator++(int) { DescIterator const tmp(*this); operator++(); return tmp; }
 304
 305         // Comparison
 306         int CompareDesc(const DescIterator &B) const;
 307
 308         // Accessors
 309         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;}
 310         inline const char *md5() const {return Owner->StrP + S->md5sum;}
 311         inline DescFileIterator FileList() const;
 312
 313         inline DescIterator() : Iterator<Description, DescIterator>() {}
 314         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 315                 if (S == 0)
 316                         S = Owner.DescP;
 317         }
 318 };
 319                                                                         /*}}}*/
 320 // Dependency iterator                                                  /*{{{*/
 321 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 322         enum {DepVer, DepRev} Type;
 323         DependencyData * S2;
 324
 325         public:
 326         inline Dependency* OwnerPointer() const {
 327                 return (Owner != 0) ? Owner->DepP : 0;
 328         }
 329
 330         // Iteration
 331         DepIterator& operator++();
 332         inline DepIterator operator++(int) { DepIterator const tmp(*this); operator++(); return tmp; }
 333
 334         // Accessors
 335         inline const char *TargetVer() const {return S2->Version == 0?0:Owner->StrP + S2->Version;}
 336         inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S2->Package);}
 337         inline PkgIterator SmartTargetPkg() const {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;}
 338         inline VerIterator ParentVer() const {return VerIterator(*Owner,Owner->VerP + S->ParentVer);}
 339         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);}
 340         inline bool Reverse() const {return Type == DepRev;}
 341         bool IsCritical() const APT_PURE;
 342         bool IsNegative() const APT_PURE;
 343         bool IsIgnorable(PrvIterator const &Prv) const APT_PURE;
 344         bool IsIgnorable(PkgIterator const &Pkg) const APT_PURE;
 345         /* MultiArch can be translated to SingleArch for an resolver and we did so,
 346            by adding dependencies to help the resolver understand the problem, but
 347            sometimes it is needed to identify these to ignore them… */
 348         inline bool IsMultiArchImplicit() const APT_PURE {
 349                 return (S2->CompareOp & pkgCache::Dep::MultiArchImplicit) == pkgCache::Dep::MultiArchImplicit;
 350         }
 351         /* This covers additionally negative dependencies, which aren't arch-specific,
 352            but change architecture nonetheless as a Conflicts: foo does applies for all archs */
 353         bool IsImplicit() const APT_PURE;
 354
 355         bool IsSatisfied(VerIterator const &Ver) const APT_PURE;
 356         bool IsSatisfied(PrvIterator const &Prv) const APT_PURE;
 357         void GlobOr(DepIterator &Start,DepIterator &End);
 358         Version **AllTargets() const;
 359         bool SmartTargetPkg(PkgIterator &Result) const;
 360         inline const char *CompType() const {return Owner->CompType(S2->CompareOp);}
 361         inline const char *DepType() const {return Owner->DepType(S2->Type);}
 362
 363         // overrides because we are special
 364         struct DependencyProxy
 365         {
 366            map_stringitem_t &Version;
 367            map_pointer_t &Package;
 368            map_id_t &ID;
 369            unsigned char &Type;
 370            unsigned char &CompareOp;
 371            map_pointer_t &ParentVer;
 372            map_pointer_t &DependencyData;
 373            map_pointer_t &NextRevDepends;
 374            map_pointer_t &NextDepends;
 375            map_pointer_t &NextData;
 376            DependencyProxy const * operator->() const { return this; }
 377            DependencyProxy * operator->() { return this; }
 378         };
 379         inline DependencyProxy operator->() const {return (DependencyProxy) { S2->Version, S2->Package, S->ID, S2->Type, S2->CompareOp, S->ParentVer, S->DependencyData, S->NextRevDepends, S->NextDepends, S2->NextData };}
 380         inline DependencyProxy operator->() {return (DependencyProxy) { S2->Version, S2->Package, S->ID, S2->Type, S2->CompareOp, S->ParentVer, S->DependencyData, S->NextRevDepends, S->NextDepends, S2->NextData };}
 381         void ReMap(void const * const oldMap, void const * const newMap)
 382         {
 383                 Iterator<Dependency, DepIterator>::ReMap(oldMap, newMap);
 384                 if (Owner == 0 || S == 0 || S2 == 0)
 385                         return;
 386                 S2 += (DependencyData const * const)(newMap) - (DependencyData const * const)(oldMap);
 387         }
 388
 389         //Nice printable representation
 390         APT_DEPRECATED_MSG("Use APT::PrettyDep instead") friend std::ostream& operator <<(std::ostream& out, DepIterator D);
 391
 392         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 393                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 394                 if (S == 0)
 395                         S = Owner.DepP;
 396         }
 397         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 398                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 399                 if (S == 0)
 400                         S = Owner.DepP;
 401         }
 402         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer), S2(0) {}
 403 };
 404                                                                         /*}}}*/
 405 // Provides iterator                                                    /*{{{*/
 406 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 407         enum {PrvVer, PrvPkg} Type;
 408
 409         public:
 410         inline Provides* OwnerPointer() const {
 411                 return (Owner != 0) ? Owner->ProvideP : 0;
 412         }
 413
 414         // Iteration
 415         inline PrvIterator& operator ++() {if (S != Owner->ProvideP) S = Owner->ProvideP +
 416            (Type == PrvVer?S->NextPkgProv:S->NextProvides); return *this;}
 417         inline PrvIterator operator++(int) { PrvIterator const tmp(*this); operator++(); return tmp; }
 418
 419         // Accessors
 420         inline const char *Name() const {return ParentPkg().Name();}
 421         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;}
 422         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 423         inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);}
 424         inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);}
 425
 426         /* MultiArch can be translated to SingleArch for an resolver and we did so,
 427            by adding provides to help the resolver understand the problem, but
 428            sometimes it is needed to identify these to ignore them… */
 429         bool IsMultiArchImplicit() const APT_PURE
 430         { return (S->Flags & pkgCache::Flag::MultiArchImplicit) == pkgCache::Flag::MultiArchImplicit; }
 431
 432
 433         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {}
 434         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 435                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 436                 if (S == 0)
 437                         S = Owner.ProvideP;
 438         }
 439         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 440                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 441                 if (S == 0)
 442                         S = Owner.ProvideP;
 443         }
 444 };
 445                                                                         /*}}}*/
 446 // Release file                                                         /*{{{*/
 447 class pkgCache::RlsFileIterator : public Iterator<ReleaseFile, RlsFileIterator> {
 448         public:
 449         inline ReleaseFile* OwnerPointer() const {
 450                 return (Owner != 0) ? Owner->RlsFileP : 0;
 451         }
 452
 453         // Iteration
 454         inline RlsFileIterator& operator++() {if (S != Owner->RlsFileP) S = Owner->RlsFileP + S->NextFile;return *this;}
 455         inline RlsFileIterator operator++(int) { RlsFileIterator const tmp(*this); operator++(); return tmp; }
 456
 457         // Accessors
 458         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 459         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;}
 460         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;}
 461         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;}
 462         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;}
 463         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;}
 464         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;}
 465         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return (S->Flags & flag) == flag; }
 466
 467         bool IsOk();
 468         std::string RelStr();
 469
 470         // Constructors
 471         inline RlsFileIterator() : Iterator<ReleaseFile, RlsFileIterator>() {}
 472         explicit inline RlsFileIterator(pkgCache &Owner) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Owner.RlsFileP) {}
 473         inline RlsFileIterator(pkgCache &Owner,ReleaseFile *Trg) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Trg) {}
 474 };
 475                                                                         /*}}}*/
 476 // Package file                                                         /*{{{*/
 477 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 478         public:
 479         inline PackageFile* OwnerPointer() const {
 480                 return (Owner != 0) ? Owner->PkgFileP : 0;
 481         }
 482
 483         // Iteration
 484         inline PkgFileIterator& operator++() {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile; return *this;}
 485         inline PkgFileIterator operator++(int) { PkgFileIterator const tmp(*this); operator++(); return tmp; }
 486
 487         // Accessors
 488         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 489         inline pkgCache::RlsFileIterator ReleaseFile() const {return RlsFileIterator(*Owner, Owner->RlsFileP + S->Release);}
 490         inline const char *Archive() const {return S->Release == 0 ? Component() : ReleaseFile().Archive();}
 491         inline const char *Version() const {return S->Release == 0 ? NULL : ReleaseFile().Version();}
 492         inline const char *Origin() const {return S->Release == 0 ? NULL : ReleaseFile().Origin();}
 493         inline const char *Codename() const {return S->Release == 0 ? NULL : ReleaseFile().Codename();}
 494         inline const char *Label() const {return S->Release == 0 ? NULL : ReleaseFile().Label();}
 495         inline const char *Site() const {return S->Release == 0 ? NULL : ReleaseFile().Site();}
 496         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return S->Release== 0 ? false : ReleaseFile().Flagged(flag);}
 497         inline bool Flagged(pkgCache::Flag::PkgFFlags const flag) const {return (S->Flags & flag) == flag;}
 498         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;}
 499         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;}
 500         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;}
 501
 502         bool IsOk();
 503         std::string RelStr();
 504
 505         // Constructors
 506         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {}
 507         explicit inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {}
 508         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {}
 509 };
 510                                                                         /*}}}*/
 511 // Version File                                                         /*{{{*/
 512 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 513         public:
 514         inline VerFile* OwnerPointer() const {
 515                 return (Owner != 0) ? Owner->VerFileP : 0;
 516         }
 517
 518         // Iteration
 519         inline VerFileIterator& operator++() {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile; return *this;}
 520         inline VerFileIterator operator++(int) { VerFileIterator const tmp(*this); operator++(); return tmp; }
 521
 522         // Accessors
 523         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 524
 525         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {}
 526         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {}
 527 };
 528                                                                         /*}}}*/
 529 // Description File                                                     /*{{{*/
 530 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 531         public:
 532         inline DescFile* OwnerPointer() const {
 533                 return (Owner != 0) ? Owner->DescFileP : 0;
 534         }
 535
 536         // Iteration
 537         inline DescFileIterator& operator++() {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile; return *this;}
 538         inline DescFileIterator operator++(int) { DescFileIterator const tmp(*this); operator++(); return tmp; }
 539
 540         // Accessors
 541         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 542
 543         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {}
 544         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {}
 545 };
 546                                                                         /*}}}*/
 547 // Inlined Begin functions can't be in the class because of order problems /*{{{*/
 548 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 549        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);}
 550 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 551        {return VerIterator(*Owner,Owner->VerP + S->VersionList);}
 552 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 553        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);}
 554 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 555        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);}
 556 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 557        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 558 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 559        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);}
 560 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 561        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 562 inline pkgCache::TagIterator pkgCache::VerIterator::TagList() const
 563        {return TagIterator(*Owner,Owner->TagP + S->TagList);};
 564 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 565        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);}
 566 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 567        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);}
 568 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 569        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);}
 570 APT_DEPRECATED_MSG("Use the .Section method of VerIterator instead") inline const char * pkgCache::PkgIterator::Section() const
 571        {return S->VersionList == 0 ? 0 : VersionList().Section();}
 572                                                                         /*}}}*/
 573 #endif