apt
@VERSION@
|
00001 // -*- mode: cpp; mode: fold -*- 00002 // Description /*{{{*/ 00008 /*}}}*/ 00009 #ifndef APT_CACHESET_H 00010 #define APT_CACHESET_H 00011 // Include Files /*{{{*/ 00012 #include <iostream> 00013 #include <fstream> 00014 #include <list> 00015 #include <map> 00016 #include <set> 00017 #include <list> 00018 #include <string> 00019 #include <iterator> 00020 00021 #include <apt-pkg/error.h> 00022 #include <apt-pkg/pkgcache.h> 00023 00024 #ifndef APT_8_CLEANER_HEADERS 00025 #include <apt-pkg/cachefile.h> 00026 #endif 00027 /*}}}*/ 00028 00029 class pkgCacheFile; 00030 00031 namespace APT { 00032 class PackageContainerInterface; 00033 class VersionContainerInterface; 00034 00035 class CacheSetHelper { /*{{{*/ 00044 public: /*{{{*/ 00045 CacheSetHelper(bool const ShowError = true, 00046 GlobalError::MsgType ErrorType = GlobalError::ERROR) : 00047 ShowError(ShowError), ErrorType(ErrorType) {}; 00048 virtual ~CacheSetHelper() {}; 00049 00050 virtual void showTaskSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern); 00051 virtual void showRegExSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern); 00052 virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver, 00053 std::string const &ver, bool const verIsRel); 00054 00055 virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern); 00056 virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern); 00057 virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str); 00058 00059 virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg); 00060 virtual void canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, 00061 pkgCache::PkgIterator const &Pkg); 00062 virtual void canNotFindCandInstVer(VersionContainerInterface * const vci, 00063 pkgCacheFile &Cache, 00064 pkgCache::PkgIterator const &Pkg); 00065 00066 virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str); 00067 virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache, 00068 pkgCache::PkgIterator const &Pkg); 00069 virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache, 00070 pkgCache::PkgIterator const &Pkg); 00071 virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache, 00072 pkgCache::PkgIterator const &Pkg); 00073 00074 bool showErrors() const { return ShowError; }; 00075 bool showErrors(bool const newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); }; 00076 GlobalError::MsgType errorType() const { return ErrorType; }; 00077 GlobalError::MsgType errorType(GlobalError::MsgType const &newValue) 00078 { 00079 if (ErrorType == newValue) return ErrorType; 00080 else { 00081 GlobalError::MsgType const &oldValue = ErrorType; 00082 ErrorType = newValue; 00083 return oldValue; 00084 } 00085 }; 00086 00087 /*}}}*/ 00088 protected: 00089 bool ShowError; 00090 GlobalError::MsgType ErrorType; 00091 }; /*}}}*/ 00092 class PackageContainerInterface { /*{{{*/ 00102 public: 00103 class const_iterator { /*{{{*/ 00104 public: 00105 virtual pkgCache::PkgIterator getPkg() const = 0; 00106 operator pkgCache::PkgIterator(void) const { return getPkg(); } 00107 00108 inline const char *Name() const {return getPkg().Name(); } 00109 inline std::string FullName(bool const Pretty) const { return getPkg().FullName(Pretty); } 00110 inline std::string FullName() const { return getPkg().FullName(); } 00111 inline const char *Section() const {return getPkg().Section(); } 00112 inline bool Purge() const {return getPkg().Purge(); } 00113 inline const char *Arch() const {return getPkg().Arch(); } 00114 inline pkgCache::GrpIterator Group() const { return getPkg().Group(); } 00115 inline pkgCache::VerIterator VersionList() const { return getPkg().VersionList(); } 00116 inline pkgCache::VerIterator CurrentVer() const { return getPkg().CurrentVer(); } 00117 inline pkgCache::DepIterator RevDependsList() const { return getPkg().RevDependsList(); } 00118 inline pkgCache::PrvIterator ProvidesList() const { return getPkg().ProvidesList(); } 00119 inline pkgCache::PkgIterator::OkState State() const { return getPkg().State(); } 00120 inline const char *CandVersion() const { return getPkg().CandVersion(); } 00121 inline const char *CurVersion() const { return getPkg().CurVersion(); } 00122 inline pkgCache *Cache() const { return getPkg().Cache(); }; 00123 inline unsigned long Index() const {return getPkg().Index();}; 00124 // we have only valid iterators here 00125 inline bool end() const { return false; }; 00126 00127 inline pkgCache::Package const * operator->() const {return &*getPkg();}; 00128 }; 00129 /*}}}*/ 00130 00131 virtual bool insert(pkgCache::PkgIterator const &P) = 0; 00132 virtual bool empty() const = 0; 00133 virtual void clear() = 0; 00134 00135 enum Constructor { UNKNOWN, REGEX, TASK }; 00136 virtual void setConstructor(Constructor const &con) = 0; 00137 virtual Constructor getConstructor() const = 0; 00138 00139 static bool FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper); 00140 static bool FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper); 00141 static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper); 00142 static bool FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper); 00143 static bool FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper); 00144 00145 struct Modifier { 00146 enum Position { NONE, PREFIX, POSTFIX }; 00147 unsigned short ID; 00148 const char * const Alias; 00149 Position Pos; 00150 Modifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {}; 00151 }; 00152 00153 static bool FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci, 00154 pkgCacheFile &Cache, const char * cmdline, 00155 std::list<Modifier> const &mods, CacheSetHelper &helper); 00156 }; 00157 /*}}}*/ 00158 template<class Container> class PackageContainer : public PackageContainerInterface {/*{{{*/ 00164 Container _cont; 00165 public: /*{{{*/ 00167 class const_iterator : public PackageContainerInterface::const_iterator,/*{{{*/ 00168 public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> { 00169 typename Container::const_iterator _iter; 00170 public: 00171 const_iterator(typename Container::const_iterator i) : _iter(i) {} 00172 pkgCache::PkgIterator getPkg(void) const { return *_iter; } 00173 inline pkgCache::PkgIterator operator*(void) const { return *_iter; }; 00174 operator typename Container::const_iterator(void) const { return _iter; } 00175 inline const_iterator& operator++() { ++_iter; return *this; } 00176 inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; } 00177 inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; }; 00178 inline bool operator==(const_iterator const &i) const { return _iter == i._iter; }; 00179 friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); } 00180 }; 00181 class iterator : public PackageContainerInterface::const_iterator, 00182 public std::iterator<std::forward_iterator_tag, typename Container::iterator> { 00183 typename Container::iterator _iter; 00184 public: 00185 iterator(typename Container::iterator i) : _iter(i) {} 00186 pkgCache::PkgIterator getPkg(void) const { return *_iter; } 00187 inline pkgCache::PkgIterator operator*(void) const { return *_iter; }; 00188 operator typename Container::iterator(void) const { return _iter; } 00189 operator typename PackageContainer<Container>::const_iterator() { return PackageContainer<Container>::const_iterator(_iter); } 00190 inline iterator& operator++() { ++_iter; return *this; } 00191 inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; } 00192 inline bool operator!=(iterator const &i) const { return _iter != i._iter; }; 00193 inline bool operator==(iterator const &i) const { return _iter == i._iter; }; 00194 friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); } 00195 }; 00196 /*}}}*/ 00197 00198 bool insert(pkgCache::PkgIterator const &P) { if (P.end() == true) return false; _cont.insert(P); return true; }; 00199 template<class Cont> void insert(PackageContainer<Cont> const &pkgcont) { _cont.insert((typename Cont::const_iterator)pkgcont.begin(), (typename Cont::const_iterator)pkgcont.end()); }; 00200 void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); }; 00201 00202 bool empty() const { return _cont.empty(); }; 00203 void clear() { return _cont.clear(); }; 00204 void erase(iterator position) { _cont.erase((typename Container::iterator)position); }; 00205 size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); }; 00206 void erase(iterator first, iterator last) { _cont.erase(first, last); }; 00207 size_t size() const { return _cont.size(); }; 00208 00209 const_iterator begin() const { return const_iterator(_cont.begin()); }; 00210 const_iterator end() const { return const_iterator(_cont.end()); }; 00211 iterator begin() { return iterator(_cont.begin()); }; 00212 iterator end() { return iterator(_cont.end()); }; 00213 const_iterator find(pkgCache::PkgIterator const &P) const { return const_iterator(_cont.find(P)); }; 00214 00215 void setConstructor(Constructor const &by) { ConstructedBy = by; }; 00216 Constructor getConstructor() const { return ConstructedBy; }; 00217 00218 PackageContainer() : ConstructedBy(UNKNOWN) {}; 00219 PackageContainer(Constructor const &by) : ConstructedBy(by) {}; 00220 00229 static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) { 00230 PackageContainer cont(TASK); 00231 PackageContainerInterface::FromTask(&cont, Cache, pattern, helper); 00232 return cont; 00233 } 00234 static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern) { 00235 CacheSetHelper helper; 00236 return FromTask(Cache, pattern, helper); 00237 } 00238 00247 static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) { 00248 PackageContainer cont(REGEX); 00249 PackageContainerInterface::FromRegEx(&cont, Cache, pattern, helper); 00250 return cont; 00251 } 00252 00253 static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string const &pattern) { 00254 CacheSetHelper helper; 00255 return FromRegEx(Cache, pattern, helper); 00256 } 00257 00263 static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) { 00264 return PackageContainerInterface::FromName(Cache, pattern, helper); 00265 } 00266 static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) { 00267 CacheSetHelper helper; 00268 return PackageContainerInterface::FromName(Cache, pattern, helper); 00269 } 00270 00276 static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) { 00277 PackageContainer cont; 00278 PackageContainerInterface::FromString(&cont, Cache, pattern, helper); 00279 return cont; 00280 } 00281 static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) { 00282 CacheSetHelper helper; 00283 return FromString(Cache, pattern, helper); 00284 } 00285 00293 static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) { 00294 PackageContainer cont; 00295 PackageContainerInterface::FromCommandLine(&cont, Cache, cmdline, helper); 00296 return cont; 00297 } 00298 static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) { 00299 CacheSetHelper helper; 00300 return FromCommandLine(Cache, cmdline, helper); 00301 } 00302 00314 static std::map<unsigned short, PackageContainer> GroupedFromCommandLine( 00315 pkgCacheFile &Cache, 00316 const char **cmdline, 00317 std::list<Modifier> const &mods, 00318 unsigned short const &fallback, 00319 CacheSetHelper &helper) { 00320 std::map<unsigned short, PackageContainer> pkgsets; 00321 for (const char **I = cmdline; *I != 0; ++I) { 00322 unsigned short modID = fallback; 00323 PackageContainer pkgset; 00324 PackageContainerInterface::FromModifierCommandLine(modID, &pkgset, Cache, *I, mods, helper); 00325 pkgsets[modID].insert(pkgset); 00326 } 00327 return pkgsets; 00328 } 00329 static std::map<unsigned short, PackageContainer> GroupedFromCommandLine( 00330 pkgCacheFile &Cache, 00331 const char **cmdline, 00332 std::list<Modifier> const &mods, 00333 unsigned short const &fallback) { 00334 CacheSetHelper helper; 00335 return GroupedFromCommandLine(Cache, cmdline, 00336 mods, fallback, helper); 00337 } 00338 /*}}}*/ 00339 private: /*{{{*/ 00340 Constructor ConstructedBy; 00341 /*}}}*/ 00342 }; /*}}}*/ 00343 00344 template<> template<class Cont> void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(PackageContainer<Cont> const &pkgcont) { 00345 for (typename PackageContainer<Cont>::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p) 00346 _cont.push_back(*p); 00347 }; 00348 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated 00349 // specializations again and again - but we need to see them, so that library users can use them 00350 template<> inline bool PackageContainer<std::list<pkgCache::PkgIterator> >::insert(pkgCache::PkgIterator const &P) { 00351 if (P.end() == true) 00352 return false; 00353 _cont.push_back(P); 00354 return true; 00355 }; 00356 template<> inline void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(const_iterator begin, const_iterator end) { 00357 for (const_iterator p = begin; p != end; ++p) 00358 _cont.push_back(*p); 00359 }; 00360 typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet; 00361 typedef PackageContainer<std::list<pkgCache::PkgIterator> > PackageList; 00362 00363 class VersionContainerInterface { /*{{{*/ 00367 public: 00369 class const_iterator { /*{{{*/ 00370 public: 00371 virtual pkgCache::VerIterator getVer() const = 0; 00372 operator pkgCache::VerIterator(void) { return getVer(); } 00373 00374 inline pkgCache *Cache() const { return getVer().Cache(); }; 00375 inline unsigned long Index() const {return getVer().Index();}; 00376 inline int CompareVer(const pkgCache::VerIterator &B) const { return getVer().CompareVer(B); }; 00377 inline const char *VerStr() const { return getVer().VerStr(); }; 00378 inline const char *Section() const { return getVer().Section(); }; 00379 inline const char *Arch() const { return getVer().Arch(); }; 00380 inline pkgCache::PkgIterator ParentPkg() const { return getVer().ParentPkg(); }; 00381 inline pkgCache::DescIterator DescriptionList() const { return getVer().DescriptionList(); }; 00382 inline pkgCache::DescIterator TranslatedDescription() const { return getVer().TranslatedDescription(); }; 00383 inline pkgCache::DepIterator DependsList() const { return getVer().DependsList(); }; 00384 inline pkgCache::PrvIterator ProvidesList() const { return getVer().ProvidesList(); }; 00385 inline pkgCache::VerFileIterator FileList() const { return getVer().FileList(); }; 00386 inline bool Downloadable() const { return getVer().Downloadable(); }; 00387 inline const char *PriorityType() const { return getVer().PriorityType(); }; 00388 inline std::string RelStr() const { return getVer().RelStr(); }; 00389 inline bool Automatic() const { return getVer().Automatic(); }; 00390 inline pkgCache::VerFileIterator NewestFile() const { return getVer().NewestFile(); }; 00391 // we have only valid iterators here 00392 inline bool end() const { return false; }; 00393 00394 inline pkgCache::Version const * operator->() const { return &*getVer(); }; 00395 }; 00396 /*}}}*/ 00397 00398 virtual bool insert(pkgCache::VerIterator const &V) = 0; 00399 virtual bool empty() const = 0; 00400 virtual void clear() = 0; 00401 00403 enum Version { 00405 ALL, 00407 CANDANDINST, 00409 CANDIDATE, 00411 INSTALLED, 00413 CANDINST, 00415 INSTCAND, 00417 NEWEST 00418 }; 00419 00420 struct Modifier { 00421 enum Position { NONE, PREFIX, POSTFIX }; 00422 unsigned short ID; 00423 const char * const Alias; 00424 Position Pos; 00425 Version SelectVersion; 00426 Modifier (unsigned short const &id, const char * const alias, Position const &pos, 00427 Version const &select) : ID(id), Alias(alias), Pos(pos), 00428 SelectVersion(select) {}; 00429 }; 00430 00431 static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache, 00432 const char **cmdline, Version const &fallback, 00433 CacheSetHelper &helper); 00434 00435 static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache, 00436 std::string pkg, Version const &fallback, CacheSetHelper &helper, 00437 bool const onlyFromName = false); 00438 00439 static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache, 00440 pkgCache::PkgIterator const &P, Version const &fallback, 00441 CacheSetHelper &helper); 00442 00443 static bool FromModifierCommandLine(unsigned short &modID, 00444 VersionContainerInterface * const vci, 00445 pkgCacheFile &Cache, const char * cmdline, 00446 std::list<Modifier> const &mods, 00447 CacheSetHelper &helper); 00448 00449 00450 static bool FromDependency(VersionContainerInterface * const vci, 00451 pkgCacheFile &Cache, 00452 pkgCache::DepIterator const &D, 00453 Version const &selector, 00454 CacheSetHelper &helper); 00455 00456 protected: /*{{{*/ 00457 00462 static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache, 00463 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper); 00464 00469 static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache, 00470 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper); 00471 /*}}}*/ 00472 }; 00473 /*}}}*/ 00474 template<class Container> class VersionContainer : public VersionContainerInterface {/*{{{*/ 00480 Container _cont; 00481 public: /*{{{*/ 00483 class const_iterator : public VersionContainerInterface::const_iterator, 00484 public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {/*{{{*/ 00485 typename Container::const_iterator _iter; 00486 public: 00487 const_iterator(typename Container::const_iterator i) : _iter(i) {} 00488 pkgCache::VerIterator getVer(void) const { return *_iter; } 00489 inline pkgCache::VerIterator operator*(void) const { return *_iter; }; 00490 operator typename Container::const_iterator(void) const { return _iter; } 00491 inline const_iterator& operator++() { ++_iter; return *this; } 00492 inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; } 00493 inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; }; 00494 inline bool operator==(const_iterator const &i) const { return _iter == i._iter; }; 00495 friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); } 00496 }; 00497 class iterator : public VersionContainerInterface::const_iterator, 00498 public std::iterator<std::forward_iterator_tag, typename Container::iterator> { 00499 typename Container::iterator _iter; 00500 public: 00501 iterator(typename Container::iterator i) : _iter(i) {} 00502 pkgCache::VerIterator getVer(void) const { return *_iter; } 00503 inline pkgCache::VerIterator operator*(void) const { return *_iter; }; 00504 operator typename Container::iterator(void) const { return _iter; } 00505 operator typename VersionContainer<Container>::const_iterator() { return VersionContainer<Container>::const_iterator(_iter); } 00506 inline iterator& operator++() { ++_iter; return *this; } 00507 inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; } 00508 inline bool operator!=(iterator const &i) const { return _iter != i._iter; }; 00509 inline bool operator==(iterator const &i) const { return _iter == i._iter; }; 00510 friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); } 00511 }; 00512 /*}}}*/ 00513 00514 bool insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; _cont.insert(V); return true; }; 00515 template<class Cont> void insert(VersionContainer<Cont> const &vercont) { _cont.insert((typename Cont::const_iterator)vercont.begin(), (typename Cont::const_iterator)vercont.end()); }; 00516 void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); }; 00517 bool empty() const { return _cont.empty(); }; 00518 void clear() { return _cont.clear(); }; 00519 void erase(iterator position) { _cont.erase((typename Container::iterator)position); }; 00520 size_t erase(const pkgCache::VerIterator x) { return _cont.erase(x); }; 00521 void erase(iterator first, iterator last) { _cont.erase(first, last); }; 00522 size_t size() const { return _cont.size(); }; 00523 00524 const_iterator begin() const { return const_iterator(_cont.begin()); }; 00525 const_iterator end() const { return const_iterator(_cont.end()); }; 00526 iterator begin() { return iterator(_cont.begin()); }; 00527 iterator end() { return iterator(_cont.end()); }; 00528 const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); }; 00529 00537 static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, 00538 Version const &fallback, CacheSetHelper &helper) { 00539 VersionContainer vercon; 00540 VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper); 00541 return vercon; 00542 } 00543 static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, 00544 Version const &fallback) { 00545 CacheSetHelper helper; 00546 return FromCommandLine(Cache, cmdline, fallback, helper); 00547 } 00548 static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) { 00549 return FromCommandLine(Cache, cmdline, CANDINST); 00550 } 00551 00552 static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg, 00553 Version const &fallback, CacheSetHelper &helper, 00554 bool const onlyFromName = false) { 00555 VersionContainer vercon; 00556 VersionContainerInterface::FromString(&vercon, Cache, pkg, fallback, helper); 00557 return vercon; 00558 } 00559 static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg, 00560 Version const &fallback) { 00561 CacheSetHelper helper; 00562 return FromString(Cache, pkg, fallback, helper); 00563 } 00564 static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) { 00565 return FromString(Cache, pkg, CANDINST); 00566 } 00567 00574 static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P, 00575 Version const &fallback, CacheSetHelper &helper) { 00576 VersionContainer vercon; 00577 VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper); 00578 return vercon; 00579 } 00580 static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P, 00581 Version const &fallback) { 00582 CacheSetHelper helper; 00583 return FromPackage(Cache, P, fallback, helper); 00584 } 00585 static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) { 00586 return FromPackage(Cache, P, CANDIDATE); 00587 } 00588 00589 static std::map<unsigned short, VersionContainer> GroupedFromCommandLine( 00590 pkgCacheFile &Cache, 00591 const char **cmdline, 00592 std::list<Modifier> const &mods, 00593 unsigned short const fallback, 00594 CacheSetHelper &helper) { 00595 std::map<unsigned short, VersionContainer> versets; 00596 for (const char **I = cmdline; *I != 0; ++I) { 00597 unsigned short modID = fallback; 00598 VersionContainer verset; 00599 VersionContainerInterface::FromModifierCommandLine(modID, &verset, Cache, *I, mods, helper); 00600 versets[modID].insert(verset); 00601 } 00602 return versets; 00603 00604 } 00605 static std::map<unsigned short, VersionContainer> GroupedFromCommandLine( 00606 pkgCacheFile &Cache, const char **cmdline, 00607 std::list<Modifier> const &mods, 00608 unsigned short const fallback) { 00609 CacheSetHelper helper; 00610 return GroupedFromCommandLine(Cache, cmdline, 00611 mods, fallback, helper); 00612 } 00613 00614 static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D, 00615 Version const &selector, CacheSetHelper &helper) { 00616 VersionContainer vercon; 00617 VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper); 00618 return vercon; 00619 } 00620 static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D, 00621 Version const &selector) { 00622 CacheSetHelper helper; 00623 return FromPackage(Cache, D, selector, helper); 00624 } 00625 static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) { 00626 return FromPackage(Cache, D, CANDIDATE); 00627 } 00628 /*}}}*/ 00629 }; /*}}}*/ 00630 00631 template<> template<class Cont> void VersionContainer<std::list<pkgCache::VerIterator> >::insert(VersionContainer<Cont> const &vercont) { 00632 for (typename VersionContainer<Cont>::const_iterator v = vercont.begin(); v != vercont.end(); ++v) 00633 _cont.push_back(*v); 00634 }; 00635 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated 00636 // specializations again and again - but we need to see them, so that library users can use them 00637 template<> inline bool VersionContainer<std::list<pkgCache::VerIterator> >::insert(pkgCache::VerIterator const &V) { 00638 if (V.end() == true) 00639 return false; 00640 _cont.push_back(V); 00641 return true; 00642 }; 00643 template<> inline void VersionContainer<std::list<pkgCache::VerIterator> >::insert(const_iterator begin, const_iterator end) { 00644 for (const_iterator v = begin; v != end; ++v) 00645 _cont.push_back(*v); 00646 }; 00647 typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet; 00648 typedef VersionContainer<std::list<pkgCache::VerIterator> > VersionList; 00649 } 00650 #endif