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