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         std::string FullName(bool const &Pretty = false) const;
 155
 156         // Constructors
 157         inline PkgIterator(pkgCache &Owner,Package *Trg) : Iterator<Package, PkgIterator>(Owner, Trg), HashIndex(0) {
 158                 if (S == 0)
 159                         S = OwnerPointer();
 160         };
 161         inline PkgIterator() : Iterator<Package, PkgIterator>(), HashIndex(0) {};
 162 };
 163                                                                         /*}}}*/
 164 // Version Iterator                                                     /*{{{*/
 165 class pkgCache::VerIterator : public Iterator<Version, VerIterator> {
 166         protected:
 167         inline Version* OwnerPointer() const {
 168                 return Owner->VerP;
 169         };
 170
 171         public:
 172         // Iteration
 173         void operator ++(int) {if (S != Owner->VerP) S = Owner->VerP + S->NextVer;};
 174         inline void operator ++() {operator ++(0);};
 175
 176         // Comparison
 177         int CompareVer(const VerIterator &B) const;
 178
 179         // Accessors
 180         inline const char *VerStr() const {return S->VerStr == 0?0:Owner->StrP + S->VerStr;};
 181         inline const char *Section() const {return S->Section == 0?0:Owner->StrP + S->Section;};
 182         inline const char *Arch() const {
 183                 if(S->MultiArch == pkgCache::Version::All)
 184                         return "all";
 185                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 186         };
 187         inline const char *Arch(bool const pseudo) const {
 188                 if(pseudo == false)
 189                         return Arch();
 190                 return S->ParentPkg == 0?0:Owner->StrP + ParentPkg()->Arch;
 191         };
 192         inline PkgIterator ParentPkg() const {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 193
 194         inline DescIterator DescriptionList() const;
 195         DescIterator TranslatedDescription() const;
 196         inline DepIterator DependsList() const;
 197         inline PrvIterator ProvidesList() const;
 198         inline VerFileIterator FileList() const;
 199         bool Downloadable() const;
 200         inline const char *PriorityType() {return Owner->Priority(S->Priority);};
 201         string RelStr();
 202
 203         bool Automatic() const;
 204         bool Pseudo() const;
 205         VerFileIterator NewestFile() const;
 206
 207         inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Iterator<Version, VerIterator>(Owner, Trg) {
 208                 if (S == 0)
 209                         S = OwnerPointer();
 210         };
 211         inline VerIterator() : Iterator<Version, VerIterator>() {};
 212 };
 213                                                                         /*}}}*/
 214 // Description Iterator                                                 /*{{{*/
 215 class pkgCache::DescIterator : public Iterator<Description, DescIterator> {
 216         protected:
 217         inline Description* OwnerPointer() const {
 218                 return Owner->DescP;
 219         };
 220
 221         public:
 222         // Iteration
 223         void operator ++(int) {if (S != Owner->DescP) S = Owner->DescP + S->NextDesc;};
 224         inline void operator ++() {operator ++(0);};
 225
 226         // Comparison
 227         int CompareDesc(const DescIterator &B) const;
 228
 229         // Accessors
 230         inline const char *LanguageCode() const {return Owner->StrP + S->language_code;};
 231         inline const char *md5() const {return Owner->StrP + S->md5sum;};
 232         inline DescFileIterator FileList() const;
 233
 234         inline DescIterator() : Iterator<Description, DescIterator>() {};
 235         inline DescIterator(pkgCache &Owner,Description *Trg = 0) : Iterator<Description, DescIterator>(Owner, Trg) {
 236                 if (S == 0)
 237                         S = Owner.DescP;
 238         };
 239 };
 240                                                                         /*}}}*/
 241 // Dependency iterator                                                  /*{{{*/
 242 class pkgCache::DepIterator : public Iterator<Dependency, DepIterator> {
 243         enum {DepVer, DepRev} Type;
 244
 245         protected:
 246         inline Dependency* OwnerPointer() const {
 247                 return Owner->DepP;
 248         };
 249
 250         public:
 251         // Iteration
 252         void operator ++(int) {if (S != Owner->DepP) S = Owner->DepP +
 253                 (Type == DepVer ? S->NextDepends : S->NextRevDepends);};
 254         inline void operator ++() {operator ++(0);};
 255
 256         // Accessors
 257         inline const char *TargetVer() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 258         inline PkgIterator TargetPkg() {return PkgIterator(*Owner,Owner->PkgP + S->Package);};
 259         inline PkgIterator SmartTargetPkg() {PkgIterator R(*Owner,0);SmartTargetPkg(R);return R;};
 260         inline VerIterator ParentVer() {return VerIterator(*Owner,Owner->VerP + S->ParentVer);};
 261         inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->ParentVer].ParentPkg);};
 262         inline bool Reverse() {return Type == DepRev;};
 263         bool IsCritical();
 264         void GlobOr(DepIterator &Start,DepIterator &End);
 265         Version **AllTargets();
 266         bool SmartTargetPkg(PkgIterator &Result);
 267         inline const char *CompType() {return Owner->CompType(S->CompareOp);};
 268         inline const char *DepType() {return Owner->DepType(S->Type);};
 269
 270         inline DepIterator(pkgCache &Owner, Dependency *Trg, Version* = 0) :
 271                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepVer) {
 272                 if (S == 0)
 273                         S = Owner.DepP;
 274         };
 275         inline DepIterator(pkgCache &Owner, Dependency *Trg, Package*) :
 276                 Iterator<Dependency, DepIterator>(Owner, Trg), Type(DepRev) {
 277                 if (S == 0)
 278                         S = Owner.DepP;
 279         };
 280         inline DepIterator() : Iterator<Dependency, DepIterator>(), Type(DepVer) {};
 281 };
 282                                                                         /*}}}*/
 283 // Provides iterator                                                    /*{{{*/
 284 class pkgCache::PrvIterator : public Iterator<Provides, PrvIterator> {
 285         enum {PrvVer, PrvPkg} Type;
 286
 287         protected:
 288         inline Provides* OwnerPointer() const {
 289                 return Owner->ProvideP;
 290         };
 291
 292         public:
 293         // Iteration
 294         void operator ++(int) {if (S != Owner->ProvideP) S = Owner->ProvideP +
 295                 (Type == PrvVer?S->NextPkgProv:S->NextProvides);};
 296         inline void operator ++() {operator ++(0);};
 297
 298         // Accessors
 299         inline const char *Name() const {return Owner->StrP + Owner->PkgP[S->ParentPkg].Name;};
 300         inline const char *ProvideVersion() const {return S->ProvideVersion == 0?0:Owner->StrP + S->ProvideVersion;};
 301         inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + S->ParentPkg);};
 302         inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + S->Version);};
 303         inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[S->Version].ParentPkg);};
 304
 305         inline PrvIterator() : Iterator<Provides, PrvIterator>(), Type(PrvVer) {};
 306
 307         inline PrvIterator(pkgCache &Owner, Provides *Trg, Version*) :
 308                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvVer) {
 309                 if (S == 0)
 310                         S = Owner.ProvideP;
 311         };
 312         inline PrvIterator(pkgCache &Owner, Provides *Trg, Package*) :
 313                 Iterator<Provides, PrvIterator>(Owner, Trg), Type(PrvPkg) {
 314                 if (S == 0)
 315                         S = Owner.ProvideP;
 316         };
 317 };
 318                                                                         /*}}}*/
 319 // Package file                                                         /*{{{*/
 320 class pkgCache::PkgFileIterator : public Iterator<PackageFile, PkgFileIterator> {
 321         protected:
 322         inline PackageFile* OwnerPointer() const {
 323                 return Owner->PkgFileP;
 324         };
 325
 326         public:
 327         // Iteration
 328         void operator ++(int) {if (S != Owner->PkgFileP) S = Owner->PkgFileP + S->NextFile;};
 329         inline void operator ++() {operator ++(0);};
 330
 331         // Accessors
 332         inline const char *FileName() const {return S->FileName == 0?0:Owner->StrP + S->FileName;};
 333         inline const char *Archive() const {return S->Archive == 0?0:Owner->StrP + S->Archive;};
 334         inline const char *Component() const {return S->Component == 0?0:Owner->StrP + S->Component;};
 335         inline const char *Version() const {return S->Version == 0?0:Owner->StrP + S->Version;};
 336         inline const char *Origin() const {return S->Origin == 0?0:Owner->StrP + S->Origin;};
 337         inline const char *Codename() const {return S->Codename ==0?0:Owner->StrP + S->Codename;};
 338         inline const char *Label() const {return S->Label == 0?0:Owner->StrP + S->Label;};
 339         inline const char *Site() const {return S->Site == 0?0:Owner->StrP + S->Site;};
 340         inline const char *Architecture() const {return S->Architecture == 0?0:Owner->StrP + S->Architecture;};
 341         inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
 342
 343         bool IsOk();
 344         string RelStr();
 345
 346         // Constructors
 347         inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
 348         inline PkgFileIterator(pkgCache &Owner) : Iterator<PackageFile, PkgFileIterator>(Owner, Owner.PkgFileP) {};
 349         inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Iterator<PackageFile, PkgFileIterator>(Owner, Trg) {};
 350 };
 351                                                                         /*}}}*/
 352 // Version File                                                         /*{{{*/
 353 class pkgCache::VerFileIterator : public pkgCache::Iterator<VerFile, VerFileIterator> {
 354         protected:
 355         inline VerFile* OwnerPointer() const {
 356                 return Owner->VerFileP;
 357         };
 358
 359         public:
 360         // Iteration
 361         void operator ++(int) {if (S != Owner->VerFileP) S = Owner->VerFileP + S->NextFile;};
 362         inline void operator ++() {operator ++(0);};
 363
 364         // Accessors
 365         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 366
 367         inline VerFileIterator() : Iterator<VerFile, VerFileIterator>() {};
 368         inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Iterator<VerFile, VerFileIterator>(Owner, Trg) {};
 369 };
 370                                                                         /*}}}*/
 371 // Description File                                                     /*{{{*/
 372 class pkgCache::DescFileIterator : public Iterator<DescFile, DescFileIterator> {
 373         protected:
 374         inline DescFile* OwnerPointer() const {
 375                 return Owner->DescFileP;
 376         };
 377
 378         public:
 379         // Iteration
 380         void operator ++(int) {if (S != Owner->DescFileP) S = Owner->DescFileP + S->NextFile;};
 381         inline void operator ++() {operator ++(0);};
 382
 383         // Accessors
 384         inline PkgFileIterator File() const {return PkgFileIterator(*Owner,S->File + Owner->PkgFileP);};
 385
 386         inline DescFileIterator() : Iterator<DescFile, DescFileIterator>() {};
 387         inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Iterator<DescFile, DescFileIterator>(Owner, Trg) {};
 388 };
 389                                                                         /*}}}*/
 390 // Inlined Begin functions cant be in the class because of order problems /*{{{*/
 391 inline pkgCache::PkgIterator pkgCache::GrpIterator::PackageList() const
 392        {return PkgIterator(*Owner,Owner->PkgP + S->FirstPackage);};
 393 inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
 394        {return VerIterator(*Owner,Owner->VerP + S->VersionList);};
 395 inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
 396        {return VerIterator(*Owner,Owner->VerP + S->CurrentVer);};
 397 inline pkgCache::DepIterator pkgCache::PkgIterator::RevDependsList() const
 398        {return DepIterator(*Owner,Owner->DepP + S->RevDepends,S);};
 399 inline pkgCache::PrvIterator pkgCache::PkgIterator::ProvidesList() const
 400        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 401 inline pkgCache::DescIterator pkgCache::VerIterator::DescriptionList() const
 402        {return DescIterator(*Owner,Owner->DescP + S->DescriptionList);};
 403 inline pkgCache::PrvIterator pkgCache::VerIterator::ProvidesList() const
 404        {return PrvIterator(*Owner,Owner->ProvideP + S->ProvidesList,S);};
 405 inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
 406        {return DepIterator(*Owner,Owner->DepP + S->DependsList,S);};
 407 inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
 408        {return VerFileIterator(*Owner,Owner->VerFileP + S->FileList);};
 409 inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
 410        {return DescFileIterator(*Owner,Owner->DescFileP + S->FileList);};
 411                                                                         /*}}}*/
 412 #endif