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         protected:
  37         Str *S;
  38         pkgCache *Owner;
  39
  40         /** \brief Returns the Pointer for this struct in the owner
  41          *  The implementation of this method should be pretty short
  42          *  as it will only return the Pointer into the mmap stored
  43          *  in the owner but the name of this pointer is different for
  44          *  each stucture and we want to abstract here at least for the
  45          *  basic methods from the actual structure.
  46          *  \return Pointer to the first structure of this type
  47          */
  48         virtual Str* OwnerPointer() const = 0;
  49
  50         public:
  51         // Iteration
  52         virtual void operator ++(int) = 0;
  53         virtual void operator ++() = 0; // Should be {operator ++(0);};
  54         inline bool end() const {return Owner == 0 || S == OwnerPointer();};
  55
  56         // Comparison
  57         inline bool operator ==(const Itr &B) const {return S == B.S;};
  58         inline bool operator !=(const Itr &B) const {return S != B.S;};
  59
  60         // Accessors
  61         inline Str *operator ->() {return S;};
  62         inline Str const *operator ->() const {return S;};
  63         inline operator Str *() {return S == OwnerPointer() ? 0 : S;};
  64         inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;};
  65         inline Str const &operator *() const {return *S;};
  66         inline pkgCache *Cache() {return Owner;};
  67
  68         // Mixed stuff
  69         inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;};
  70         inline bool IsGood() const { return S && Owner && ! end();};
  71         inline unsigned long Index() const {return S - OwnerPointer();};
  72
  73         // Constructors - look out for the variable assigning
  74         inline Iterator() : S(0), Owner(0) {};
  75         inline Iterator(pkgCache &Owner,Str *T = 0) : S(T), Owner(&Owner) {};
  76 };
  77                                                                         /*}}}*/
  78 // Group Iterator                                                       /*{{{*/
  79 /* Packages with the same name are collected in a Group so someone only
  80    interest in package names can iterate easily over the names, so the
  81    different architectures can be treated as of the "same" package
  82    (apt internally treat them as totally different packages) */
  83 class pkgCache::GrpIterator: public Iterator<Group, GrpIterator> {
  84         long HashIndex;
  85
  86         protected:
  87         inline Group* OwnerPointer() const {
  88                 return Owner->GrpP;
  89         };
  90
  91         public:
  92         // This constructor is the 'begin' constructor, never use it.
  93         inline GrpIterator(pkgCache &Owner) : Iterator<Group, GrpIterator>(Owner), HashIndex(-1) {
  94                 S = OwnerPointer();
  95                 operator ++(0);
  96         };
  97
  98         virtual void operator ++(int);
  99         virtual void operator ++() {operator ++(0);};
 100
 101         inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
 102         inline PkgIterator PackageList() const;
 103         PkgIterator FindPkg(string Arch = "any");
 104         PkgIterator NextPkg(PkgIterator const &Pkg);
 105
 106         // Constructors
 107         inline GrpIterator(pkgCache &Owner, Group *Trg) : Iterator<Group, GrpIterator>(Owner, Trg), HashIndex(0) {
 108                 if (S == 0)
 109                         S = OwnerPointer();
 110         };
 111         inline GrpIterator() : Iterator<Group, GrpIterator>(), HashIndex(0) {};
 112
 113 };
 114                                                                         /*}}}*/
 115 // Package Iterator                                                     /*{{{*/
 116 class pkgCache::PkgIterator: public Iterator<Package, PkgIterator> {
 117         long HashIndex;
 118
 119         protected:
 120         inline Package* OwnerPointer() const {
 121                 return Owner->PkgP;
 122         };
 123
 124         public:
 125         // This constructor is the 'begin' constructor, never use it.
 126         inline PkgIterator(pkgCache &Owner) : Iterator<Package, PkgIterator>(Owner), HashIndex(-1) {
 127                 S = OwnerPointer();
 128                 operator ++(0);
 129         };
 130
 131         virtual void operator ++(int);
 132         virtual void operator ++() {operator ++(0);};
 133
 134         enum OkState {NeedsNothing,NeedsUnpack,NeedsConfigure};
 135
 136         // Accessors
 137         inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
 138         inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
 139         inline bool Purge() const {return S->CurrentState == pkgCache::State::Purge ||
 140                 (S->CurrentVer == 0 && S->CurrentState == pkgCache::State::NotInstalled);};
 141         inline const char *Arch() const {return S->Arch == 0?0:Owner->StrP + S->Arch;};
 142         inline GrpIterator Group() const { return GrpIterator(*Owner, Owner->GrpP + S->Group);};
 143
 144         inline VerIterator VersionList() const;
 145         inline VerIterator CurrentVer() const;
 146         inline DepIterator RevDependsList() const;
 147         inline PrvIterator ProvidesList() const;
 148         OkState State() const;
 149         const char *CandVersion() const;
 150         const char *CurVersion() const;
 151
 152         //Nice printable representation
 153         friend std::ostream& operator <<(std::ostream& out, PkgIterator i);
 154
 155         // Constructors
 156         inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
 157                 if (S == 0)
 158                         S = OwnerPointer();
 159         };
 160         inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
 161 };
 162                                                                         /*}}}*/
 163 // Version Iterator                                                     /*{{{*/
 164 class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
 165         protected:
 166         inline Version* OwnerPointer() const {
 167                 return Owner->VerP;
 168         };
 169
 170         public:
 171         // Iteration
 172         void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
 173         inline void operator ++() {operator ++(0);};
 174
 175         // Comparison
 176         int CompareVer(const VerIterator &B) const;
 177
 178         // Accessors
 179         inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;};
 180         inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
 181         inline const char *Arch() const {
 182                 if(S->MultiArch == pkgCache::Version::All)
 183                         return "all";
 184                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 185         };
 186         inline const char *Arch(bool const pseudo) const {
 187                 if(pseudo == false)
 188                         return Arch();
 189                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 190         };
 191         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 192
 193         inline DescIterator DescriptionList() const;
 194         DescIterator TranslatedDescription() const;
 195         inline DepIterator DependsList() const;
 196         inline PrvIterator ProvidesList() const;
 197         inline VerFileIterator FileList() const;
 198         bool Downloadable() const;
 199         inline const char *PriorityType() {return Owner->Priority(S->Priority);};
 200         string RelStr();
 201
 202         bool Automatic() const;
 203         bool Pseudo() const;
 204         VerFileIterator NewestFile() const;
 205
 206         inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
 207                 if (S == 0)
 208                         S = OwnerPointer();
 209         };
 210         inline VerIterator() : Iterator<Version, VerIterator>() {};
 211 };
 212                                                                         /*}}}*/
 213 // Description Iterator                                                 /*{{{*/
 214 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 215         protected:
 216         inline Description* OwnerPointer() const {
 217                 return Owner->DescP;
 218         };
 219
 220         public:
 221         // Iteration
 222         void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
 223         inline void operator ++() {operator ++(0);};
 224
 225         // Comparison
 226         int CompareDesc(const DescIterator &B) const;
 227
 228         // Accessors
 229         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
 230         inline const char *md5() const {return Owner->StrP + S->md5sum;};
 231         inline DescFileIterator FileList() const;
 232
 233         inline DescIterator() : Iterator<Description, DescIterator>() {};
 234         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 235                 if (S == 0)
 236                         S = Owner.DescP;
 237         };
 238 };
 239                                                                         /*}}}*/
 240 // Dependency iterator                                                  /*{{{*/
 241 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 242         enum {DepVer, DepRev} Type;
 243
 244         protected:
 245         inline Dependency* OwnerPointer() const {
 246                 return Owner->DepP;
 247         };
 248
 249         public:
 250         // Iteration
 251         void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
 252                 (Type == DepVer ? S->NextDepends : S->NextRevDepends);};
 253         inline void operator ++() {operator ++(0);};
 254
 255         // Accessors
 256         inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 257         inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
 258         inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
 259         inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
 260         inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
 261         inline bool Reverse() {return Type == DepRev;};
 262         bool IsCritical();
 263         void GlobOr(DepIterator &Start,DepIterator &End);
 264         Version **AllTargets();
 265         bool SmartTargetPkg(PkgIterator &Result);
 266         inline const char *CompType() {return Owner->CompType(S->CompareOp);};
 267         inline const char *DepType() {return Owner->DepType(S->Type);};
 268
 269         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 270                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
 271                 if (S == 0)
 272                         S = Owner.DepP;
 273         };
 274         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 275                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
 276                 if (S == 0)
 277                         S = Owner.DepP;
 278         };
 279         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
 280 };
 281                                                                         /*}}}*/
 282 // Provides iterator                                                    /*{{{*/
 283 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 284         enum {PrvVer, PrvPkg} Type;
 285
 286         protected:
 287         inline Provides* OwnerPointer() const {
 288                 return Owner->ProvideP;
 289         };
 290
 291         public:
 292         // Iteration
 293         void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
 294                 (Type == PrvVer?S->NextPkgProv:S->NextProvides);};
 295         inline void operator ++() {operator ++(0);};
 296
 297         // Accessors
 298         inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
 299         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
 300         inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 301         inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + S->Version);};
 302         inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};
 303
 304         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
 305
 306         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 307                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 308                 if (S == 0)
 309                         S = Owner.ProvideP;
 310         };
 311         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 312                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 313                 if (S == 0)
 314                         S = Owner.ProvideP;
 315         };
 316 };
 317                                                                         /*}}}*/
 318 // Package file                                                         /*{{{*/
 319 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 320         protected:
 321         inline PackageFile* OwnerPointer() const {
 322                 return Owner->PkgFileP;
 323         };
 324
 325         public:
 326         // Iteration
 327         void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
 328         inline void operator ++() {operator ++(0);};
 329
 330         // Accessors
 331         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
 332         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
 333         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
 334         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 335         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
 336         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
 337         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
 338         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
 339         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
 340         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
 341
 342         bool IsOk();
 343         string RelStr();
 344
 345         // Constructors
 346         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
 347         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg = 0) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
 348 };
 349                                                                         /*}}}*/
 350 // Version File                                                         /*{{{*/
 351 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 352         protected:
 353         inline VerFile* OwnerPointer() const {
 354                 return Owner->VerFileP;
 355         };
 356
 357         public:
 358         // Iteration
 359         void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
 360         inline void operator ++() {operator ++(0);};
 361
 362         // Accessors
 363         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 364
 365         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
 366         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
 367 };
 368                                                                         /*}}}*/
 369 // Description File                                                     /*{{{*/
 370 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 371         protected:
 372         inline DescFile* OwnerPointer() const {
 373                 return Owner->DescFileP;
 374         };
 375
 376         public:
 377         // Iteration
 378         void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
 379         inline void operator ++() {operator ++(0);};
 380
 381         // Accessors
 382         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 383
 384         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
 385         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
 386 };
 387                                                                         /*}}}*/
 388 // Inlined Begin functions cant be in the class because of order problems /*{{{*/
 389 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 390        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);};
 391 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 392        {return VerIterator(*Owner,Owner->VerP + S->VersionList);};
 393 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 394        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
 395 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 396        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
 397 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 398        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 399 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 400        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
 401 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 402        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 403 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 404        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
 405 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 406        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
 407 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 408        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
 409                                                                         /*}}}*/
 410 #endif