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