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