apt-pkg/cacheiterators.h

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