apt-pkg/cacheiterators.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4
   5    Cache Iterators - Iterators for navigating the cache structure
   6
   7    The iterators all provides ++,==,!=,->,* and end for their type.
   8    The end function can be used to tell if the list has been fully
   9    traversed.
  10
  11    Unlike STL iterators these contain helper functions to access the data
  12    that is being iterated over. This is because the data structures can't
  13    be formed in a manner that is intuitive to use and also mmapable.
  14
  15    For each variable in the target structure that would need a translation
  16    to be accessed correctly a translating function of the same name is
  17    present in the iterator. If applicable the translating function will
  18    return an iterator.
  19
  20    The DepIterator can iterate over two lists, a list of 'version depends'
  21    or a list of 'package reverse depends'. The type is determined by the
  22    structure passed to the constructor, which should be the structure
  23    that has the depends pointer as a member. The provide iterator has the
  24    same system.
  25
  26    This header is not user includable, please use apt-pkg/pkgcache.h
  27
  28    ##################################################################### */
  29                                                                         /*}}}*/
  30 #ifndef PKGLIB_CACHEITERATORS_H
  31 #define PKGLIB_CACHEITERATORS_H
  32 // abstract Iterator template                                           /*{{{*/
  33 /* This template provides the very basic iterator methods we
  34    need to have for doing some walk-over-the-cache magic, */
  35 template<typename Str, typename Itr> class pkgCache::Iterator {
  36         __attribute__ ((deprecated)) void _dummy(); // FIXME: Who on earth uses this method ???
  37
  38         protected:
  39         Str *S;
  40         pkgCache *Owner;
  41
  42         /** \brief Returns the Pointer for this struct in the owner
  43          *  The implementation of this method should be pretty short
  44          *  as it will only return the Pointer into the mmap stored
  45          *  in the owner but the name of this pointer is different for
  46          *  each stucture and we want to abstract here at least for the
  47          *  basic methods from the actual structure.
  48          *  \return Pointer to the first structure of this type
  49          */
  50         virtual Str* OwnerPointer() const = 0;
  51
  52         public:
  53         // Iteration
  54         virtual void operator ++(int) = 0;
  55         virtual void operator ++() = 0; // Should be {operator ++(0);};
  56         inline bool end() const {return Owner == 0 || S == OwnerPointer();};
  57
  58         // Comparison
  59         inline bool operator ==(const Itr &B) const {return S == B.S;};
  60         inline bool operator !=(const Itr &B) const {return S != B.S;};
  61
  62         // Accessors
  63         inline Str *operator ->() {return S;};
  64         inline Str const *operator ->() const {return S;};
  65         inline operator Str *() {return S == OwnerPointer() ? 0 : S;};
  66         inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;};
  67         inline Str const &operator *() const {return *S;};
  68         inline pkgCache *Cache() {return Owner;};
  69
  70         // Mixed stuff
  71         inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;};
  72         inline bool IsGood() const { return S && Owner && ! end();};
  73         inline unsigned long Index() const {return S - OwnerPointer();};
  74
  75         // Constructors - look out for the variable assigning
  76         inline Iterator() : S(0), Owner(0) {};
  77         inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {};
  78 };
  79                                                                         /*}}}*/
  80 // Package Iterator                                                     /*{{{*/
  81 class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
  82         long HashIndex;
  83
  84         protected:
  85         inline Package* OwnerPointer() const {
  86                 return Owner->PkgP;
  87         };
  88
  89         public:
  90         // This constructor is the 'begin' constructor, never use it.
  91         inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
  92                 S = OwnerPointer();
  93                 operator ++(0);
  94         };
  95
  96         virtual void operator ++(int);
  97         virtual void operator ++() {operator ++(0);};
  98
  99         enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
 100
 101         // Accessors
 102         inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
 103         inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
 104         inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
 105                 (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);};
 106
 107         inline VerIterator VersionList() const;
 108         inline VerIterator CurrentVer() const;
 109         inline DepIterator RevDependsList() const;
 110         inline PrvIterator ProvidesList() const;
 111         OkState State() const;
 112         const char *CandVersion() const;
 113         const char *CurVersion() const;
 114
 115         //Nice printable representation
 116         friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
 117
 118         // Constructors
 119         inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
 120                 if (S == 0)
 121                         S = OwnerPointer();
 122         };
 123         inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
 124 };
 125                                                                         /*}}}*/
 126 // Version Iterator                                                     /*{{{*/
 127 class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
 128         protected:
 129         inline Version* OwnerPointer() const {
 130                 return Owner->VerP;
 131         };
 132
 133         public:
 134         // Iteration
 135         void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
 136         inline void operator ++() {operator ++(0);};
 137
 138         // Comparison
 139         int CompareVer(const VerIterator &B) const;
 140
 141         // Accessors
 142         inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;};
 143         inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
 144         inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;};
 145         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 146
 147         inline DescIterator DescriptionList() const;
 148         DescIterator TranslatedDescription() const;
 149         inline DepIterator DependsList() const;
 150         inline PrvIterator ProvidesList() const;
 151         inline VerFileIterator FileList() const;
 152         bool Downloadable() const;
 153         inline const char *PriorityType() {return Owner->Priority(S->Priority);};
 154         string RelStr();
 155
 156         bool Automatic() const;
 157         VerFileIterator NewestFile() const;
 158
 159         inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
 160                 if (S == 0)
 161                         S = OwnerPointer();
 162         };
 163         inline VerIterator() : Iterator<Version, VerIterator>() {};
 164 };
 165                                                                         /*}}}*/
 166 // Description Iterator                                                 /*{{{*/
 167 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 168         protected:
 169         inline Description* OwnerPointer() const {
 170                 return Owner->DescP;
 171         };
 172
 173         public:
 174         // Iteration
 175         void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
 176         inline void operator ++() {operator ++(0);};
 177
 178         // Comparison
 179         int CompareDesc(const DescIterator &B) const;
 180
 181         // Accessors
 182         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
 183         inline const char *md5() const {return Owner->StrP + S->md5sum;};
 184         inline DescFileIterator FileList() const;
 185
 186         inline DescIterator() : Iterator<Description, DescIterator>() {};
 187         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 188                 if (S == 0)
 189                         S = Owner.DescP;
 190         };
 191 };
 192                                                                         /*}}}*/
 193 // Dependency iterator                                                  /*{{{*/
 194 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 195         enum {DepVer, DepRev} Type;
 196
 197         protected:
 198         inline Dependency* OwnerPointer() const {
 199                 return Owner->DepP;
 200         };
 201
 202         public:
 203         // Iteration
 204         void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
 205                 (Type == DepVer ? S->NextDepends : S->NextRevDepends);};
 206         inline void operator ++() {operator ++(0);};
 207
 208         // Accessors
 209         inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 210         inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
 211         inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
 212         inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
 213         inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
 214         inline bool Reverse() {return Type == DepRev;};
 215         bool IsCritical();
 216         void GlobOr(DepIterator &Start,DepIterator &End);
 217         Version **AllTargets();
 218         bool SmartTargetPkg(PkgIterator &Result);
 219         inline const char *CompType() {return Owner->CompType(S->CompareOp);};
 220         inline const char *DepType() {return Owner->DepType(S->Type);};
 221
 222         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 223                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
 224                 if (S == 0)
 225                         S = Owner.DepP;
 226         };
 227         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 228                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
 229                 if (S == 0)
 230                         S = Owner.DepP;
 231         };
 232         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
 233 };
 234                                                                         /*}}}*/
 235 // Provides iterator                                                    /*{{{*/
 236 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 237         enum {PrvVer, PrvPkg} Type;
 238
 239         protected:
 240         inline Provides* OwnerPointer() const {
 241                 return Owner->ProvideP;
 242         };
 243
 244         public:
 245         // Iteration
 246         void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
 247                 (Type == PrvVer?S->NextPkgProv:S->NextProvides);};
 248         inline void operator ++() {operator ++(0);};
 249
 250         // Accessors
 251         inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
 252         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
 253         inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 254         inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + S->Version);};
 255         inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};
 256
 257         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
 258
 259         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 260                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 261                 if (S == 0)
 262                         S = Owner.ProvideP;
 263         };
 264         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 265                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 266                 if (S == 0)
 267                         S = Owner.ProvideP;
 268         };
 269 };
 270                                                                         /*}}}*/
 271 // Package file                                                         /*{{{*/
 272 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 273         protected:
 274         inline PackageFile* OwnerPointer() const {
 275                 return Owner->PkgFileP;
 276         };
 277
 278         public:
 279         // Iteration
 280         void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
 281         inline void operator ++() {operator ++(0);};
 282
 283         // Accessors
 284         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
 285         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
 286         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
 287         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 288         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
 289         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
 290         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
 291         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
 292         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
 293         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
 294
 295         bool IsOk();
 296         string RelStr();
 297
 298         // Constructors
 299         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
 300         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg = 0) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
 301 };
 302                                                                         /*}}}*/
 303 // Version File                                                         /*{{{*/
 304 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 305         protected:
 306         inline VerFile* OwnerPointer() const {
 307                 return Owner->VerFileP;
 308         };
 309
 310         public:
 311         // Iteration
 312         void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
 313         inline void operator ++() {operator ++(0);};
 314
 315         // Accessors
 316         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 317
 318         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
 319         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
 320 };
 321                                                                         /*}}}*/
 322 // Description File                                                     /*{{{*/
 323 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 324         protected:
 325         inline DescFile* OwnerPointer() const {
 326                 return Owner->DescFileP;
 327         };
 328
 329         public:
 330         // Iteration
 331         void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
 332         inline void operator ++() {operator ++(0);};
 333
 334         // Accessors
 335         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 336
 337         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
 338         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
 339 };
 340                                                                         /*}}}*/
 341 // Inlined Begin functions cant be in the class because of order problems /*{{{*/
 342 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 343        {return VerIterator(*Owner,Owner->VerP + S->VersionList);};
 344 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 345        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
 346 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 347        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
 348 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 349        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 350 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 351        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
 352 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 353        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 354 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 355        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
 356 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 357        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
 358 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 359        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
 360                                                                         /*}}}*/
 361 #endif