apt  0.9.7.7ubuntu3
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 FromGroup(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
143  static bool FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
144  static bool FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper);
145 
146  struct Modifier {
147  enum Position { NONE, PREFIX, POSTFIX };
148  unsigned short ID;
149  const char * const Alias;
150  Position Pos;
151  Modifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {};
152  };
153 
154  static bool FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
155  pkgCacheFile &Cache, const char * cmdline,
156  std::list<Modifier> const &mods, CacheSetHelper &helper);
157 };
158  /*}}}*/
159 template<class Container> class PackageContainer : public PackageContainerInterface {/*{{{*/
165  Container _cont;
166 public: /*{{{*/
169  public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {
170  typename Container::const_iterator _iter;
171  public:
172  const_iterator(typename Container::const_iterator i) : _iter(i) {}
173  pkgCache::PkgIterator getPkg(void) const { return *_iter; }
174  inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
175  operator typename Container::const_iterator(void) const { return _iter; }
176  inline const_iterator& operator++() { ++_iter; return *this; }
177  inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
178  inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; };
179  inline bool operator==(const_iterator const &i) const { return _iter == i._iter; };
180  friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
181  };
183  public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
184  typename Container::iterator _iter;
185  public:
186  iterator(typename Container::iterator i) : _iter(i) {}
187  pkgCache::PkgIterator getPkg(void) const { return *_iter; }
188  inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
189  operator typename Container::iterator(void) const { return _iter; }
191  inline iterator& operator++() { ++_iter; return *this; }
192  inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
193  inline bool operator!=(iterator const &i) const { return _iter != i._iter; };
194  inline bool operator==(iterator const &i) const { return _iter == i._iter; };
195  inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; };
196  inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; };
197  friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
198  };
199  /*}}}*/
200 
201  bool insert(pkgCache::PkgIterator const &P) { if (P.end() == true) return false; _cont.insert(P); return true; };
202  template<class Cont> void insert(PackageContainer<Cont> const &pkgcont) { _cont.insert((typename Cont::const_iterator)pkgcont.begin(), (typename Cont::const_iterator)pkgcont.end()); };
203  void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
204 
205  bool empty() const { return _cont.empty(); };
206  void clear() { return _cont.clear(); };
207  //FIXME: on ABI break, replace the first with the second without bool
208  void erase(iterator position) { _cont.erase((typename Container::iterator)position); };
209  iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); };
210  size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); };
211  void erase(iterator first, iterator last) { _cont.erase(first, last); };
212  size_t size() const { return _cont.size(); };
213 
214  const_iterator begin() const { return const_iterator(_cont.begin()); };
215  const_iterator end() const { return const_iterator(_cont.end()); };
216  iterator begin() { return iterator(_cont.begin()); };
217  iterator end() { return iterator(_cont.end()); };
218  const_iterator find(pkgCache::PkgIterator const &P) const { return const_iterator(_cont.find(P)); };
219 
220  void setConstructor(Constructor const &by) { ConstructedBy = by; };
221  Constructor getConstructor() const { return ConstructedBy; };
222 
223  PackageContainer() : ConstructedBy(UNKNOWN) {};
224  PackageContainer(Constructor const &by) : ConstructedBy(by) {};
225 
234  static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
235  PackageContainer cont(TASK);
236  PackageContainerInterface::FromTask(&cont, Cache, pattern, helper);
237  return cont;
238  }
239  static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern) {
240  CacheSetHelper helper;
241  return FromTask(Cache, pattern, helper);
242  }
243 
252  static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
253  PackageContainer cont(REGEX);
254  PackageContainerInterface::FromRegEx(&cont, Cache, pattern, helper);
255  return cont;
256  }
257 
258  static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
259  CacheSetHelper helper;
260  return FromRegEx(Cache, pattern, helper);
261  }
262 
268  static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
269  return PackageContainerInterface::FromName(Cache, pattern, helper);
270  }
271  static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) {
272  CacheSetHelper helper;
273  return PackageContainerInterface::FromName(Cache, pattern, helper);
274  }
275 
281  static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
282  PackageContainer cont;
283  PackageContainerInterface::FromString(&cont, Cache, pattern, helper);
284  return cont;
285  }
286  static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) {
287  CacheSetHelper helper;
288  return FromString(Cache, pattern, helper);
289  }
290 
298  static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
299  PackageContainer cont;
300  PackageContainerInterface::FromCommandLine(&cont, Cache, cmdline, helper);
301  return cont;
302  }
303  static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
304  CacheSetHelper helper;
305  return FromCommandLine(Cache, cmdline, helper);
306  }
307 
319  static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
320  pkgCacheFile &Cache,
321  const char **cmdline,
322  std::list<Modifier> const &mods,
323  unsigned short const &fallback,
324  CacheSetHelper &helper) {
325  std::map<unsigned short, PackageContainer> pkgsets;
326  for (const char **I = cmdline; *I != 0; ++I) {
327  unsigned short modID = fallback;
328  PackageContainer pkgset;
329  PackageContainerInterface::FromModifierCommandLine(modID, &pkgset, Cache, *I, mods, helper);
330  pkgsets[modID].insert(pkgset);
331  }
332  return pkgsets;
333  }
334  static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
335  pkgCacheFile &Cache,
336  const char **cmdline,
337  std::list<Modifier> const &mods,
338  unsigned short const &fallback) {
339  CacheSetHelper helper;
340  return GroupedFromCommandLine(Cache, cmdline,
341  mods, fallback, helper);
342  }
343  /*}}}*/
344 private: /*{{{*/
345  Constructor ConstructedBy;
346  /*}}}*/
347 }; /*}}}*/
348 
349 template<> template<class Cont> void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(PackageContainer<Cont> const &pkgcont) {
350  for (typename PackageContainer<Cont>::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p)
351  _cont.push_back(*p);
352 };
353 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
354 // specializations again and again - but we need to see them, so that library users can use them
355 template<> inline bool PackageContainer<std::list<pkgCache::PkgIterator> >::insert(pkgCache::PkgIterator const &P) {
356  if (P.end() == true)
357  return false;
358  _cont.push_back(P);
359  return true;
360 };
361 template<> inline void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(const_iterator begin, const_iterator end) {
362  for (const_iterator p = begin; p != end; ++p)
363  _cont.push_back(*p);
364 };
365 typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet;
366 typedef PackageContainer<std::list<pkgCache::PkgIterator> > PackageList;
367 
372 public:
374  class const_iterator { /*{{{*/
375  public:
376  virtual pkgCache::VerIterator getVer() const = 0;
377  operator pkgCache::VerIterator(void) { return getVer(); }
378 
379  inline pkgCache *Cache() const { return getVer().Cache(); };
380  inline unsigned long Index() const {return getVer().Index();};
381  inline int CompareVer(const pkgCache::VerIterator &B) const { return getVer().CompareVer(B); };
382  inline const char *VerStr() const { return getVer().VerStr(); };
383  inline const char *Section() const { return getVer().Section(); };
384  inline const char *Arch() const { return getVer().Arch(); };
385  inline pkgCache::PkgIterator ParentPkg() const { return getVer().ParentPkg(); };
386  inline pkgCache::DescIterator DescriptionList() const { return getVer().DescriptionList(); };
387  inline pkgCache::DescIterator TranslatedDescription() const { return getVer().TranslatedDescription(); };
388  inline pkgCache::DepIterator DependsList() const { return getVer().DependsList(); };
389  inline pkgCache::PrvIterator ProvidesList() const { return getVer().ProvidesList(); };
390  inline pkgCache::VerFileIterator FileList() const { return getVer().FileList(); };
391  inline bool Downloadable() const { return getVer().Downloadable(); };
392  inline const char *PriorityType() const { return getVer().PriorityType(); };
393  inline std::string RelStr() const { return getVer().RelStr(); };
394  inline bool Automatic() const { return getVer().Automatic(); };
395  inline pkgCache::VerFileIterator NewestFile() const { return getVer().NewestFile(); };
396  // we have only valid iterators here
397  inline bool end() const { return false; };
398 
399  inline pkgCache::Version const * operator->() const { return &*getVer(); };
400  };
401  /*}}}*/
402 
403  virtual bool insert(pkgCache::VerIterator const &V) = 0;
404  virtual bool empty() const = 0;
405  virtual void clear() = 0;
406 
408  enum Version {
423  };
424 
425  struct Modifier {
426  enum Position { NONE, PREFIX, POSTFIX };
427  unsigned short ID;
428  const char * const Alias;
429  Position Pos;
430  Version SelectVersion;
431  Modifier (unsigned short const &id, const char * const alias, Position const &pos,
432  Version const &select) : ID(id), Alias(alias), Pos(pos),
433  SelectVersion(select) {};
434  };
435 
436  static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
437  const char **cmdline, Version const &fallback,
438  CacheSetHelper &helper);
439 
440  static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
441  std::string pkg, Version const &fallback, CacheSetHelper &helper,
442  bool const onlyFromName = false);
443 
444  static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
445  pkgCache::PkgIterator const &P, Version const &fallback,
446  CacheSetHelper &helper);
447 
448  static bool FromModifierCommandLine(unsigned short &modID,
449  VersionContainerInterface * const vci,
450  pkgCacheFile &Cache, const char * cmdline,
451  std::list<Modifier> const &mods,
452  CacheSetHelper &helper);
453 
454 
455  static bool FromDependency(VersionContainerInterface * const vci,
456  pkgCacheFile &Cache,
457  pkgCache::DepIterator const &D,
458  Version const &selector,
459  CacheSetHelper &helper);
460 
461 protected: /*{{{*/
462 
468  pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
469 
475  pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
476  /*}}}*/
477 };
478  /*}}}*/
479 template<class Container> class VersionContainer : public VersionContainerInterface {/*{{{*/
485  Container _cont;
486 public: /*{{{*/
489  public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {/*{{{*/
490  typename Container::const_iterator _iter;
491  public:
492  const_iterator(typename Container::const_iterator i) : _iter(i) {}
493  pkgCache::VerIterator getVer(void) const { return *_iter; }
494  inline pkgCache::VerIterator operator*(void) const { return *_iter; };
495  operator typename Container::const_iterator(void) const { return _iter; }
496  inline const_iterator& operator++() { ++_iter; return *this; }
497  inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
498  inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; };
499  inline bool operator==(const_iterator const &i) const { return _iter == i._iter; };
500  friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
501  };
503  public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
504  typename Container::iterator _iter;
505  public:
506  iterator(typename Container::iterator i) : _iter(i) {}
507  pkgCache::VerIterator getVer(void) const { return *_iter; }
508  inline pkgCache::VerIterator operator*(void) const { return *_iter; };
509  operator typename Container::iterator(void) const { return _iter; }
511  inline iterator& operator++() { ++_iter; return *this; }
512  inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
513  inline bool operator!=(iterator const &i) const { return _iter != i._iter; };
514  inline bool operator==(iterator const &i) const { return _iter == i._iter; };
515  inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; };
516  inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; };
517  friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
518  };
519  /*}}}*/
520 
521  bool insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; _cont.insert(V); return true; };
522  template<class Cont> void insert(VersionContainer<Cont> const &vercont) { _cont.insert((typename Cont::const_iterator)vercont.begin(), (typename Cont::const_iterator)vercont.end()); };
523  void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
524  bool empty() const { return _cont.empty(); };
525  void clear() { return _cont.clear(); };
526  //FIXME: on ABI break, replace the first with the second without bool
527  void erase(iterator position) { _cont.erase((typename Container::iterator)position); };
528  iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); };
529  size_t erase(const pkgCache::VerIterator x) { return _cont.erase(x); };
530  void erase(iterator first, iterator last) { _cont.erase(first, last); };
531  size_t size() const { return _cont.size(); };
532 
533  const_iterator begin() const { return const_iterator(_cont.begin()); };
534  const_iterator end() const { return const_iterator(_cont.end()); };
535  iterator begin() { return iterator(_cont.begin()); };
536  iterator end() { return iterator(_cont.end()); };
537  const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); };
538 
546  static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
547  Version const &fallback, CacheSetHelper &helper) {
548  VersionContainer vercon;
549  VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper);
550  return vercon;
551  }
552  static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
553  Version const &fallback) {
554  CacheSetHelper helper;
555  return FromCommandLine(Cache, cmdline, fallback, helper);
556  }
557  static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
558  return FromCommandLine(Cache, cmdline, CANDINST);
559  }
560 
561  static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,
562  Version const &fallback, CacheSetHelper &helper,
563  bool const onlyFromName = false) {
564  VersionContainer vercon;
565  VersionContainerInterface::FromString(&vercon, Cache, pkg, fallback, helper);
566  return vercon;
567  }
568  static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg,
569  Version const &fallback) {
570  CacheSetHelper helper;
571  return FromString(Cache, pkg, fallback, helper);
572  }
573  static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) {
574  return FromString(Cache, pkg, CANDINST);
575  }
576 
584  Version const &fallback, CacheSetHelper &helper) {
585  VersionContainer vercon;
586  VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper);
587  return vercon;
588  }
590  Version const &fallback) {
591  CacheSetHelper helper;
592  return FromPackage(Cache, P, fallback, helper);
593  }
594  static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
595  return FromPackage(Cache, P, CANDIDATE);
596  }
597 
598  static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
599  pkgCacheFile &Cache,
600  const char **cmdline,
601  std::list<Modifier> const &mods,
602  unsigned short const fallback,
603  CacheSetHelper &helper) {
604  std::map<unsigned short, VersionContainer> versets;
605  for (const char **I = cmdline; *I != 0; ++I) {
606  unsigned short modID = fallback;
607  VersionContainer verset;
608  VersionContainerInterface::FromModifierCommandLine(modID, &verset, Cache, *I, mods, helper);
609  versets[modID].insert(verset);
610  }
611  return versets;
612 
613  }
614  static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
615  pkgCacheFile &Cache, const char **cmdline,
616  std::list<Modifier> const &mods,
617  unsigned short const fallback) {
618  CacheSetHelper helper;
619  return GroupedFromCommandLine(Cache, cmdline,
620  mods, fallback, helper);
621  }
622 
623  static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
624  Version const &selector, CacheSetHelper &helper) {
625  VersionContainer vercon;
626  VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper);
627  return vercon;
628  }
629  static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
630  Version const &selector) {
631  CacheSetHelper helper;
632  return FromPackage(Cache, D, selector, helper);
633  }
634  static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) {
635  return FromPackage(Cache, D, CANDIDATE);
636  }
637  /*}}}*/
638 }; /*}}}*/
639 
640 template<> template<class Cont> void VersionContainer<std::list<pkgCache::VerIterator> >::insert(VersionContainer<Cont> const &vercont) {
641  for (typename VersionContainer<Cont>::const_iterator v = vercont.begin(); v != vercont.end(); ++v)
642  _cont.push_back(*v);
643 };
644 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
645 // specializations again and again - but we need to see them, so that library users can use them
646 template<> inline bool VersionContainer<std::list<pkgCache::VerIterator> >::insert(pkgCache::VerIterator const &V) {
647  if (V.end() == true)
648  return false;
649  _cont.push_back(V);
650  return true;
651 };
652 template<> inline void VersionContainer<std::list<pkgCache::VerIterator> >::insert(const_iterator begin, const_iterator end) {
653  for (const_iterator v = begin; v != end; ++v)
654  _cont.push_back(*v);
655 };
656 typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet;
657 typedef VersionContainer<std::list<pkgCache::VerIterator> > VersionList;
658 }
659 #endif