apt  @VERSION@
cacheset.h
Go to the documentation of this file.
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