apt-pkg/cacheiterators.h

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