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<iterator>
  33
  34 #include<string.h>
  35 // abstract Iterator template                                           /*{{{*/
  36 /* This template provides the very basic iterator methods we
  37    need to have for doing some walk-over-the-cache magic */
  38 template<typename Str, typename Itr> class pkgCache::Iterator :
  39                         public std::iterator<std::forward_iterator_tag, Str> {
  40         protected:
  41         Str *S;
  42         pkgCache *Owner;
  43
  44         /** \brief Returns the Pointer for this struct in the owner
  45          *  The implementation of this method should be pretty short
  46          *  as it will only return the Pointer into the mmap stored
  47          *  in the owner but the name of this pointer is different for
  48          *  each stucture and we want to abstract here at least for the
  49          *  basic methods from the actual structure.
  50          *  \return Pointer to the first structure of this type
  51          */
  52         virtual Str* OwnerPointer() const = 0;
  53
  54         public:
  55         // Iteration
  56         virtual void operator ++(int) = 0;
  57         virtual void operator ++() = 0; // Should be {operator ++(0);};
  58         inline bool end() const {return Owner == 0 || S == OwnerPointer();};
  59
  60         // Comparison
  61         inline bool operator ==(const Itr &B) const {return S == B.S;};
  62         inline bool operator !=(const Itr &B) const {return S != B.S;};
  63
  64         // Accessors
  65         inline Str *operator ->() {return S;};
  66         inline Str const *operator ->() const {return S;};
  67         inline operator Str *() {return S == OwnerPointer() ? 0 : S;};
  68         inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;};
  69         inline Str &operator *() {return *S;};
  70         inline Str const &operator *() const {return *S;};
  71         inline pkgCache *Cache() const {return Owner;};
  72
  73         // Mixed stuff
  74         inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;};
  75         inline bool IsGood() const { return S && Owner && ! end();};
  76         inline unsigned long Index() const {return S - OwnerPointer();};
  77
  78         void ReMap(void const * const oldMap, void const * const newMap) {
  79                 if (Owner == 0 || S == 0)
  80                         return;
  81                 S += (Str*)(newMap) - (Str*)(oldMap);
  82         }
  83
  84         // Constructors - look out for the variable assigning
  85         inline Iterator() : S(0), Owner(0) {};
  86         inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {};
  87 };
  88                                                                         /*}}}*/
  89 // Group Iterator                                                       /*{{{*/
  90 /* Packages with the same name are collected in a Group so someone only
  91    interest in package names can iterate easily over the names, so the
  92    different architectures can be treated as of the "same" package
  93    (apt internally treat them as totally different packages) */
  94 class pkgCache::GrpIterator: public Iterator<Group, GrpIterator> {
  95         long HashIndex;
  96
  97         protected:
  98         inline Group* OwnerPointer() const {
  99                 return (Owner != 0) ? Owner->GrpP : 0;
 100         };
 101
 102         public:
 103         // This constructor is the 'begin' constructor, never use it.
 104         inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
 105                 S = OwnerPointer();
 106                 operator ++(0);
 107         };
 108
 109         virtual void operator ++(int);
 110         virtual void operator ++() {operator ++(0);};
 111
 112         inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
 113         inline PkgIterator PackageList() const;
 114         PkgIterator FindPkg(string Arch = "any") const;
 115         /** \brief find the package with the "best" architecture
 116
 117             The best architecture is either the "native" or the first
 118             in the list of Architectures which is not an end-Pointer
 119
 120             \param PreferNonVirtual tries to respond with a non-virtual package
 121                    and only if this fails returns the best virtual package */
 122         PkgIterator FindPreferredPkg(bool const &PreferNonVirtual = true) const;
 123         PkgIterator NextPkg(PkgIterator const &Pkg) const;
 124
 125         // Constructors
 126         inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
 127                 if (S == 0)
 128                         S = OwnerPointer();
 129         };
 130         inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {};
 131
 132 };
 133                                                                         /*}}}*/
 134 // Package Iterator                                                     /*{{{*/
 135 class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
 136         long HashIndex;
 137
 138         protected:
 139         inline Package* OwnerPointer() const {
 140                 return (Owner != 0) ? Owner->PkgP : 0;
 141         };
 142
 143         public:
 144         // This constructor is the 'begin' constructor, never use it.
 145         inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
 146                 S = OwnerPointer();
 147                 operator ++(0);
 148         };
 149
 150         virtual void operator ++(int);
 151         virtual void operator ++() {operator ++(0);};
 152
 153         enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
 154
 155         // Accessors
 156         inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
 157         inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
 158         inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
 159                 (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);};
 160         inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;};
 161         inline GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);};
 162
 163         inline VerIterator VersionList() const;
 164         inline VerIterator CurrentVer() const;
 165         inline DepIterator RevDependsList() const;
 166         inline PrvIterator ProvidesList() const;
 167         OkState State() const;
 168         const char *CandVersion() const;
 169         const char *CurVersion() const;
 170
 171         //Nice printable representation
 172         friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
 173         std::string FullName(bool const &Pretty = false) const;
 174
 175         // Constructors
 176         inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
 177                 if (S == 0)
 178                         S = OwnerPointer();
 179         };
 180         inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
 181 };
 182                                                                         /*}}}*/
 183 // Version Iterator                                                     /*{{{*/
 184 class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
 185         protected:
 186         inline Version* OwnerPointer() const {
 187                 return (Owner != 0) ? Owner->VerP : 0;
 188         };
 189
 190         public:
 191         // Iteration
 192         void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
 193         inline void operator ++() {operator ++(0);};
 194
 195         // Comparison
 196         int CompareVer(const VerIterator &B) const;
 197         /** \brief compares two version and returns if they are similar
 198
 199             This method should be used to identify if two pseudo versions are
 200             refering to the same "real" version */
 201         inline bool SimilarVer(const VerIterator &B) const {
 202                 return (B.end() == false && S->Hash == B->Hash && strcmp(VerStr(), B.VerStr()) == 0);
 203         };
 204
 205         // Accessors
 206         inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;};
 207         inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
 208         inline const char *Arch() const {
 209                 if (S->MultiArch == pkgCache::Version::All ||
 210                     S->MultiArch == pkgCache::Version::AllForeign ||
 211                     S->MultiArch == pkgCache::Version::AllAllowed)
 212                         return "all";
 213                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 214         };
 215         __deprecated inline const char *Arch(bool const pseudo) const {
 216                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 217         };
 218         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 219
 220         inline DescIterator DescriptionList() const;
 221         DescIterator TranslatedDescription() const;
 222         inline DepIterator DependsList() const;
 223         inline PrvIterator ProvidesList() const;
 224         inline VerFileIterator FileList() const;
 225         bool Downloadable() const;
 226         inline const char *PriorityType() const {return Owner->Priority(S->Priority);};
 227         string RelStr() const;
 228
 229         bool Automatic() const;
 230         __deprecated bool Pseudo() const;
 231         VerFileIterator NewestFile() const;
 232
 233         inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
 234                 if (S == 0)
 235                         S = OwnerPointer();
 236         };
 237         inline VerIterator() : Iterator<Version, VerIterator>() {};
 238 };
 239                                                                         /*}}}*/
 240 // Description Iterator                                                 /*{{{*/
 241 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 242         protected:
 243         inline Description* OwnerPointer() const {
 244                 return (Owner != 0) ? Owner->DescP : 0;
 245         };
 246
 247         public:
 248         // Iteration
 249         void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
 250         inline void operator ++() {operator ++(0);};
 251
 252         // Comparison
 253         int CompareDesc(const DescIterator &B) const;
 254
 255         // Accessors
 256         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
 257         inline const char *md5() const {return Owner->StrP + S->md5sum;};
 258         inline DescFileIterator FileList() const;
 259
 260         inline DescIterator() : Iterator<Description, DescIterator>() {};
 261         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 262                 if (S == 0)
 263                         S = Owner.DescP;
 264         };
 265 };
 266                                                                         /*}}}*/
 267 // Dependency iterator                                                  /*{{{*/
 268 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 269         enum {DepVer, DepRev} Type;
 270
 271         protected:
 272         inline Dependency* OwnerPointer() const {
 273                 return (Owner != 0) ? Owner->DepP : 0;
 274         };
 275
 276         public:
 277         // Iteration
 278         void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
 279                 (Type == DepVer ? S->NextDepends : S->NextRevDepends);};
 280         inline void operator ++() {operator ++(0);};
 281
 282         // Accessors
 283         inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 284         inline PkgIterator TargetPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
 285         inline PkgIterator SmartTargetPkg() const {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
 286         inline VerIterator ParentVer() const {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
 287         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
 288         inline bool Reverse() const {return Type == DepRev;};
 289         bool IsCritical() const;
 290         bool IsNegative() const;
 291         void GlobOr(DepIterator &Start,DepIterator &End);
 292         Version **AllTargets() const;
 293         bool SmartTargetPkg(PkgIterator &Result) const;
 294         inline const char *CompType() const {return Owner->CompType(S->CompareOp);};
 295         inline const char *DepType() const {return Owner->DepType(S->Type);};
 296
 297         //Nice printable representation
 298         friend std::ostream& operator <<(std::ostream& out, DepIterator D);
 299
 300         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 301                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
 302                 if (S == 0)
 303                         S = Owner.DepP;
 304         };
 305         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 306                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
 307                 if (S == 0)
 308                         S = Owner.DepP;
 309         };
 310         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
 311 };
 312                                                                         /*}}}*/
 313 // Provides iterator                                                    /*{{{*/
 314 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 315         enum {PrvVer, PrvPkg} Type;
 316
 317         protected:
 318         inline Provides* OwnerPointer() const {
 319                 return (Owner != 0) ? Owner->ProvideP : 0;
 320         };
 321
 322         public:
 323         // Iteration
 324         void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
 325                 (Type == PrvVer?S->NextPkgProv:S->NextProvides);};
 326         inline void operator ++() {operator ++(0);};
 327
 328         // Accessors
 329         inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
 330         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
 331         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 332         inline VerIterator OwnerVer() const {return VerIterator(*Owner,Owner->VerP + S->Version);};
 333         inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};
 334
 335         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
 336
 337         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 338                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 339                 if (S == 0)
 340                         S = Owner.ProvideP;
 341         };
 342         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 343                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 344                 if (S == 0)
 345                         S = Owner.ProvideP;
 346         };
 347 };
 348                                                                         /*}}}*/
 349 // Package file                                                         /*{{{*/
 350 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 351         protected:
 352         inline PackageFile* OwnerPointer() const {
 353                 return (Owner != 0) ? Owner->PkgFileP : 0;
 354         };
 355
 356         public:
 357         // Iteration
 358         void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
 359         inline void operator ++() {operator ++(0);};
 360
 361         // Accessors
 362         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
 363         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
 364         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
 365         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 366         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
 367         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
 368         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
 369         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
 370         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
 371         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
 372
 373         bool IsOk();
 374         string RelStr();
 375
 376         // Constructors
 377         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
 378         inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {};
 379         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
 380 };
 381                                                                         /*}}}*/
 382 // Version File                                                         /*{{{*/
 383 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 384         protected:
 385         inline VerFile* OwnerPointer() const {
 386                 return (Owner != 0) ? Owner->VerFileP : 0;
 387         };
 388
 389         public:
 390         // Iteration
 391         void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
 392         inline void operator ++() {operator ++(0);};
 393
 394         // Accessors
 395         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 396
 397         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
 398         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
 399 };
 400                                                                         /*}}}*/
 401 // Description File                                                     /*{{{*/
 402 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 403         protected:
 404         inline DescFile* OwnerPointer() const {
 405                 return (Owner != 0) ? Owner->DescFileP : 0;
 406         };
 407
 408         public:
 409         // Iteration
 410         void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + 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 DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
 417         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
 418 };
 419                                                                         /*}}}*/
 420 // Inlined Begin functions cant be in the class because of order problems /*{{{*/
 421 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 422        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);};
 423 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 424        {return VerIterator(*Owner,Owner->VerP + S->VersionList);};
 425 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 426        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
 427 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 428        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
 429 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 430        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 431 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 432        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
 433 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 434        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 435 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 436        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
 437 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 438        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
 439 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 440        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
 441                                                                         /*}}}*/
 442 #endif