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