apt-pkg/cacheiterators.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: cacheiterators.h,v 1.18.2.1 2004/05/08 22:44:27 mdz Exp $
   4 /* ######################################################################
   5
   6    Cache Iterators - Iterators for navigating the cache structure
   7
   8    The iterators all provides ++,==,!=,->,* and end for their type.
   9    The end function can be used to tell if the list has been fully
  10    traversed.
  11
  12    Unlike STL iterators these contain helper functions to access the data
  13    that is being iterated over. This is because the data structures can't
  14    be formed in a manner that is intuitive to use and also mmapable.
  15
  16    For each variable in the target structure that would need a translation
  17    to be accessed correctly a translating function of the same name is
  18    present in the iterator. If applicable the translating function will
  19    return an iterator.
  20
  21    The DepIterator can iterate over two lists, a list of 'version depends'
  22    or a list of 'package reverse depends'. The type is determined by the
  23    structure passed to the constructor, which should be the structure
  24    that has the depends pointer as a member. The provide iterator has the
  25    same system.
  26
  27    This header is not user includable, please use apt-pkg/pkgcache.h
  28
  29    ##################################################################### */
  30                                                                         /*}}}*/
  31 #ifndef PKGLIB_CACHEITERATORS_H
  32 #define PKGLIB_CACHEITERATORS_H
  33
  34
  35 // Package Iterator                                                     /*{{{*/
  36 class pkgCache::PkgIterator
  37 {
  38    friend class pkgCache;
  39    Package *Pkg;
  40    pkgCache *Owner;
  41    long HashIndex;
  42
  43    protected:
  44
  45    // This constructor is the 'begin' constructor, never use it.
  46    inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
  47    {
  48       Pkg = Owner.PkgP;
  49       operator ++(0);
  50    };
  51
  52    public:
  53
  54    enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
  55
  56    // Iteration
  57    void operator ++(int);
  58    inline void operator ++() {operator ++(0);};
  59    inline bool end() const {return Owner == 0 || Pkg == Owner->PkgP?true:false;};
  60
  61    // Comparison
  62    inline bool operator ==(const PkgIterator &B) const {return Pkg == B.Pkg;};
  63    inline bool operator !=(const PkgIterator &B) const {return Pkg != B.Pkg;};
  64
  65    // Accessors
  66    inline Package *operator ->() {return Pkg;};
  67    inline Package const *operator ->() const {return Pkg;};
  68    inline Package const &operator *() const {return *Pkg;};
  69    inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
  70    inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
  71    inline pkgCache *Cache() {return Owner;};
  72
  73    inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
  74    inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
  75    inline bool Purge() const {return Pkg->CurrentState == pkgCache::State::Purge ||
  76          (Pkg->CurrentVer == 0 && Pkg->CurrentState == pkgCache::State::NotInstalled);};
  77    inline VerIterator VersionList() const;
  78    inline VerIterator CurrentVer() const;
  79    inline DepIterator RevDependsList() const;
  80    inline PrvIterator ProvidesList() const;
  81    inline unsigned long Index() const {return Pkg - Owner->PkgP;};
  82    OkState State() const;
  83
  84    //Nice printable representation
  85    friend std::ostream& operator<<(std::ostream& out, pkgCache::PkgIterator Pkg);
  86
  87    const char *CandVersion() const;
  88    const char *CurVersion() const;
  89
  90    // Constructors
  91    inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
  92           HashIndex(0)
  93    {
  94       if (Pkg == 0)
  95          Pkg = Owner.PkgP;
  96    };
  97    inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
  98 };
  99                                                                         /*}}}*/
 100 // Version Iterator                                                     /*{{{*/
 101 class pkgCache::VerIterator
 102 {
 103    Version *Ver;
 104    pkgCache *Owner;
 105
 106    void _dummy();
 107
 108    public:
 109
 110    // Iteration
 111    void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
 112    inline void operator ++() {operator ++(0);};
 113    inline bool end() const {return Owner == 0 || (Ver == Owner->VerP?true:false);};
 114    inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
 115
 116    // Comparison
 117    inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
 118    inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
 119    int CompareVer(const VerIterator &B) const;
 120
 121    // Testing
 122    inline bool IsGood() const { return Ver && Owner && ! end();};
 123
 124    // Accessors
 125    inline Version *operator ->() {return Ver;};
 126    inline Version const *operator ->() const {return Ver;};
 127    inline Version &operator *() {return *Ver;};
 128    inline Version const &operator *() const {return *Ver;};
 129    inline operator Version *() {return Ver == Owner->VerP?0:Ver;};
 130    inline operator Version const *() const {return Ver == Owner->VerP?0:Ver;};
 131    inline pkgCache *Cache() {return Owner;};
 132
 133    inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner->StrP + Ver->VerStr;};
 134    inline const char *Section() const {return Ver->Section == 0?0:Owner->StrP + Ver->Section;};
 135    inline const char *Arch() const {return Ver->Arch == 0?0:Owner->StrP + Ver->Arch;};
 136    inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Ver->ParentPkg);};
 137    inline DescIterator DescriptionList() const;
 138    DescIterator TranslatedDescription() const;
 139    inline DepIterator DependsList() const;
 140    inline PrvIterator ProvidesList() const;
 141    inline VerFileIterator FileList() const;
 142    inline unsigned long Index() const {return Ver - Owner->VerP;};
 143    bool Downloadable() const;
 144    inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
 145    string RelStr();
 146
 147    bool Automatic() const;
 148    VerFileIterator NewestFile() const;
 149
 150    inline VerIterator() : Ver(0), Owner(0) {};
 151    inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg),
 152               Owner(&Owner)
 153    {
 154       if (Ver == 0)
 155          Ver = Owner.VerP;
 156    };
 157 };
 158                                                                         /*}}}*/
 159 // Description Iterator                                                 /*{{{*/
 160 class pkgCache::DescIterator
 161 {
 162    Description *Desc;
 163    pkgCache *Owner;
 164
 165    void _dummy();
 166
 167    public:
 168
 169    // Iteration
 170    void operator ++(int) {if (Desc != Owner->DescP) Desc = Owner->DescP + Desc->NextDesc;};
 171    inline void operator ++() {operator ++(0);};
 172    inline bool end() const {return Owner == 0 || Desc == Owner->DescP?true:false;};
 173    inline void operator =(const DescIterator &B) {Desc = B.Desc; Owner = B.Owner;};
 174
 175    // Comparison
 176    inline bool operator ==(const DescIterator &B) const {return Desc == B.Desc;};
 177    inline bool operator !=(const DescIterator &B) const {return Desc != B.Desc;};
 178    int CompareDesc(const DescIterator &B) const;
 179
 180    // Accessors
 181    inline Description *operator ->() {return Desc;};
 182    inline Description const *operator ->() const {return Desc;};
 183    inline Description &operator *() {return *Desc;};
 184    inline Description const &operator *() const {return *Desc;};
 185    inline operator Description *() {return Desc == Owner->DescP?0:Desc;};
 186    inline operator Description const *() const {return Desc == Owner->DescP?0:Desc;};
 187    inline pkgCache *Cache() {return Owner;};
 188
 189    inline const char *LanguageCode() const {return Owner->StrP + Desc->language_code;};
 190    inline const char *md5() const {return Owner->StrP + Desc->md5sum;};
 191    inline DescFileIterator FileList() const;
 192    inline unsigned long Index() const {return Desc - Owner->DescP;};
 193
 194    inline DescIterator() : Desc(0), Owner(0) {};
 195    inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Desc(Trg),
 196               Owner(&Owner)
 197    {
 198       if (Desc == 0)
 199          Desc = Owner.DescP;
 200    };
 201 };
 202                                                                         /*}}}*/
 203 // Dependency iterator                                                  /*{{{*/
 204 class pkgCache::DepIterator
 205 {
 206    Dependency *Dep;
 207    enum {DepVer, DepRev} Type;
 208    pkgCache *Owner;
 209
 210    void _dummy();
 211
 212    public:
 213
 214    // Iteration
 215    void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
 216         (Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
 217    inline void operator ++() {operator ++(0);};
 218    inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
 219
 220    // Comparison
 221    inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
 222    inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
 223
 224    // Accessors
 225    inline Dependency *operator ->() {return Dep;};
 226    inline Dependency const *operator ->() const {return Dep;};
 227    inline Dependency &operator *() {return *Dep;};
 228    inline Dependency const &operator *() const {return *Dep;};
 229    inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
 230    inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
 231    inline pkgCache *Cache() {return Owner;};
 232
 233    inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
 234    inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
 235    inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
 236    inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
 237    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
 238    inline bool Reverse() {return Type == DepRev;};
 239    inline unsigned long Index() const {return Dep - Owner->DepP;};
 240    bool IsCritical();
 241    void GlobOr(DepIterator &Start,DepIterator &End);
 242    Version **AllTargets();
 243    bool SmartTargetPkg(PkgIterator &Result);
 244    inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
 245    inline const char *DepType() {return Owner->DepType(Dep->Type);};
 246
 247    inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
 248           Dep(Trg), Type(DepVer), Owner(&Owner)
 249    {
 250       if (Dep == 0)
 251          Dep = Owner.DepP;
 252    };
 253    inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
 254           Dep(Trg), Type(DepRev), Owner(&Owner)
 255    {
 256       if (Dep == 0)
 257          Dep = Owner.DepP;
 258    };
 259    inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
 260 };
 261                                                                         /*}}}*/
 262 // Provides iterator                                                    /*{{{*/
 263 class pkgCache::PrvIterator
 264 {
 265    Provides *Prv;
 266    enum {PrvVer, PrvPkg} Type;
 267    pkgCache *Owner;
 268
 269    void _dummy();
 270
 271    public:
 272
 273    // Iteration
 274    void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
 275         (Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
 276    inline void operator ++() {operator ++(0);};
 277    inline bool end() const {return Owner == 0 || Prv == Owner->ProvideP?true:false;};
 278
 279    // Comparison
 280    inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
 281    inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
 282
 283    // Accessors
 284    inline Provides *operator ->() {return Prv;};
 285    inline Provides const *operator ->() const {return Prv;};
 286    inline Provides &operator *() {return *Prv;};
 287    inline Provides const &operator *() const {return *Prv;};
 288    inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
 289    inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
 290    inline pkgCache *Cache() {return Owner;};
 291
 292    inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
 293    inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
 294    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
 295    inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
 296    inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
 297    inline unsigned long Index() const {return Prv - Owner->ProvideP;};
 298
 299    inline PrvIterator() : Prv(0), Type(PrvVer), Owner(0)  {};
 300
 301    inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
 302           Prv(Trg), Type(PrvVer), Owner(&Owner)
 303    {
 304       if (Prv == 0)
 305          Prv = Owner.ProvideP;
 306    };
 307    inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) :
 308           Prv(Trg), Type(PrvPkg), Owner(&Owner)
 309    {
 310       if (Prv == 0)
 311          Prv = Owner.ProvideP;
 312    };
 313 };
 314                                                                         /*}}}*/
 315 // Package file                                                         /*{{{*/
 316 class pkgCache::PkgFileIterator
 317 {
 318    pkgCache *Owner;
 319    PackageFile *File;
 320
 321    public:
 322
 323    // Iteration
 324    void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
 325    inline void operator ++() {operator ++(0);};
 326    inline bool end() const {return Owner == 0 || File == Owner->PkgFileP?true:false;};
 327
 328    // Comparison
 329    inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
 330    inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
 331
 332    // Accessors
 333    inline PackageFile *operator ->() {return File;};
 334    inline PackageFile const *operator ->() const {return File;};
 335    inline PackageFile const &operator *() const {return *File;};
 336    inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
 337    inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
 338    inline pkgCache *Cache() {return Owner;};
 339
 340    inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
 341    inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
 342    inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
 343    inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
 344    inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
 345    inline const char *Codename() const {return File->Codename ==0?0:Owner->StrP + File->Codename;};
 346    inline const char *Label() const {return File->Label == 0?0:Owner->StrP + File->Label;};
 347    inline const char *Site() const {return File->Site == 0?0:Owner->StrP + File->Site;};
 348    inline const char *Architecture() const {return File->Architecture == 0?0:Owner->StrP + File->Architecture;};
 349    inline const char *IndexType() const {return File->IndexType == 0?0:Owner->StrP + File->IndexType;};
 350
 351    inline unsigned long Index() const {return File - Owner->PkgFileP;};
 352
 353    bool IsOk();
 354    string RelStr();
 355
 356    // Constructors
 357    inline PkgFileIterator() : Owner(0), File(0) {};
 358    inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
 359    inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
 360 };
 361                                                                         /*}}}*/
 362 // Version File                                                         /*{{{*/
 363 class pkgCache::VerFileIterator
 364 {
 365    pkgCache *Owner;
 366    VerFile *FileP;
 367
 368    public:
 369
 370    // Iteration
 371    void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
 372    inline void operator ++() {operator ++(0);};
 373    inline bool end() const {return Owner == 0 || FileP == Owner->VerFileP?true:false;};
 374
 375    // Comparison
 376    inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
 377    inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
 378
 379    // Accessors
 380    inline VerFile *operator ->() {return FileP;};
 381    inline VerFile const *operator ->() const {return FileP;};
 382    inline VerFile const &operator *() const {return *FileP;};
 383    inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
 384    inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
 385    inline pkgCache *Cache() {return Owner;};
 386
 387    inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
 388    inline unsigned long Index() const {return FileP - Owner->VerFileP;};
 389
 390    inline VerFileIterator() : Owner(0), FileP(0) {};
 391    inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
 392 };
 393                                                                         /*}}}*/
 394 // Description File                                                     /*{{{*/
 395 class pkgCache::DescFileIterator
 396 {
 397    pkgCache *Owner;
 398    DescFile *FileP;
 399
 400    public:
 401
 402    // Iteration
 403    void operator ++(int) {if (FileP != Owner->DescFileP) FileP = Owner->DescFileP + FileP->NextFile;};
 404    inline void operator ++() {operator ++(0);};
 405    inline bool end() const {return Owner == 0 ||  FileP == Owner->DescFileP?true:false;};
 406
 407    // Comparison
 408    inline bool operator ==(const DescFileIterator &B) const {return FileP == B.FileP;};
 409    inline bool operator !=(const DescFileIterator &B) const {return FileP != B.FileP;};
 410
 411    // Accessors
 412    inline DescFile *operator ->() {return FileP;};
 413    inline DescFile const *operator ->() const {return FileP;};
 414    inline DescFile const &operator *() const {return *FileP;};
 415    inline operator DescFile *() {return FileP == Owner->DescFileP?0:FileP;};
 416    inline operator DescFile const *() const {return FileP == Owner->DescFileP?0:FileP;};
 417    inline pkgCache *Cache() {return Owner;};
 418
 419    inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
 420    inline unsigned long Index() const {return FileP - Owner->DescFileP;};
 421
 422    inline DescFileIterator() : Owner(0), FileP(0) {};
 423    inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Owner(&Owner), FileP(Trg) {};
 424 };
 425                                                                         /*}}}*/
 426 // Inlined Begin functions cant be in the class because of order problems /*{{{*/
 427 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 428        {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
 429 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 430        {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
 431 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 432        {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
 433 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 434        {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
 435 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 436        {return DescIterator(*Owner,Owner->DescP + Ver->DescriptionList);};
 437 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 438        {return PrvIterator(*Owner,Owner->ProvideP + Ver->ProvidesList,Ver);};
 439 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 440        {return DepIterator(*Owner,Owner->DepP + Ver->DependsList,Ver);};
 441 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 442        {return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);};
 443 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 444        {return DescFileIterator(*Owner,Owner->DescFileP + Desc->FileList);};
 445                                                                         /*}}}*/
 446 #endif