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         protected:
  47         Str *S;
  48         pkgCache *Owner;
  49
  50         /** \brief Returns the Pointer for this struct in the owner
  51          *  The implementation of this method should be pretty short
  52          *  as it will only return the Pointer into the mmap stored
  53          *  in the owner but the name of this pointer is different for
  54          *  each structure and we want to abstract here at least for the
  55          *  basic methods from the actual structure.
  56          *  \return Pointer to the first structure of this type
  57          */
  58         virtual Str* OwnerPointer() const = 0;
  59
  60         public:
  61         // Iteration
  62         virtual void operator ++(int) = 0;
  63         virtual void operator ++() = 0; // Should be {operator ++(0);}
  64         inline bool end() const {return Owner == 0 || S == OwnerPointer();}
  65
  66         // Comparison
  67         inline bool operator ==(const Itr &B) const {return S == B.S;}
  68         inline bool operator !=(const Itr &B) const {return S != B.S;}
  69
  70         // Accessors
  71         inline Str *operator ->() {return S;}
  72         inline Str const *operator ->() const {return S;}
  73         inline operator Str *() {return S == OwnerPointer() ? 0 : S;}
  74         inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;}
  75         inline Str &operator *() {return *S;}
  76         inline Str const &operator *() const {return *S;}
  77         inline pkgCache *Cache() const {return Owner;}
  78
  79         // Mixed stuff
  80         inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;}
  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         protected:
 104         inline Group* OwnerPointer() const {
 105                 return (Owner != 0) ? Owner->GrpP : 0;
 106         }
 107
 108         public:
 109         // This constructor is the 'begin' constructor, never use it.
 110         inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
 111                 S = OwnerPointer();
 112                 operator ++(0);
 113         }
 114
 115         virtual void operator ++(int);
 116         virtual void operator ++() {operator ++(0);}
 117
 118         inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;}
 119         inline PkgIterator PackageList() const;
 120         PkgIterator FindPkg(std::string Arch = "any") const;
 121         /** \brief find the package with the "best" architecture
 122
 123             The best architecture is either the "native" or the first
 124             in the list of Architectures which is not an end-Pointer
 125
 126             \param PreferNonVirtual tries to respond with a non-virtual package
 127                    and only if this fails returns the best virtual package */
 128         PkgIterator FindPreferredPkg(bool const &PreferNonVirtual = true) const;
 129         PkgIterator NextPkg(PkgIterator const &Pkg) const;
 130
 131         // Constructors
 132         inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
 133                 if (S == 0)
 134                         S = OwnerPointer();
 135         }
 136         inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {}
 137
 138 };
 139                                                                         /*}}}*/
 140 // Package Iterator                                                     /*{{{*/
 141 class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
 142         long HashIndex;
 143
 144         protected:
 145         inline Package* OwnerPointer() const {
 146                 return (Owner != 0) ? Owner->PkgP : 0;
 147         }
 148
 149         public:
 150         // This constructor is the 'begin' constructor, never use it.
 151         inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
 152                 S = OwnerPointer();
 153                 operator ++(0);
 154         }
 155
 156         virtual void operator ++(int);
 157         virtual void operator ++() {operator ++(0);}
 158
 159         enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
 160
 161         // Accessors
 162         inline const char *Name() const { return Group().Name(); }
 163         // Versions have sections - and packages can have different versions with different sections
 164         // so this interface is broken by design. It used to return the section of the "first parsed
 165         // package stanza", but as this can potentially be anything it now returns the section of the
 166         // newest version instead (if any). aka: Run as fast as you can to Version.Section().
 167         APT_DEPRECATED 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         const char *CandVersion() const APT_PURE;
 179         const char *CurVersion() const APT_PURE;
 180
 181         //Nice printable representation
 182         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         protected:
 196         inline Version* OwnerPointer() const {
 197                 return (Owner != 0) ? Owner->VerP : 0;
 198         }
 199
 200         public:
 201         // Iteration
 202         void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;}
 203         inline void operator ++() {operator ++(0);}
 204
 205         // Comparison
 206         int CompareVer(const VerIterator &B) const;
 207         /** \brief compares two version and returns if they are similar
 208
 209             This method should be used to identify if two pseudo versions are
 210             referring to the same "real" version */
 211         inline bool SimilarVer(const VerIterator &B) const {
 212                 return (B.end() == false && S->Hash == B->Hash && strcmp(VerStr(), B.VerStr()) == 0);
 213         }
 214
 215         // Accessors
 216         inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;}
 217         inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;}
 218 #if APT_PKG_ABI >= 413
 219         /** \brief source package name this version comes from
 220            Always contains the name, even if it is the same as the binary name */
 221         inline const char *SourcePkgName() const {return Owner->StrP + S->SourcePkgName;}
 222         /** \brief source version this version comes from
 223            Always contains the version string, even if it is the same as the binary version */
 224         inline const char *SourceVerStr() const {return Owner->StrP + S->SourceVerStr;}
 225 #endif
 226         inline const char *Arch() const {
 227                 if ((S->MultiArch & pkgCache::Version::All) == pkgCache::Version::All)
 228                         return "all";
 229                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 230         }
 231         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 232
 233         inline DescIterator DescriptionList() const;
 234         DescIterator TranslatedDescription() const;
 235         inline DepIterator DependsList() const;
 236         inline PrvIterator ProvidesList() const;
 237         inline VerFileIterator FileList() const;
 238         bool Downloadable() const;
 239         inline const char *PriorityType() const {return Owner->Priority(S->Priority);}
 240         const char *MultiArchType() const APT_PURE;
 241         std::string RelStr() const;
 242
 243         bool Automatic() const;
 244         VerFileIterator NewestFile() const;
 245
 246         inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
 247                 if (S == 0)
 248                         S = OwnerPointer();
 249         }
 250         inline VerIterator() : Iterator<Version, VerIterator>() {}
 251 };
 252                                                                         /*}}}*/
 253 // Description Iterator                                                 /*{{{*/
 254 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 255         protected:
 256         inline Description* OwnerPointer() const {
 257                 return (Owner != 0) ? Owner->DescP : 0;
 258         }
 259
 260         public:
 261         // Iteration
 262         void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;}
 263         inline void operator ++() {operator ++(0);}
 264
 265         // Comparison
 266         int CompareDesc(const DescIterator &B) const;
 267
 268         // Accessors
 269         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;}
 270         inline const char *md5() const {return Owner->StrP + S->md5sum;}
 271         inline DescFileIterator FileList() const;
 272
 273         inline DescIterator() : Iterator<Description, DescIterator>() {}
 274         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 275                 if (S == 0)
 276                         S = Owner.DescP;
 277         }
 278 };
 279                                                                         /*}}}*/
 280 // Dependency iterator                                                  /*{{{*/
 281 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 282         enum {DepVer, DepRev} Type;
 283
 284         protected:
 285         inline Dependency* OwnerPointer() const {
 286                 return (Owner != 0) ? Owner->DepP : 0;
 287         }
 288
 289         public:
 290         // Iteration
 291         void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
 292                 (Type == DepVer ? S->NextDepends : S->NextRevDepends);}
 293         inline void operator ++() {operator ++(0);}
 294
 295         // Accessors
 296         inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;}
 297         inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->Package);}
 298         inline PkgIterator SmartTargetPkg() const {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;}
 299         inline VerIterator ParentVer() const {return VerIterator(*Owner,Owner->VerP + S->ParentVer);}
 300         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);}
 301         inline bool Reverse() const {return Type == DepRev;}
 302         bool IsCritical() const APT_PURE;
 303         bool IsNegative() const APT_PURE;
 304         bool IsIgnorable(PrvIterator const &Prv) const APT_PURE;
 305         bool IsIgnorable(PkgIterator const &Pkg) const APT_PURE;
 306         bool IsMultiArchImplicit() const APT_PURE;
 307         bool IsSatisfied(VerIterator const &Ver) const APT_PURE;
 308         bool IsSatisfied(PrvIterator const &Prv) const APT_PURE;
 309         void GlobOr(DepIterator &Start,DepIterator &End);
 310         Version **AllTargets() const;
 311         bool SmartTargetPkg(PkgIterator &Result) const;
 312         inline const char *CompType() const {return Owner->CompType(S->CompareOp);}
 313         inline const char *DepType() const {return Owner->DepType(S->Type);}
 314
 315         //Nice printable representation
 316         friend std::ostream& operator <<(std::ostream& out, DepIterator D);
 317
 318         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 319                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
 320                 if (S == 0)
 321                         S = Owner.DepP;
 322         }
 323         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 324                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
 325                 if (S == 0)
 326                         S = Owner.DepP;
 327         }
 328         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {}
 329 };
 330                                                                         /*}}}*/
 331 // Provides iterator                                                    /*{{{*/
 332 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 333         enum {PrvVer, PrvPkg} Type;
 334
 335         protected:
 336         inline Provides* OwnerPointer() const {
 337                 return (Owner != 0) ? Owner->ProvideP : 0;
 338         }
 339
 340         public:
 341         // Iteration
 342         void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
 343                 (Type == PrvVer?S->NextPkgProv:S->NextProvides);}
 344         inline void operator ++() {operator ++(0);}
 345
 346         // Accessors
 347         inline const char *Name() const {return ParentPkg().Name();}
 348         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;}
 349         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);}
 350         inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);}
 351         inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);}
 352
 353         bool IsMultiArchImplicit() const APT_PURE;
 354
 355         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {}
 356         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 357                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 358                 if (S == 0)
 359                         S = Owner.ProvideP;
 360         }
 361         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 362                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 363                 if (S == 0)
 364                         S = Owner.ProvideP;
 365         }
 366 };
 367                                                                         /*}}}*/
 368 // Package file                                                         /*{{{*/
 369 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 370         protected:
 371         inline PackageFile* OwnerPointer() const {
 372                 return (Owner != 0) ? Owner->PkgFileP : 0;
 373         }
 374
 375         public:
 376         // Iteration
 377         void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;}
 378         inline void operator ++() {operator ++(0);}
 379
 380         // Accessors
 381         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;}
 382         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;}
 383         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;}
 384         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;}
 385         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;}
 386         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;}
 387         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;}
 388         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;}
 389         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;}
 390         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;}
 391
 392         bool IsOk();
 393         std::string RelStr();
 394
 395         // Constructors
 396         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {}
 397         inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {}
 398         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {}
 399 };
 400                                                                         /*}}}*/
 401 // Version File                                                         /*{{{*/
 402 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 403         protected:
 404         inline VerFile* OwnerPointer() const {
 405                 return (Owner != 0) ? Owner->VerFileP : 0;
 406         }
 407
 408         public:
 409         // Iteration
 410         void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;}
 411         inline void operator ++() {operator ++(0);}
 412
 413         // Accessors
 414         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 415
 416         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {}
 417         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {}
 418 };
 419                                                                         /*}}}*/
 420 // Description File                                                     /*{{{*/
 421 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 422         protected:
 423         inline DescFile* OwnerPointer() const {
 424                 return (Owner != 0) ? Owner->DescFileP : 0;
 425         }
 426
 427         public:
 428         // Iteration
 429         void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;}
 430         inline void operator ++() {operator ++(0);}
 431
 432         // Accessors
 433         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);}
 434
 435         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {}
 436         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {}
 437 };
 438                                                                         /*}}}*/
 439 // Inlined Begin functions can't be in the class because of order problems /*{{{*/
 440 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 441        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);}
 442 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 443        {return VerIterator(*Owner,Owner->VerP + S->VersionList);}
 444 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 445        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);}
 446 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 447        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);}
 448 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 449        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 450 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 451        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);}
 452 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 453        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);}
 454 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 455        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);}
 456 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 457        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);}
 458 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 459        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);}
 460                                                                         /*}}}*/
 461 #endif