apt-pkg/cacheiterators.h

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