apt-pkg/cacheiterators.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: cacheiterators.h,v 1.9 1998/11/27 00:07:23 jgg 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 // Header section: pkglib
  32 #ifndef PKGLIB_CACHEITERATORS_H
  33 #define PKGLIB_CACHEITERATORS_H
  34
  35 #ifdef __GNUG__
  36 #pragma interface "apt-pkg/cacheiterators.h"
  37 #endif
  38
  39 // Package Iterator
  40 class pkgCache::PkgIterator
  41 {
  42    Package *Pkg;
  43    pkgCache *Owner;
  44    long HashIndex;
  45
  46    public:
  47
  48    enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
  49
  50    // Iteration
  51    void operator ++(int);
  52    inline void operator ++() {operator ++(0);};
  53    inline bool end() const {return Owner == 0 || Pkg == Owner->PkgP?true:false;};
  54
  55    // Comparison
  56    inline bool operator ==(const PkgIterator &B) const {return Pkg == B.Pkg;};
  57    inline bool operator !=(const PkgIterator &B) const {return Pkg != B.Pkg;};
  58
  59    // Accessors
  60    inline Package *operator ->() {return Pkg;};
  61    inline Package const *operator ->() const {return Pkg;};
  62    inline Package const &operator *() const {return *Pkg;};
  63    inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
  64    inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
  65
  66    inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
  67    inline const char *Section() const {return Pkg->Section == 0?0:Owner->StrP + Pkg->Section;};
  68    inline const char *TargetDist() const {return Pkg->TargetDist == 0?0:Owner->StrP + Pkg->TargetDist;};
  69    inline VerIterator VersionList() const;
  70    inline VerIterator TargetVer() const;
  71    inline VerIterator CurrentVer() const;
  72    inline DepIterator RevDependsList() const;
  73    inline PrvIterator ProvidesList() const;
  74    inline unsigned long Index() const {return Pkg - Owner->PkgP;};
  75    OkState State() const;
  76
  77    // Constructors
  78    inline PkgIterator(pkgCache &Owner) : Owner(&Owner), HashIndex(-1)
  79    {
  80       Pkg = Owner.PkgP;
  81       operator ++(0);
  82    };
  83    inline PkgIterator(pkgCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner),
  84           HashIndex(0)
  85    {
  86       if (Pkg == 0)
  87          Pkg = Owner.PkgP;
  88    };
  89    inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
  90 };
  91
  92 // Version Iterator
  93 class pkgCache::VerIterator
  94 {
  95    Version *Ver;
  96    pkgCache &Owner;
  97
  98    void _dummy();
  99
 100    public:
 101
 102    // Iteration
 103    void operator ++(int) {if (Ver != Owner.VerP) Ver = Owner.VerP + Ver->NextVer;};
 104    inline void operator ++() {operator ++(0);};
 105    inline bool end() const {return Ver == Owner.VerP?true:false;};
 106    inline void operator =(const VerIterator &B) {Ver = B.Ver;};
 107
 108    // Comparison
 109    inline bool operator ==(const VerIterator &B) const {return Ver == B.Ver;};
 110    inline bool operator !=(const VerIterator &B) const {return Ver != B.Ver;};
 111    int CompareVer(const VerIterator &B) const;
 112
 113    // Accessors
 114    inline Version *operator ->() {return Ver;};
 115    inline Version const *operator ->() const {return Ver;};
 116    inline Version &operator *() {return *Ver;};
 117    inline Version const &operator *() const {return *Ver;};
 118    inline operator Version *() {return Ver == Owner.VerP?0:Ver;};
 119    inline operator Version const *() const {return Ver == Owner.VerP?0:Ver;};
 120
 121    inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner.StrP + Ver->VerStr;};
 122    inline const char *Section() const {return Ver->Section == 0?0:Owner.StrP + Ver->Section;};
 123    inline PkgIterator ParentPkg() const {return PkgIterator(Owner,Owner.PkgP + Ver->ParentPkg);};
 124    inline DepIterator DependsList() const;
 125    inline PrvIterator ProvidesList() const;
 126    inline VerFileIterator FileList() const;
 127    inline unsigned long Index() const {return Ver - Owner.VerP;};
 128    bool Downloadable() const;
 129    const char *PriorityType();
 130
 131    inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), Owner(Owner)
 132    {
 133       if (Ver == 0)
 134          Ver = Owner.VerP;
 135    };
 136 };
 137
 138 // Dependency iterator
 139 class pkgCache::DepIterator
 140 {
 141    Dependency *Dep;
 142    enum {DepVer, DepRev} Type;
 143    pkgCache *Owner;
 144
 145    void _dummy();
 146
 147    public:
 148
 149    // Iteration
 150    void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
 151         (Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
 152    inline void operator ++() {operator ++(0);};
 153    inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
 154
 155    // Comparison
 156    inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
 157    inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
 158
 159    // Accessors
 160    inline Dependency *operator ->() {return Dep;};
 161    inline Dependency const *operator ->() const {return Dep;};
 162    inline Dependency &operator *() {return *Dep;};
 163    inline Dependency const &operator *() const {return *Dep;};
 164    inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
 165    inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
 166
 167    inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
 168    inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
 169    inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner);SmartTargetPkg(R);return R;};
 170    inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
 171    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
 172    inline bool Reverse() {return Type == DepRev;};
 173    inline unsigned long Index() const {return Dep - Owner->DepP;};
 174    bool IsCritical();
 175    void GlobOr(DepIterator &Start,DepIterator &End);
 176    Version **AllTargets();
 177    bool SmartTargetPkg(PkgIterator &Result);
 178    const char *CompType();
 179    const char *DepType();
 180
 181    inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
 182           Dep(Trg), Type(DepVer), Owner(&Owner)
 183    {
 184       if (Dep == 0)
 185          Dep = Owner.DepP;
 186    };
 187    inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
 188           Dep(Trg), Type(DepRev), Owner(&Owner)
 189    {
 190       if (Dep == 0)
 191          Dep = Owner.DepP;
 192    };
 193    inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
 194 };
 195
 196 // Provides iterator
 197 class pkgCache::PrvIterator
 198 {
 199    Provides *Prv;
 200    enum {PrvVer, PrvPkg} Type;
 201    pkgCache *Owner;
 202
 203    void _dummy();
 204
 205    public:
 206
 207    // Iteration
 208    void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
 209         (Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
 210    inline void operator ++() {operator ++(0);};
 211    inline bool end() const {return Prv == Owner->ProvideP?true:false;};
 212
 213    // Comparison
 214    inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
 215    inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
 216
 217    // Accessors
 218    inline Provides *operator ->() {return Prv;};
 219    inline Provides const *operator ->() const {return Prv;};
 220    inline Provides &operator *() {return *Prv;};
 221    inline Provides const &operator *() const {return *Prv;};
 222    inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
 223    inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
 224
 225    inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
 226    inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
 227    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
 228    inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
 229    inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
 230    inline unsigned long Index() const {return Prv - Owner->ProvideP;};
 231
 232    inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
 233           Prv(Trg), Type(PrvVer), Owner(&Owner)
 234    {
 235       if (Prv == 0)
 236          Prv = Owner.ProvideP;
 237    };
 238    inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) :
 239           Prv(Trg), Type(PrvPkg), Owner(&Owner)
 240    {
 241       if (Prv == 0)
 242          Prv = Owner.ProvideP;
 243    };
 244 };
 245
 246 // Package file
 247 class pkgCache::PkgFileIterator
 248 {
 249    pkgCache *Owner;
 250    PackageFile *File;
 251
 252    public:
 253
 254    // Iteration
 255    void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
 256    inline void operator ++() {operator ++(0);};
 257    inline bool end() const {return File == Owner->PkgFileP?true:false;};
 258
 259    // Comparison
 260    inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
 261    inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
 262
 263    // Accessors
 264    inline PackageFile *operator ->() {return File;};
 265    inline PackageFile const *operator ->() const {return File;};
 266    inline PackageFile const &operator *() const {return *File;};
 267    inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
 268    inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
 269
 270    inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
 271    inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
 272    inline const char *Distribution() const {return File->Distribution == 0?0:Owner->StrP + File->Distribution;};
 273    inline unsigned long Index() const {return File - Owner->PkgFileP;};
 274
 275    bool IsOk();
 276
 277    // Constructors
 278    inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP + Owner.Head().FileList) {};
 279    inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
 280 };
 281
 282 // Version File
 283 class pkgCache::VerFileIterator
 284 {
 285    pkgCache *Owner;
 286    VerFile *FileP;
 287
 288    public:
 289
 290    // Iteration
 291    void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
 292    inline void operator ++() {operator ++(0);};
 293    inline bool end() const {return FileP == Owner->VerFileP?true:false;};
 294
 295    // Comparison
 296    inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
 297    inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
 298
 299    // Accessors
 300    inline VerFile *operator ->() {return FileP;};
 301    inline VerFile const *operator ->() const {return FileP;};
 302    inline VerFile const &operator *() const {return *FileP;};
 303    inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
 304    inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
 305
 306    inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
 307    inline unsigned long Index() const {return FileP - Owner->VerFileP;};
 308
 309    inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
 310 };
 311
 312 // Inlined Begin functions cant be in the class because of order problems
 313 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 314        {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
 315 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 316        {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
 317 inline pkgCache::VerIterator pkgCache::PkgIterator::TargetVer() const
 318        {return VerIterator(*Owner,Owner->VerP + Pkg->TargetVer);};
 319 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 320        {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
 321 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 322        {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
 323 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 324        {return PrvIterator(Owner,Owner.ProvideP + Ver->ProvidesList,Ver);};
 325 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 326        {return DepIterator(Owner,Owner.DepP + Ver->DependsList,Ver);};
 327 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 328        {return VerFileIterator(Owner,Owner.VerFileP + Ver->FileList);};
 329
 330 #endif