apt-pkg/cacheiterators.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: cacheiterators.h,v 1.11 1998/12/14 08:07:28 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    bool Automatic() const;
 132    VerFileIterator NewestFile() const;
 133
 134    inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), Owner(Owner)
 135    {
 136       if (Ver == 0)
 137          Ver = Owner.VerP;
 138    };
 139 };
 140
 141 // Dependency iterator
 142 class pkgCache::DepIterator
 143 {
 144    Dependency *Dep;
 145    enum {DepVer, DepRev} Type;
 146    pkgCache *Owner;
 147
 148    void _dummy();
 149
 150    public:
 151
 152    // Iteration
 153    void operator ++(int) {if (Dep != Owner->DepP) Dep = Owner->DepP +
 154         (Type == DepVer?Dep->NextDepends:Dep->NextRevDepends);};
 155    inline void operator ++() {operator ++(0);};
 156    inline bool end() const {return Owner == 0 || Dep == Owner->DepP?true:false;};
 157
 158    // Comparison
 159    inline bool operator ==(const DepIterator &B) const {return Dep == B.Dep;};
 160    inline bool operator !=(const DepIterator &B) const {return Dep != B.Dep;};
 161
 162    // Accessors
 163    inline Dependency *operator ->() {return Dep;};
 164    inline Dependency const *operator ->() const {return Dep;};
 165    inline Dependency &operator *() {return *Dep;};
 166    inline Dependency const &operator *() const {return *Dep;};
 167    inline operator Dependency *() {return Dep == Owner->DepP?0:Dep;};
 168    inline operator Dependency const *() const {return Dep == Owner->DepP?0:Dep;};
 169
 170    inline const char *TargetVer() const {return Dep->Version == 0?0:Owner->StrP + Dep->Version;};
 171    inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + Dep->Package);};
 172    inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner);SmartTargetPkg(R);return R;};
 173    inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + Dep->ParentVer);};
 174    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
 175    inline bool Reverse() {return Type == DepRev;};
 176    inline unsigned long Index() const {return Dep - Owner->DepP;};
 177    bool IsCritical();
 178    void GlobOr(DepIterator &Start,DepIterator &End);
 179    Version **AllTargets();
 180    bool SmartTargetPkg(PkgIterator &Result);
 181    const char *CompType();
 182    const char *DepType();
 183
 184    inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
 185           Dep(Trg), Type(DepVer), Owner(&Owner)
 186    {
 187       if (Dep == 0)
 188          Dep = Owner.DepP;
 189    };
 190    inline DepIterator(pkgCache &Owner,Dependency *Trg,Package *) :
 191           Dep(Trg), Type(DepRev), Owner(&Owner)
 192    {
 193       if (Dep == 0)
 194          Dep = Owner.DepP;
 195    };
 196    inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
 197 };
 198
 199 // Provides iterator
 200 class pkgCache::PrvIterator
 201 {
 202    Provides *Prv;
 203    enum {PrvVer, PrvPkg} Type;
 204    pkgCache *Owner;
 205
 206    void _dummy();
 207
 208    public:
 209
 210    // Iteration
 211    void operator ++(int) {if (Prv != Owner->ProvideP) Prv = Owner->ProvideP +
 212         (Type == PrvVer?Prv->NextPkgProv:Prv->NextProvides);};
 213    inline void operator ++() {operator ++(0);};
 214    inline bool end() const {return Prv == Owner->ProvideP?true:false;};
 215
 216    // Comparison
 217    inline bool operator ==(const PrvIterator &B) const {return Prv == B.Prv;};
 218    inline bool operator !=(const PrvIterator &B) const {return Prv != B.Prv;};
 219
 220    // Accessors
 221    inline Provides *operator ->() {return Prv;};
 222    inline Provides const *operator ->() const {return Prv;};
 223    inline Provides &operator *() {return *Prv;};
 224    inline Provides const &operator *() const {return *Prv;};
 225    inline operator Provides *() {return Prv == Owner->ProvideP?0:Prv;};
 226    inline operator Provides const *() const {return Prv == Owner->ProvideP?0:Prv;};
 227
 228    inline const char *Name() const {return Owner->StrP + Owner->PkgP[Prv->ParentPkg].Name;};
 229    inline const char *ProvideVersion() const {return Prv->ProvideVersion == 0?0:Owner->StrP + Prv->ProvideVersion;};
 230    inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
 231    inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
 232    inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
 233    inline unsigned long Index() const {return Prv - Owner->ProvideP;};
 234
 235    inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
 236           Prv(Trg), Type(PrvVer), Owner(&Owner)
 237    {
 238       if (Prv == 0)
 239          Prv = Owner.ProvideP;
 240    };
 241    inline PrvIterator(pkgCache &Owner,Provides *Trg,Package *) :
 242           Prv(Trg), Type(PrvPkg), Owner(&Owner)
 243    {
 244       if (Prv == 0)
 245          Prv = Owner.ProvideP;
 246    };
 247 };
 248
 249 // Package file
 250 class pkgCache::PkgFileIterator
 251 {
 252    pkgCache *Owner;
 253    PackageFile *File;
 254
 255    public:
 256
 257    // Iteration
 258    void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
 259    inline void operator ++() {operator ++(0);};
 260    inline bool end() const {return File == Owner->PkgFileP?true:false;};
 261
 262    // Comparison
 263    inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
 264    inline bool operator !=(const PkgFileIterator &B) const {return File != B.File;};
 265
 266    // Accessors
 267    inline PackageFile *operator ->() {return File;};
 268    inline PackageFile const *operator ->() const {return File;};
 269    inline PackageFile const &operator *() const {return *File;};
 270    inline operator PackageFile *() {return File == Owner->PkgFileP?0:File;};
 271    inline operator PackageFile const *() const {return File == Owner->PkgFileP?0:File;};
 272
 273    inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
 274    inline const char *Archive() const {return File->Archive == 0?0:Owner->StrP + File->Archive;};
 275    inline const char *Component() const {return File->Component == 0?0:Owner->StrP + File->Component;};
 276    inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
 277    inline const char *Origin() const {return File->Origin == 0?0:Owner->StrP + File->Origin;};
 278    inline const char *Label() const {return File->Origin == 0?0:Owner->StrP + File->Label;};
 279    inline const char *Architecture() const {return File->Origin == 0?0:Owner->StrP + File->Architecture;};
 280
 281    inline unsigned long Index() const {return File - Owner->PkgFileP;};
 282
 283    bool IsOk();
 284
 285    // Constructors
 286    inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP + Owner.Head().FileList) {};
 287    inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
 288 };
 289
 290 // Version File
 291 class pkgCache::VerFileIterator
 292 {
 293    pkgCache *Owner;
 294    VerFile *FileP;
 295
 296    public:
 297
 298    // Iteration
 299    void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
 300    inline void operator ++() {operator ++(0);};
 301    inline bool end() const {return FileP == Owner->VerFileP?true:false;};
 302
 303    // Comparison
 304    inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
 305    inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
 306
 307    // Accessors
 308    inline VerFile *operator ->() {return FileP;};
 309    inline VerFile const *operator ->() const {return FileP;};
 310    inline VerFile const &operator *() const {return *FileP;};
 311    inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
 312    inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
 313
 314    inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
 315    inline unsigned long Index() const {return FileP - Owner->VerFileP;};
 316
 317    inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
 318 };
 319
 320 // Inlined Begin functions cant be in the class because of order problems
 321 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 322        {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
 323 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 324        {return VerIterator(*Owner,Owner->VerP + Pkg->CurrentVer);};
 325 inline pkgCache::VerIterator pkgCache::PkgIterator::TargetVer() const
 326        {return VerIterator(*Owner,Owner->VerP + Pkg->TargetVer);};
 327 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 328        {return DepIterator(*Owner,Owner->DepP + Pkg->RevDepends,Pkg);};
 329 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 330        {return PrvIterator(*Owner,Owner->ProvideP + Pkg->ProvidesList,Pkg);};
 331 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 332        {return PrvIterator(Owner,Owner.ProvideP + Ver->ProvidesList,Ver);};
 333 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 334        {return DepIterator(Owner,Owner.DepP + Ver->DependsList,Ver);};
 335 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 336        {return VerFileIterator(Owner,Owner.VerFileP + Ver->FileList);};
 337
 338 #endif