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 : public Iterator<Tag, TagIterator> {
 254         public:
 255         inline Tag* OwnerPointer() const {
 256                 return (Owner != 0) ? Owner->TagP : 0;
 257         }
 258
 259    // Iteration
 260    void operator ++(int) {if (S != Owner->TagP) S = Owner->TagP + S->NextTag;};
 261    inline void operator ++() {operator ++(0);};
 262
 263    // Comparison
 264    inline bool operator ==(const TagIterator &B) const {return S == B.S;};
 265    inline bool operator !=(const TagIterator &B) const {return S != B.S;};
 266    int CompareTag(const TagIterator &B) const;
 267
 268    // Accessors
 269    inline const char *Name() const {return Owner->StrP + S->Name;};
 270    inline unsigned long Index() const {return S - Owner->TagP;};
 271
 272         inline TagIterator(pkgCache &Owner,Tag *Trg = 0) : Iterator<Tag, TagIterator>(Owner, Trg) {
 273                 if (S == 0)
 274                         S = OwnerPointer();
 275         }
 276         inline TagIterator() : Iterator<Tag, TagIterator>() {}
 277 };
 278                                                                         /*}}}*/
 279 // Description Iterator                                                 /*{{{*/
 280 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 281         public:
 282         inline Description* OwnerPointer() const {
 283                 return (Owner != 0) ? Owner->DescP : 0;
 284         }
 285
 286         // Iteration
 287         inline DescIterator& operator++() {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc; return *this;}
 288         inline DescIterator operator++(int) { DescIterator const tmp(*this); operator++(); return tmp; }
 289
 290         // Comparison
 291         int CompareDesc(const DescIterator &B) const;
 292
 293         // Accessors
 294         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;}
 295         inline const char *md5() const {return Owner->StrP + S->md5sum;}
 296         inline DescFileIterator FileList() const;
 297
 298         inline DescIterator() : Iterator<Description, DescIterator>() {}
 299         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 300                 if (S == 0)
 301                         S = Owner.DescP;
 302         }
 303 };
 304                                                                         /*}}}*/
 305 // Dependency iterator                                                  /*{{{*/
 306 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 307         enum {DepVer, DepRev} Type;
 308         DependencyData * S2;
 309
 310         public:
 311         inline Dependency* OwnerPointer() const {
 312                 return (Owner != 0) ? Owner->DepP : 0;
 313         }
 314
 315         // Iteration
 316         DepIterator& operator++();
 317         inline DepIterator operator++(int) { DepIterator const tmp(*this); operator++(); return tmp; }
 318
 319         // Accessors
 320         inline const char *TargetVer() const {return S2->Version == 0?0:Owner->StrP + S2->Version;}
 321         inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S2->Package);}
 322         inline PkgIterator SmartTargetPkg() const {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;}
 323         inline VerIterator ParentVer() const {return VerIterator(*Owner,Owner->VerP + S->ParentVer);}
 324         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);}
 325         inline bool Reverse() const {return Type == DepRev;}
 326         bool IsCritical() const APT_PURE;
 327         bool IsNegative() const APT_PURE;
 328         bool IsIgnorable(PrvIterator const &Prv) const APT_PURE;
 329         bool IsIgnorable(PkgIterator const &Pkg) const APT_PURE;
 330         /* MultiArch can be translated to SingleArch for an resolver and we did so,
 331            by adding dependencies to help the resolver understand the problem, but
 332            sometimes it is needed to identify these to ignore them… */
 333         inline bool IsMultiArchImplicit() const APT_PURE {
 334                 return (S2->CompareOp & pkgCache::Dep::MultiArchImplicit) == pkgCache::Dep::MultiArchImplicit;
 335         }
 336         /* This covers additionally negative dependencies, which aren't arch-specific,
 337            but change architecture nonetheless as a Conflicts: foo does applies for all archs */
 338         bool IsImplicit() const APT_PURE;
 339
 340         bool IsSatisfied(VerIterator const &Ver) const APT_PURE;
 341         bool IsSatisfied(PrvIterator const &Prv) const APT_PURE;
 342         void GlobOr(DepIterator &Start,DepIterator &End);
 343         Version **AllTargets() const;
 344         bool SmartTargetPkg(PkgIterator &Result) const;
 345         inline const char *CompType() const {return Owner->CompType(S2->CompareOp);}
 346         inline const char *DepType() const {return Owner->DepType(S2->Type);}
 347
 348         // overrides because we are special
 349         struct DependencyProxy
 350         {
 351            map_stringitem_t &Version;
 352            map_pointer_t &Package;
 353            map_id_t &ID;
 354            unsigned char &Type;
 355            unsigned char &CompareOp;
 356            map_pointer_t &ParentVer;
 357            map_pointer_t &DependencyData;
 358            map_pointer_t &NextRevDepends;
 359            map_pointer_t &NextDepends;
 360            map_pointer_t &NextData;
 361            DependencyProxy const * operator->() const { return this; }
 362            DependencyProxy * operator->() { return this; }
 363         };
 364         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 };}
 365         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 };}
 366         void ReMap(void const * const oldMap, void const * const newMap)
 367         {
 368                 Iterator<Dependency, DepIterator>::ReMap(oldMap, newMap);
 369                 if (Owner == 0 || S == 0 || S2 == 0)
 370                         return;
 371                 S2 += (DependencyData const * const)(newMap) - (DependencyData const * const)(oldMap);
 372         }
 373
 374         //Nice printable representation
 375         APT_DEPRECATED_MSG("Use APT::PrettyDep instead") friend std::ostream& operator <<(std::ostream& out, DepIterator D);
 376
 377         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 378                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 379                 if (S == 0)
 380                         S = Owner.DepP;
 381         }
 382         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 383                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev), S2(Trg == 0 ? Owner.DepDataP : (Owner.DepDataP + Trg->DependencyData)) {
 384                 if (S == 0)
 385                         S = Owner.DepP;
 386         }
 387         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer), S2(0) {}
 388 };
 389                                                                         /*}}}*/
 390 // Provides iterator                                                    /*{{{*/
 391 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 392         enum {PrvVer, PrvPkg} Type;
 393
 394         public:
 395         inline Provides* OwnerPointer() const {
 396                 return (Owner != 0) ? Owner->ProvideP : 0;
 397         }
 398
 399         // Iteration
 400         inline PrvIterator& operator ++() {if (S != Owner->ProvideP) S = Owner->ProvideP +
 401            (Type == PrvVer?S->NextPkgProv:S->NextProvides); return *this;}
 402         inline PrvIterator operator++(int) { PrvIterator const tmp(*this); operator++(); return tmp; }
 403
 404         // Accessors
 405         inline const char *Name() const {return ParentPkg().Name();}
 406         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;}
 407         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 408         inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);}
 409         inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);}
 410
 411         /* MultiArch can be translated to SingleArch for an resolver and we did so,
 412            by adding provides to help the resolver understand the problem, but
 413            sometimes it is needed to identify these to ignore them… */
 414         bool IsMultiArchImplicit() const APT_PURE
 415         { return (S->Flags & pkgCache::Flag::MultiArchImplicit) == pkgCache::Flag::MultiArchImplicit; }
 416
 417
 418         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {}
 419         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 420                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 421                 if (S == 0)
 422                         S = Owner.ProvideP;
 423         }
 424         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 425                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 426                 if (S == 0)
 427                         S = Owner.ProvideP;
 428         }
 429 };
 430                                                                         /*}}}*/
 431 // Release file                                                         /*{{{*/
 432 class pkgCache::RlsFileIterator : public Iterator<ReleaseFile, RlsFileIterator> {
 433         public:
 434         inline ReleaseFile* OwnerPointer() const {
 435                 return (Owner != 0) ? Owner->RlsFileP : 0;
 436         }
 437
 438         // Iteration
 439         inline RlsFileIterator& operator++() {if (S != Owner->RlsFileP) S = Owner->RlsFileP + S->NextFile;return *this;}
 440         inline RlsFileIterator operator++(int) { RlsFileIterator const tmp(*this); operator++(); return tmp; }
 441
 442         // Accessors
 443         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 444         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;}
 445         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;}
 446         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;}
 447         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;}
 448         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;}
 449         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;}
 450         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return (S->Flags & flag) == flag; }
 451
 452         bool IsOk();
 453         std::string RelStr();
 454
 455         // Constructors
 456         inline RlsFileIterator() : Iterator<ReleaseFile, RlsFileIterator>() {}
 457         explicit inline RlsFileIterator(pkgCache &Owner) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Owner.RlsFileP) {}
 458         inline RlsFileIterator(pkgCache &Owner,ReleaseFile *Trg) : Iterator<ReleaseFile, RlsFileIterator>(Owner, Trg) {}
 459 };
 460                                                                         /*}}}*/
 461 // Package file                                                         /*{{{*/
 462 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 463         public:
 464         inline PackageFile* OwnerPointer() const {
 465                 return (Owner != 0) ? Owner->PkgFileP : 0;
 466         }
 467
 468         // Iteration
 469         inline PkgFileIterator& operator++() {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile; return *this;}
 470         inline PkgFileIterator operator++(int) { PkgFileIterator const tmp(*this); operator++(); return tmp; }
 471
 472         // Accessors
 473         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 474         inline pkgCache::RlsFileIterator ReleaseFile() const {return RlsFileIterator(*Owner, Owner->RlsFileP + S->Release);}
 475         inline const char *Archive() const {return S->Release == 0 ? Component() : ReleaseFile().Archive();}
 476         inline const char *Version() const {return S->Release == 0 ? NULL : ReleaseFile().Version();}
 477         inline const char *Origin() const {return S->Release == 0 ? NULL : ReleaseFile().Origin();}
 478         inline const char *Codename() const {return S->Release == 0 ? NULL : ReleaseFile().Codename();}
 479         inline const char *Label() const {return S->Release == 0 ? NULL : ReleaseFile().Label();}
 480         inline const char *Site() const {return S->Release == 0 ? NULL : ReleaseFile().Site();}
 481         inline bool Flagged(pkgCache::Flag::ReleaseFileFlags const flag) const {return S->Release== 0 ? false : ReleaseFile().Flagged(flag);}
 482         inline bool Flagged(pkgCache::Flag::PkgFFlags const flag) const {return (S->Flags & flag) == flag;}
 483         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;}
 484         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;}
 485         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;}
 486
 487         bool IsOk();
 488         std::string RelStr();
 489
 490         // Constructors
 491         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {}
 492         explicit inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {}
 493         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {}
 494 };
 495                                                                         /*}}}*/
 496 // Version File                                                         /*{{{*/
 497 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 498         public:
 499         inline VerFile* OwnerPointer() const {
 500                 return (Owner != 0) ? Owner->VerFileP : 0;
 501         }
 502
 503         // Iteration
 504         inline VerFileIterator& operator++() {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile; return *this;}
 505         inline VerFileIterator operator++(int) { VerFileIterator const tmp(*this); operator++(); return tmp; }
 506
 507         // Accessors
 508         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 509
 510         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {}
 511         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {}
 512 };
 513                                                                         /*}}}*/
 514 // Description File                                                     /*{{{*/
 515 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 516         public:
 517         inline DescFile* OwnerPointer() const {
 518                 return (Owner != 0) ? Owner->DescFileP : 0;
 519         }
 520
 521         // Iteration
 522         inline DescFileIterator& operator++() {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile; return *this;}
 523         inline DescFileIterator operator++(int) { DescFileIterator const tmp(*this); operator++(); return tmp; }
 524
 525         // Accessors
 526         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 527
 528         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {}
 529         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {}
 530 };
 531                                                                         /*}}}*/
 532 // Inlined Begin functions can't be in the class because of order problems /*{{{*/
 533 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 534        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);}
 535 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 536        {return VerIterator(*Owner,Owner->VerP + S->VersionList);}
 537 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 538        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);}
 539 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 540        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);}
 541 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 542        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 543 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 544        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);}
 545 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 546        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 547 inline pkgCache::TagIterator pkgCache::VerIterator::TagList() const
 548        {return TagIterator(*Owner,Owner->TagP + S->TagList);};
 549 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 550        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);}
 551 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 552        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);}
 553 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 554        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);}
 555 APT_DEPRECATED_MSG("Use the .Section method of VerIterator instead") inline const char * pkgCache::PkgIterator::Section() const
 556        {return S->VersionList == 0 ? 0 : VersionList().Section();}
 557                                                                         /*}}}*/
 558 #endif