apt  0.9.6ubuntu1
cacheset.h
Go to the documentation of this file.
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
8  /*}}}*/
9 #ifndef APT_CACHESET_H
10 #define APT_CACHESET_H
11 // Include Files /*{{{*/
12 #include <iostream>
13 #include <fstream>
14 #include <list>
15 #include <map>
16 #include <set>
17 #include <list>
18 #include <string>
19 #include <iterator>
20 
21 #include <apt-pkg/error.h>
22 #include <apt-pkg/pkgcache.h>
23 
24 #ifndef APT_8_CLEANER_HEADERS
25 #include <apt-pkg/cachefile.h>
26 #endif
27  /*}}}*/
28 
29 class pkgCacheFile;
30 
31 namespace APT {
32 class PackageContainerInterface;
33 class VersionContainerInterface;
34 
35 class CacheSetHelper { /*{{{*/
44 public: /*{{{*/
45  CacheSetHelper(bool const ShowError = true,
47  ShowError(ShowError), ErrorType(ErrorType) {};
48  virtual ~CacheSetHelper() {};
49 
50  virtual void showTaskSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
51  virtual void showRegExSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
52  virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
53  std::string const &ver, bool const verIsRel);
54 
55  virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
56  virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
57  virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str);
58 
59  virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
60  virtual void canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
61  pkgCache::PkgIterator const &Pkg);
62  virtual void canNotFindCandInstVer(VersionContainerInterface * const vci,
63  pkgCacheFile &Cache,
64  pkgCache::PkgIterator const &Pkg);
65 
66  virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
67  virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,
68  pkgCache::PkgIterator const &Pkg);
69  virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,
70  pkgCache::PkgIterator const &Pkg);
71  virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,
72  pkgCache::PkgIterator const &Pkg);
73 
74  bool showErrors() const { return ShowError; };
75  bool showErrors(bool const newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); };
76  GlobalError::MsgType errorType() const { return ErrorType; };
77  GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
78  {
79  if (ErrorType == newValue) return ErrorType;
80  else {
81  GlobalError::MsgType const &oldValue = ErrorType;
82  ErrorType = newValue;
83  return oldValue;
84  }
85  };
86 
87  /*}}}*/
88 protected:
89  bool ShowError;
90  GlobalError::MsgType ErrorType;
91 }; /*}}}*/
102 public:
103  class const_iterator { /*{{{*/
104  public:
105  virtual pkgCache::PkgIterator getPkg() const = 0;
106  operator pkgCache::PkgIterator(void) const { return getPkg(); }
107 
108  inline const char *Name() const {return getPkg().Name(); }
109  inline std::string FullName(bool const Pretty) const { return getPkg().FullName(Pretty); }
110  inline std::string FullName() const { return getPkg().FullName(); }
111  inline const char *Section() const {return getPkg().Section(); }
112  inline bool Purge() const {return getPkg().Purge(); }
113  inline const char *Arch() const {return getPkg().Arch(); }
114  inline pkgCache::GrpIterator Group() const { return getPkg().Group(); }
115  inline pkgCache::VerIterator VersionList() const { return getPkg().VersionList(); }
116  inline pkgCache::VerIterator CurrentVer() const { return getPkg().CurrentVer(); }
117  inline pkgCache::DepIterator RevDependsList() const { return getPkg().RevDependsList(); }
118  inline pkgCache::PrvIterator ProvidesList() const { return getPkg().ProvidesList(); }
119  inline pkgCache::PkgIterator::OkState State() const { return getPkg().State(); }
120  inline const char *CandVersion() const { return getPkg().CandVersion(); }
121  inline const char *CurVersion() const { return getPkg().CurVersion(); }
122  inline pkgCache *Cache() const { return getPkg().Cache(); };
123  inline unsigned long Index() const {return getPkg().Index();};
124  // we have only valid iterators here
125  inline bool end() const { return false; };
126 
127  inline pkgCache::Package const * operator->() const {return &*getPkg();};
128  };
129  /*}}}*/
130 
131  virtual bool insert(pkgCache::PkgIterator const &P) = 0;
132  virtual bool empty() const = 0;
133  virtual void clear() = 0;
134 
135  enum Constructor { UNKNOWN, REGEX, TASK };
136  virtual void setConstructor(Constructor const &con) = 0;
137  virtual Constructor getConstructor() const = 0;
138 
139  static bool FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
140  static bool FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
141  static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
142  static bool FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
143  static bool FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper);
144 
145  struct Modifier {
146  enum Position { NONE, PREFIX, POSTFIX };
147  unsigned short ID;
148  const char * const Alias;
149  Position Pos;
150  Modifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {};
151  };
152 
153  static bool FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
154  pkgCacheFile &Cache, const char * cmdline,
155  std::list<Modifier> const &mods, CacheSetHelper &helper);
156 };
157  /*}}}*/
158 template<class Container> class PackageContainer : public PackageContainerInterface {/*{{{*/
164  Container _cont;
165 public: /*{{{*/
168  public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {
169  typename Container::const_iterator _iter;
170  public:
171  const_iterator(typename Container::const_iterator i) : _iter(i) {}
172  pkgCache::PkgIterator getPkg(void) const { return *_iter; }
173  inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
174  operator typename Container::const_iterator(void) const { return _iter; }
175  inline const_iterator& operator++() { ++_iter; return *this; }
176  inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
177  inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; };
178  inline bool operator==(const_iterator const &i) const { return _iter == i._iter; };
179  friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
180  };
182  public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
183  typename Container::iterator _iter;
184  public:
185  iterator(typename Container::iterator i) : _iter(i) {}
186  pkgCache::PkgIterator getPkg(void) const { return *_iter; }
187  inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
188  operator typename Container::iterator(void) const { return _iter; }
190  inline iterator& operator++() { ++_iter; return *this; }
191  inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
192  inline bool operator!=(iterator const &i) const { return _iter != i._iter; };
193  inline bool operator==(iterator const &i) const { return _iter == i._iter; };
194  inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; };
195  inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; };
196  friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
197  };
198  /*}}}*/
199 
200  bool insert(pkgCache::PkgIterator const &P) { if (P.end() == true) return false; _cont.insert(P); return true; };
201  template<class Cont> void insert(PackageContainer<Cont> const &pkgcont) { _cont.insert((typename Cont::const_iterator)pkgcont.begin(), (typename Cont::const_iterator)pkgcont.end()); };
202  void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
203 
204  bool empty() const { return _cont.empty(); };
205  void clear() { return _cont.clear(); };
206  //FIXME: on ABI break, replace the first with the second without bool
207  void erase(iterator position) { _cont.erase((typename Container::iterator)position); };
208  iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); };
209  size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); };
210  void erase(iterator first, iterator last) { _cont.erase(first, last); };
211  size_t size() const { return _cont.size(); };
212 
213  const_iterator begin() const { return const_iterator(_cont.begin()); };
214  const_iterator end() const { return const_iterator(_cont.end()); };
215  iterator begin() { return iterator(_cont.begin()); };
216  iterator end() { return iterator(_cont.end()); };
217  const_iterator find(pkgCache::PkgIterator const &P) const { return const_iterator(_cont.find(P)); };
218 
219  void setConstructor(Constructor const &by) { ConstructedBy = by; };
220  Constructor getConstructor() const { return ConstructedBy; };
221 
222  PackageContainer() : ConstructedBy(UNKNOWN) {};
223  PackageContainer(Constructor const &by) : ConstructedBy(by) {};
224 
233  static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
234  PackageContainer cont(TASK);
235  PackageContainerInterface::FromTask(&cont, Cache, pattern, helper);
236  return cont;
237  }
238  static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern) {
239  CacheSetHelper helper;
240  return FromTask(Cache, pattern, helper);
241  }
242 
251  static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
252  PackageContainer cont(REGEX);
253  PackageContainerInterface::FromRegEx(&cont, Cache, pattern, helper);
254  return cont;
255  }
256 
257  static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
258  CacheSetHelper helper;
259  return FromRegEx(Cache, pattern, helper);
260  }
261 
267  static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
268  return PackageContainerInterface::FromName(Cache, pattern, helper);
269  }
270  static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) {
271  CacheSetHelper helper;
272  return PackageContainerInterface::FromName(Cache, pattern, helper);
273  }
274 
280  static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
281  PackageContainer cont;
282  PackageContainerInterface::FromString(&cont, Cache, pattern, helper);
283  return cont;
284  }
285  static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) {
286  CacheSetHelper helper;
287  return FromString(Cache, pattern, helper);
288  }
289 
297  static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
298  PackageContainer cont;
299  PackageContainerInterface::FromCommandLine(&cont, Cache, cmdline, helper);
300  return cont;
301  }
302  static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
303  CacheSetHelper helper;
304  return FromCommandLine(Cache, cmdline, helper);
305  }
306 
318  static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
319  pkgCacheFile &Cache,
320  const char **cmdline,
321  std::list<Modifier> const &mods,
322  unsigned short const &fallback,
323  CacheSetHelper &helper) {
324  std::map<unsigned short, PackageContainer> pkgsets;
325  for (const char **I = cmdline; *I != 0; ++I) {
326  unsigned short modID = fallback;
327  PackageContainer pkgset;
328  PackageContainerInterface::FromModifierCommandLine(modID, &pkgset, Cache, *I, mods, helper);
329  pkgsets[modID].insert(pkgset);
330  }
331  return pkgsets;
332  }
333  static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
334  pkgCacheFile &Cache,
335  const char **cmdline,
336  std::list<Modifier> const &mods,
337  unsigned short const &fallback) {
338  CacheSetHelper helper;
339  return GroupedFromCommandLine(Cache, cmdline,
340  mods, fallback, helper);
341  }
342  /*}}}*/
343 private: /*{{{*/
344  Constructor ConstructedBy;
345  /*}}}*/
346 }; /*}}}*/
347 
348 template<> template<class Cont> void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(PackageContainer<Cont> const &pkgcont) {
349  for (typename PackageContainer<Cont>::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p)
350  _cont.push_back(*p);
351 };
352 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
353 // specializations again and again - but we need to see them, so that library users can use them
354 template<> inline bool PackageContainer<std::list<pkgCache::PkgIterator> >::insert(pkgCache::PkgIterator const &P) {
355  if (P.end() == true)
356  return false;
357  _cont.push_back(P);
358  return true;
359 };
360 template<> inline void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(const_iterator begin, const_iterator end) {
361  for (const_iterator p = begin; p != end; ++p)
362  _cont.push_back(*p);
363 };
364 typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet;
365 typedef PackageContainer<std::list<pkgCache::PkgIterator> > PackageList;
366 
371 public:
373  class const_iterator { /*{{{*/
374  public:
375  virtual pkgCache::VerIterator getVer() const = 0;
376  operator pkgCache::VerIterator(void) { return getVer(); }
377 
378  inline pkgCache *Cache() const { return getVer().Cache(); };
379  inline unsigned long Index() const {return getVer().Index();};
380  inline int CompareVer(const pkgCache::VerIterator &B) const { return getVer().CompareVer(B); };
381  inline const char *VerStr() const { return getVer().VerStr(); };
382  inline const char *Section() const { return getVer().Section(); };
383  inline const char *Arch() const { return getVer().Arch(); };
384  inline pkgCache::PkgIterator ParentPkg() const { return getVer().ParentPkg(); };
385  inline pkgCache::DescIterator DescriptionList() const { return getVer().DescriptionList(); };
386  inline pkgCache::DescIterator TranslatedDescription() const { return getVer().TranslatedDescription(); };
387  inline pkgCache::DepIterator DependsList() const { return getVer().DependsList(); };
388  inline pkgCache::PrvIterator ProvidesList() const { return getVer().ProvidesList(); };
389  inline pkgCache::VerFileIterator FileList() const { return getVer().FileList(); };
390  inline bool Downloadable() const { return getVer().Downloadable(); };
391  inline const char *PriorityType() const { return getVer().PriorityType(); };
392  inline std::string RelStr() const { return getVer().RelStr(); };
393  inline bool Automatic() const { return getVer().Automatic(); };
394  inline pkgCache::VerFileIterator NewestFile() const { return getVer().NewestFile(); };
395  // we have only valid iterators here
396  inline bool end() const { return false; };
397 
398  inline pkgCache::Version const * operator->() const { return &*getVer(); };
399  };
400  /*}}}*/
401 
402  virtual bool insert(pkgCache::VerIterator const &V) = 0;
403  virtual bool empty() const = 0;
404  virtual void clear() = 0;
405 
407  enum Version {
422  };
423 
424  struct Modifier {
425  enum Position { NONE, PREFIX, POSTFIX };
426  unsigned short ID;
427  const char * const Alias;
428  Position Pos;
429  Version SelectVersion;
430  Modifier (unsigned short const &id, const char * const alias, Position const &pos,
431  Version const &select) : ID(id), Alias(alias), Pos(pos),
432  SelectVersion(select) {};
433  };
434 
435  static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
436  const char **cmdline, Version const &fallback,
437  CacheSetHelper &helper);
438 
439  static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
440  std::string pkg, Version const &fallback, CacheSetHelper &helper,
441  bool const onlyFromName = false);
442 
443  static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
444  pkgCache::PkgIterator const &P, Version const &fallback,
445  CacheSetHelper &helper);
446 
447  static bool FromModifierCommandLine(unsigned short &modID,
448  VersionContainerInterface * const vci,
449  pkgCacheFile &Cache, const char * cmdline,
450  std::list<Modifier> const &mods,
451  CacheSetHelper &helper);
452 
453 
454  static bool FromDependency(VersionContainerInterface * const vci,
455  pkgCacheFile &Cache,
456  pkgCache::DepIterator const &D,
457  Version const &selector,
458  CacheSetHelper &helper);
459 
460 protected: /*{{{*/
461 
467  pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
468 
474  pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
475  /*}}}*/
476 };
477  /*}}}*/
478 template<class Container> class VersionContainer : public VersionContainerInterface {/*{{{*/
484  Container _cont;
485 public: /*{{{*/
488  public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {/*{{{*/
489  typename Container::const_iterator _iter;
490  public:
491  const_iterator(typename Container::const_iterator i) : _iter(i) {}
492  pkgCache::VerIterator getVer(void) const { return *_iter; }
493  inline pkgCache::VerIterator operator*(void) const { return *_iter; };
494  operator typename Container::const_iterator(void) const { return _iter; }
495  inline const_iterator& operator++() { ++_iter; return *this; }
496  inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
497  inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; };
498  inline bool operator==(const_iterator const &i) const { return _iter == i._iter; };
499  friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
500  };
502  public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
503  typename Container::iterator _iter;
504  public:
505  iterator(typename Container::iterator i) : _iter(i) {}
506  pkgCache::VerIterator getVer(void) const { return *_iter; }
507  inline pkgCache::VerIterator operator*(void) const { return *_iter; };
508  operator typename Container::iterator(void) const { return _iter; }
510  inline iterator& operator++() { ++_iter; return *this; }
511  inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
512  inline bool operator!=(iterator const &i) const { return _iter != i._iter; };
513  inline bool operator==(iterator const &i) const { return _iter == i._iter; };
514  inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; };
515  inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; };
516  friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
517  };
518  /*}}}*/
519 
520  bool insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; _cont.insert(V); return true; };
521  template<class Cont> void insert(VersionContainer<Cont> const &vercont) { _cont.insert((typename Cont::const_iterator)vercont.begin(), (typename Cont::const_iterator)vercont.end()); };
522  void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
523  bool empty() const { return _cont.empty(); };
524  void clear() { return _cont.clear(); };
525  //FIXME: on ABI break, replace the first with the second without bool
526  void erase(iterator position) { _cont.erase((typename Container::iterator)position); };
527  iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); };
528  size_t erase(const pkgCache::VerIterator x) { return _cont.erase(x); };
529  void erase(iterator first, iterator last) { _cont.erase(first, last); };
530  size_t size() const { return _cont.size(); };
531 
532  const_iterator begin() const { return const_iterator(_cont.begin()); };
533  const_iterator end() const { return const_iterator(_cont.end()); };
534  iterator begin() { return iterator(_cont.begin()); };
535  iterator end() { return iterator(_cont.end()); };
536  const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); };
537 
545  static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
546  Version const &fallback, CacheSetHelper &helper) {
547  VersionContainer vercon;
548  VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper);
549  return vercon;
550  }
551  static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
552  Version const &fallback) {
553  CacheSetHelper helper;
554  return FromCommandLine(Cache, cmdline, fallback, helper);
555  }
556  static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
557  return FromCommandLine(Cache, cmdline, CANDINST);
558  }
559 
560  static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,
561  Version const &fallback, CacheSetHelper &helper,
562  bool const onlyFromName = false) {
563  VersionContainer vercon;
564  VersionContainerInterface::FromString(&vercon, Cache, pkg, fallback, helper);
565  return vercon;
566  }
567  static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg,
568  Version const &fallback) {
569  CacheSetHelper helper;
570  return FromString(Cache, pkg, fallback, helper);
571  }
572  static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) {
573  return FromString(Cache, pkg, CANDINST);
574  }
575 
583  Version const &fallback, CacheSetHelper &helper) {
584  VersionContainer vercon;
585  VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper);
586  return vercon;
587  }
589  Version const &fallback) {
590  CacheSetHelper helper;
591  return FromPackage(Cache, P, fallback, helper);
592  }
593  static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
594  return FromPackage(Cache, P, CANDIDATE);
595  }
596 
597  static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
598  pkgCacheFile &Cache,
599  const char **cmdline,
600  std::list<Modifier> const &mods,
601  unsigned short const fallback,
602  CacheSetHelper &helper) {
603  std::map<unsigned short, VersionContainer> versets;
604  for (const char **I = cmdline; *I != 0; ++I) {
605  unsigned short modID = fallback;
606  VersionContainer verset;
607  VersionContainerInterface::FromModifierCommandLine(modID, &verset, Cache, *I, mods, helper);
608  versets[modID].insert(verset);
609  }
610  return versets;
611 
612  }
613  static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
614  pkgCacheFile &Cache, const char **cmdline,
615  std::list<Modifier> const &mods,
616  unsigned short const fallback) {
617  CacheSetHelper helper;
618  return GroupedFromCommandLine(Cache, cmdline,
619  mods, fallback, helper);
620  }
621 
622  static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
623  Version const &selector, CacheSetHelper &helper) {
624  VersionContainer vercon;
625  VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper);
626  return vercon;
627  }
628  static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
629  Version const &selector) {
630  CacheSetHelper helper;
631  return FromPackage(Cache, D, selector, helper);
632  }
633  static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) {
634  return FromPackage(Cache, D, CANDIDATE);
635  }
636  /*}}}*/
637 }; /*}}}*/
638 
639 template<> template<class Cont> void VersionContainer<std::list<pkgCache::VerIterator> >::insert(VersionContainer<Cont> const &vercont) {
640  for (typename VersionContainer<Cont>::const_iterator v = vercont.begin(); v != vercont.end(); ++v)
641  _cont.push_back(*v);
642 };
643 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
644 // specializations again and again - but we need to see them, so that library users can use them
645 template<> inline bool VersionContainer<std::list<pkgCache::VerIterator> >::insert(pkgCache::VerIterator const &V) {
646  if (V.end() == true)
647  return false;
648  _cont.push_back(V);
649  return true;
650 };
651 template<> inline void VersionContainer<std::list<pkgCache::VerIterator> >::insert(const_iterator begin, const_iterator end) {
652  for (const_iterator v = begin; v != end; ++v)
653  _cont.push_back(*v);
654 };
655 typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet;
656 typedef VersionContainer<std::list<pkgCache::VerIterator> > VersionList;
657 }
658 #endif