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 {
 182                 if(S->MultiArch == pkgCache::Version::All)
 183                         return "all";
 184                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 185         };
 186         inline const char *Arch(bool const pseudo) const {
 187                 if(pseudo == false)
 188                         return Arch();
 189                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 190         };
 191         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 192
 193         inline DescIterator DescriptionList() const;
 194         DescIterator TranslatedDescription() const;
 195         inline DepIterator DependsList() const;
 196         inline PrvIterator ProvidesList() const;
 197         inline VerFileIterator FileList() const;
 198         bool Downloadable() const;
 199         inline const char *PriorityType() {return Owner->Priority(S->Priority);};
 200         string RelStr();
 201
 202         bool Automatic() const;
 203         VerFileIterator NewestFile() const;
 204
 205         inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
 206                 if (S == 0)
 207                         S = OwnerPointer();
 208         };
 209         inline VerIterator() : Iterator<Version, VerIterator>() {};
 210 };
 211                                                                         /*}}}*/
 212 // Description Iterator                                                 /*{{{*/
 213 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 214         protected:
 215         inline Description* OwnerPointer() const {
 216                 return Owner->DescP;
 217         };
 218
 219         public:
 220         // Iteration
 221         void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
 222         inline void operator ++() {operator ++(0);};
 223
 224         // Comparison
 225         int CompareDesc(const DescIterator &B) const;
 226
 227         // Accessors
 228         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
 229         inline const char *md5() const {return Owner->StrP + S->md5sum;};
 230         inline DescFileIterator FileList() const;
 231
 232         inline DescIterator() : Iterator<Description, DescIterator>() {};
 233         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 234                 if (S == 0)
 235                         S = Owner.DescP;
 236         };
 237 };
 238                                                                         /*}}}*/
 239 // Dependency iterator                                                  /*{{{*/
 240 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 241         enum {DepVer, DepRev} Type;
 242
 243         protected:
 244         inline Dependency* OwnerPointer() const {
 245                 return Owner->DepP;
 246         };
 247
 248         public:
 249         // Iteration
 250         void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
 251                 (Type == DepVer ? S->NextDepends : S->NextRevDepends);};
 252         inline void operator ++() {operator ++(0);};
 253
 254         // Accessors
 255         inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 256         inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
 257         inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
 258         inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
 259         inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
 260         inline bool Reverse() {return Type == DepRev;};
 261         bool IsCritical();
 262         void GlobOr(DepIterator &Start,DepIterator &End);
 263         Version **AllTargets();
 264         bool SmartTargetPkg(PkgIterator &Result);
 265         inline const char *CompType() {return Owner->CompType(S->CompareOp);};
 266         inline const char *DepType() {return Owner->DepType(S->Type);};
 267
 268         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 269                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
 270                 if (S == 0)
 271                         S = Owner.DepP;
 272         };
 273         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 274                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
 275                 if (S == 0)
 276                         S = Owner.DepP;
 277         };
 278         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
 279 };
 280                                                                         /*}}}*/
 281 // Provides iterator                                                    /*{{{*/
 282 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 283         enum {PrvVer, PrvPkg} Type;
 284
 285         protected:
 286         inline Provides* OwnerPointer() const {
 287                 return Owner->ProvideP;
 288         };
 289
 290         public:
 291         // Iteration
 292         void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
 293                 (Type == PrvVer?S->NextPkgProv:S->NextProvides);};
 294         inline void operator ++() {operator ++(0);};
 295
 296         // Accessors
 297         inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
 298         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
 299         inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 300         inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + S->Version);};
 301         inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};
 302
 303         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
 304
 305         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 306                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 307                 if (S == 0)
 308                         S = Owner.ProvideP;
 309         };
 310         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 311                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 312                 if (S == 0)
 313                         S = Owner.ProvideP;
 314         };
 315 };
 316                                                                         /*}}}*/
 317 // Package file                                                         /*{{{*/
 318 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 319         protected:
 320         inline PackageFile* OwnerPointer() const {
 321                 return Owner->PkgFileP;
 322         };
 323
 324         public:
 325         // Iteration
 326         void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
 327         inline void operator ++() {operator ++(0);};
 328
 329         // Accessors
 330         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
 331         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
 332         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
 333         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 334         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
 335         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
 336         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
 337         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
 338         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
 339         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
 340
 341         bool IsOk();
 342         string RelStr();
 343
 344         // Constructors
 345         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
 346         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg = 0) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
 347 };
 348                                                                         /*}}}*/
 349 // Version File                                                         /*{{{*/
 350 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 351         protected:
 352         inline VerFile* OwnerPointer() const {
 353                 return Owner->VerFileP;
 354         };
 355
 356         public:
 357         // Iteration
 358         void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
 359         inline void operator ++() {operator ++(0);};
 360
 361         // Accessors
 362         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 363
 364         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
 365         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
 366 };
 367                                                                         /*}}}*/
 368 // Description File                                                     /*{{{*/
 369 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 370         protected:
 371         inline DescFile* OwnerPointer() const {
 372                 return Owner->DescFileP;
 373         };
 374
 375         public:
 376         // Iteration
 377         void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
 378         inline void operator ++() {operator ++(0);};
 379
 380         // Accessors
 381         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 382
 383         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
 384         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
 385 };
 386                                                                         /*}}}*/
 387 // Inlined Begin functions cant be in the class because of order problems /*{{{*/
 388 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 389        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);};
 390 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 391        {return VerIterator(*Owner,Owner->VerP + S->VersionList);};
 392 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 393        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
 394 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 395        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
 396 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 397        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 398 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 399        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
 400 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 401        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 402 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 403        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
 404 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 405        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
 406 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 407        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
 408                                                                         /*}}}*/
 409 #endif