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    // Constructors
  85    inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
  86           HashIndex(0)
  87    {
  88       if (Pkg == 0)
  89          Pkg = Owner.PkgP;
  90    };
  91    inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
  92 };
  93
  94 // Version Iterator
  95 class pkgCache::VerIterator
  96 {
  97    Version *Ver;
  98    pkgCache *Owner;
  99
 100    void _dummy();
 101
 102    public:
 103
 104    // Iteration
 105    void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
 106    inline void operator ++() {operator ++(0);};
 107    inline bool end() const {return Owner == NULL || (Ver == Owner->VerP?true:false);};
 108    inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
 109
 110    // Comparison
 111    inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
 112    inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
 113    int CompareVer(const VerIterator &B) const;
 114
 115    // Accessors
 116    inline Version *operator ->() {return Ver;};
 117    inline Version const *operator ->() const {return Ver;};
 118    inline Version &operator *() {return *Ver;};
 119    inline Version const &operator *() const {return *Ver;};
 120    inline operator Version *() {return Ver == Owner->VerP?0:Ver;};
 121    inline operator Version const *() const {return Ver == Owner->VerP?0:Ver;};
 122    inline pkgCache *Cache() {return Owner;};
 123
 124    inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner->StrP + Ver->VerStr;};
 125    inline const char *Section() const {return Ver->Section == 0?0:Owner->StrP + Ver->Section;};
 126    inline const char *Arch() const {return Ver->Arch == 0?0:Owner->StrP + Ver->Arch;};
 127    inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + Ver->ParentPkg);};
 128    inline DescIterator DescriptionList() const;
 129    DescIterator TranslatedDescription() const;
 130    inline DepIterator DependsList() const;
 131    inline PrvIterator ProvidesList() const;
 132    inline VerFileIterator FileList() const;
 133    inline unsigned long Index() const {return Ver - Owner->VerP;};
 134    bool Downloadable() const;
 135    inline const char *PriorityType() {return Owner->Priority(Ver->Priority);};
 136    string RelStr();
 137
 138    bool Automatic() const;
 139    VerFileIterator NewestFile() const;
 140
 141    inline VerIterator() : Ver(0), Owner(0) {};
 142    inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg),
 143               Owner(&Owner)
 144    {
 145       if (Ver == 0)
 146          Ver = Owner.VerP;
 147    };
 148 };
 149
 150 // Description Iterator
 151 class pkgCache::DescIterator
 152 {
 153    Description *Desc;
 154    pkgCache *Owner;
 155
 156    void _dummy();
 157
 158    public:
 159
 160    // Iteration
 161    void operator ++(int) {if (Desc != Owner->DescP) Desc = Owner->DescP + Desc->NextDesc;};
 162    inline void operator ++() {operator ++(0);};
 163    inline bool end() const {return Desc == Owner->DescP?true:false;};
 164    inline void operator =(const DescIterator &B) {Desc = B.Desc; Owner = B.Owner;};
 165
 166    // Comparison
 167    inline bool operator ==(const DescIterator &B) const {return Desc == B.Desc;};
 168    inline bool operator !=(const DescIterator &B) const {return Desc != B.Desc;};
 169    int CompareDesc(const DescIterator &B) const;
 170
 171    // Accessors
 172    inline Description *operator ->() {return Desc;};
 173    inline Description const *operator ->() const {return Desc;};
 174    inline Description &operator *() {return *Desc;};
 175    inline Description const &operator *() const {return *Desc;};
 176    inline operator Description *() {return Desc == Owner->DescP?0:Desc;};
 177    inline operator Description const *() const {return Desc == Owner->DescP?0:Desc;};
 178    inline pkgCache *Cache() {return Owner;};
 179
 180    inline const char *LanguageCode() const {return Owner->StrP + Desc->language_code;};
 181    inline const char *md5() const {return Owner->StrP + Desc->md5sum;};
 182    inline DescFileIterator FileList() const;
 183    inline unsigned long Index() const {return Desc - Owner->DescP;};
 184
 185    inline DescIterator() : Desc(0), Owner(0) {};
 186    inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Desc(Trg),
 187               Owner(&Owner)
 188    {
 189       if (Desc == 0)
 190          Desc = Owner.DescP;
 191    };
 192 };
 193
 194 // Dependency iterator
 195 class pkgCache::DepIterator
 196 {
 197    Dependency *Dep;
 198    enum {DepVer, DepRev} Type;
 199    pkgCache *Owner;
 200
 201    void _dummy();
 202
 203    public:
 204
 205    // Iteration
 206    void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
 207         (Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
 208    inline void operator ++() {operator ++(0);};
 209    inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
 210
 211    // Comparison
 212    inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
 213    inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
 214
 215    // Accessors
 216    inline Dependency *operator ->() {return Dep;};
 217    inline Dependency const *operator ->() const {return Dep;};
 218    inline Dependency &operator *() {return *Dep;};
 219    inline Dependency const &operator *() const {return *Dep;};
 220    inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
 221    inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
 222    inline pkgCache *Cache() {return Owner;};
 223
 224    inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
 225    inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
 226    inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
 227    inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
 228    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
 229    inline bool Reverse() {return Type == DepRev;};
 230    inline unsigned long Index() const {return Dep - Owner->DepP;};
 231    bool IsCritical();
 232    void GlobOr(DepIterator &Start,DepIterator &End);
 233    Version **AllTargets();
 234    bool SmartTargetPkg(PkgIterator &Result);
 235    inline const char *CompType() {return Owner->CompType(Dep->CompareOp);};
 236    inline const char *DepType() {return Owner->DepType(Dep->Type);};
 237
 238    inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
 239           Dep(Trg), Type(DepVer), Owner(&Owner)
 240    {
 241       if (Dep == 0)
 242          Dep = Owner.DepP;
 243    };
 244    inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
 245           Dep(Trg), Type(DepRev), Owner(&Owner)
 246    {
 247       if (Dep == 0)
 248          Dep = Owner.DepP;
 249    };
 250    inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
 251 };
 252
 253 // Provides iterator
 254 class pkgCache::PrvIterator
 255 {
 256    Provides *Prv;
 257    enum {PrvVer, PrvPkg} Type;
 258    pkgCache *Owner;
 259
 260    void _dummy();
 261
 262    public:
 263
 264    // Iteration
 265    void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
 266         (Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
 267    inline void operator ++() {operator ++(0);};
 268    inline bool end() const {return Owner == 0 || Prv == Owner->ProvideP?true:false;};
 269
 270    // Comparison
 271    inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
 272    inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
 273
 274    // Accessors
 275    inline Provides *operator ->() {return Prv;};
 276    inline Provides const *operator ->() const {return Prv;};
 277    inline Provides &operator *() {return *Prv;};
 278    inline Provides const &operator *() const {return *Prv;};
 279    inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
 280    inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
 281    inline pkgCache *Cache() {return Owner;};
 282
 283    inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
 284    inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
 285    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
 286    inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
 287    inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
 288    inline unsigned long Index() const {return Prv - Owner->ProvideP;};
 289
 290    inline PrvIterator() : Prv(0), Type(PrvVer), Owner(0)  {};
 291
 292    inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
 293           Prv(Trg), Type(PrvVer), Owner(&Owner)
 294    {
 295       if (Prv == 0)
 296          Prv = Owner.ProvideP;
 297    };
 298    inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) :
 299           Prv(Trg), Type(PrvPkg), Owner(&Owner)
 300    {
 301       if (Prv == 0)
 302          Prv = Owner.ProvideP;
 303    };
 304 };
 305
 306 // Package file
 307 class pkgCache::PkgFileIterator
 308 {
 309    pkgCache *Owner;
 310    PackageFile *File;
 311
 312    public:
 313
 314    // Iteration
 315    void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
 316    inline void operator ++() {operator ++(0);};
 317    inline bool end() const {return File == Owner->PkgFileP?true:false;};
 318
 319    // Comparison
 320    inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
 321    inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
 322
 323    // Accessors
 324    inline PackageFile *operator ->() {return File;};
 325    inline PackageFile const *operator ->() const {return File;};
 326    inline PackageFile const &operator *() const {return *File;};
 327    inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
 328    inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
 329    inline pkgCache *Cache() {return Owner;};
 330
 331    inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
 332    inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
 333    inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
 334    inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
 335    inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
 336    inline const char *Codename() const {return File->Codename ==0?0:Owner->StrP + File->Codename;};
 337    inline const char *Label() const {return File->Label == 0?0:Owner->StrP + File->Label;};
 338    inline const char *Site() const {return File->Site == 0?0:Owner->StrP + File->Site;};
 339    inline const char *Architecture() const {return File->Architecture == 0?0:Owner->StrP + File->Architecture;};
 340    inline const char *IndexType() const {return File->IndexType == 0?0:Owner->StrP + File->IndexType;};
 341
 342    inline unsigned long Index() const {return File - Owner->PkgFileP;};
 343
 344    bool IsOk();
 345    string RelStr();
 346
 347    // Constructors
 348    inline PkgFileIterator() : Owner(0), File(0) {};
 349    inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
 350    inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
 351 };
 352
 353 // Version File
 354 class pkgCache::VerFileIterator
 355 {
 356    pkgCache *Owner;
 357    VerFile *FileP;
 358
 359    public:
 360
 361    // Iteration
 362    void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
 363    inline void operator ++() {operator ++(0);};
 364    inline bool end() const {return FileP == Owner->VerFileP?true:false;};
 365
 366    // Comparison
 367    inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
 368    inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
 369
 370    // Accessors
 371    inline VerFile *operator ->() {return FileP;};
 372    inline VerFile const *operator ->() const {return FileP;};
 373    inline VerFile const &operator *() const {return *FileP;};
 374    inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
 375    inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
 376    inline pkgCache *Cache() {return Owner;};
 377
 378    inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
 379    inline unsigned long Index() const {return FileP - Owner->VerFileP;};
 380
 381    inline VerFileIterator() : Owner(0), FileP(0) {};
 382    inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
 383 };
 384
 385 // Description File
 386 class pkgCache::DescFileIterator
 387 {
 388    pkgCache *Owner;
 389    DescFile *FileP;
 390
 391    public:
 392
 393    // Iteration
 394    void operator ++(int) {if (FileP != Owner->DescFileP) FileP = Owner->DescFileP + FileP->NextFile;};
 395    inline void operator ++() {operator ++(0);};
 396    inline bool end() const {return FileP == Owner->DescFileP?true:false;};
 397
 398    // Comparison
 399    inline bool operator ==(const DescFileIterator &B) const {return FileP == B.FileP;};
 400    inline bool operator !=(const DescFileIterator &B) const {return FileP != B.FileP;};
 401
 402    // Accessors
 403    inline DescFile *operator ->() {return FileP;};
 404    inline DescFile const *operator ->() const {return FileP;};
 405    inline DescFile const &operator *() const {return *FileP;};
 406    inline operator DescFile *() {return FileP == Owner->DescFileP?0:FileP;};
 407    inline operator DescFile const *() const {return FileP == Owner->DescFileP?0:FileP;};
 408    inline pkgCache *Cache() {return Owner;};
 409
 410    inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
 411    inline unsigned long Index() const {return FileP - Owner->DescFileP;};
 412
 413    inline DescFileIterator() : Owner(0), FileP(0) {};
 414    inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Owner(&Owner), FileP(Trg) {};
 415 };
 416
 417 // Inlined Begin functions cant be in the class because of order problems
 418 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 419        {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
 420 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 421        {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
 422 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 423        {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
 424 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 425        {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
 426 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 427        {return DescIterator(*Owner,Owner->DescP + Ver->DescriptionList);};
 428 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 429        {return PrvIterator(*Owner,Owner->ProvideP + Ver->ProvidesList,Ver);};
 430 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 431        {return DepIterator(*Owner,Owner->DepP + Ver->DependsList,Ver);};
 432 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 433        {return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);};
 434 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 435        {return DescFileIterator(*Owner,Owner->DescFileP + Desc->FileList);};
 436
 437 #endif