apt  0.9.14
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 <map>
15 #include <set>
16 #include <list>
17 #include <string>
18 #include <iterator>
19 
20 #include <apt-pkg/error.h>
21 #include <apt-pkg/pkgcache.h>
22 
23 #ifndef APT_8_CLEANER_HEADERS
24 #include <apt-pkg/cachefile.h>
25 #endif
26  /*}}}*/
27 
28 class pkgCacheFile;
29 
30 namespace APT {
31 class PackageContainerInterface;
32 class VersionContainerInterface;
33 
34 class CacheSetHelper { /*{{{*/
43 public: /*{{{*/
44  CacheSetHelper(bool const ShowError = true,
46  ShowError(ShowError), ErrorType(ErrorType) {};
47  virtual ~CacheSetHelper() {};
48 
49  virtual void showTaskSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
50  virtual void showRegExSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
51  virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
52  std::string const &ver, bool const verIsRel);
53 
54  virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
55  virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
56  virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str);
57 
58  virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
59  virtual void canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
60  pkgCache::PkgIterator const &Pkg);
61  virtual void canNotFindCandInstVer(VersionContainerInterface * const vci,
62  pkgCacheFile &Cache,
63  pkgCache::PkgIterator const &Pkg);
64 
65  virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
66  virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,
67  pkgCache::PkgIterator const &Pkg);
68  virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,
69  pkgCache::PkgIterator const &Pkg);
70  virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,
71  pkgCache::PkgIterator const &Pkg);
72 
73  bool showErrors() const { return ShowError; };
74  bool showErrors(bool const newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); };
75  GlobalError::MsgType errorType() const { return ErrorType; };
76  GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
77  {
78  if (ErrorType == newValue) return ErrorType;
79  else {
80  GlobalError::MsgType const &oldValue = ErrorType;
81  ErrorType = newValue;
82  return oldValue;
83  }
84  };
85 
86  /*}}}*/
87 protected:
88  bool ShowError;
89  GlobalError::MsgType ErrorType;
90 }; /*}}}*/
101 public:
102  class const_iterator { /*{{{*/
103  public:
104  virtual pkgCache::PkgIterator getPkg() const = 0;
105  operator pkgCache::PkgIterator(void) const { return getPkg(); }
106 
107  inline const char *Name() const {return getPkg().Name(); }
108  inline std::string FullName(bool const Pretty) const { return getPkg().FullName(Pretty); }
109  inline std::string FullName() const { return getPkg().FullName(); }
110  inline const char *Section() const {return getPkg().Section(); }
111  inline bool Purge() const {return getPkg().Purge(); }
112  inline const char *Arch() const {return getPkg().Arch(); }
113  inline pkgCache::GrpIterator Group() const { return getPkg().Group(); }
114  inline pkgCache::VerIterator VersionList() const { return getPkg().VersionList(); }
115  inline pkgCache::VerIterator CurrentVer() const { return getPkg().CurrentVer(); }
116  inline pkgCache::DepIterator RevDependsList() const { return getPkg().RevDependsList(); }
117  inline pkgCache::PrvIterator ProvidesList() const { return getPkg().ProvidesList(); }
118  inline pkgCache::PkgIterator::OkState State() const { return getPkg().State(); }
119  inline const char *CandVersion() const { return getPkg().CandVersion(); }
120  inline const char *CurVersion() const { return getPkg().CurVersion(); }
121  inline pkgCache *Cache() const { return getPkg().Cache(); };
122  inline unsigned long Index() const {return getPkg().Index();};
123  // we have only valid iterators here
124  inline bool end() const { return false; };
125 
126  inline pkgCache::Package const * operator->() const {return &*getPkg();};
127  };
128  /*}}}*/
129 
130  virtual bool insert(pkgCache::PkgIterator const &P) = 0;
131  virtual bool empty() const = 0;
132  virtual void clear() = 0;
133 
134  enum Constructor { UNKNOWN, REGEX, TASK, FNMATCH };
135  virtual void setConstructor(Constructor const &con) = 0;
136  virtual Constructor getConstructor() const = 0;
137 
138  static bool FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
139  static bool FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
140  static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
141  static bool FromFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string 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 
263  static PackageContainer FromFnmatch(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
264  PackageContainer cont(FNMATCH);
265  PackageContainerInterface::FromFnmatch(&cont, Cache, pattern, helper);
266  return cont;
267  }
268  static PackageContainer FromFnMatch(pkgCacheFile &Cache, std::string const &pattern) {
269  CacheSetHelper helper;
270  return FromFnmatch(Cache, pattern, helper);
271  }
272 
278  static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
279  return PackageContainerInterface::FromName(Cache, pattern, helper);
280  }
281  static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) {
282  CacheSetHelper helper;
283  return PackageContainerInterface::FromName(Cache, pattern, helper);
284  }
285 
291  static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
292  PackageContainer cont;
293  PackageContainerInterface::FromString(&cont, Cache, pattern, helper);
294  return cont;
295  }
296  static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) {
297  CacheSetHelper helper;
298  return FromString(Cache, pattern, helper);
299  }
300 
308  static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
309  PackageContainer cont;
310  PackageContainerInterface::FromCommandLine(&cont, Cache, cmdline, helper);
311  return cont;
312  }
313  static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
314  CacheSetHelper helper;
315  return FromCommandLine(Cache, cmdline, helper);
316  }
317 
329  static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
330  pkgCacheFile &Cache,
331  const char **cmdline,
332  std::list<Modifier> const &mods,
333  unsigned short const &fallback,
334  CacheSetHelper &helper) {
335  std::map<unsigned short, PackageContainer> pkgsets;
336  for (const char **I = cmdline; *I != 0; ++I) {
337  unsigned short modID = fallback;
338  PackageContainer pkgset;
339  PackageContainerInterface::FromModifierCommandLine(modID, &pkgset, Cache, *I, mods, helper);
340  pkgsets[modID].insert(pkgset);
341  }
342  return pkgsets;
343  }
344  static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
345  pkgCacheFile &Cache,
346  const char **cmdline,
347  std::list<Modifier> const &mods,
348  unsigned short const &fallback) {
349  CacheSetHelper helper;
350  return GroupedFromCommandLine(Cache, cmdline,
351  mods, fallback, helper);
352  }
353  /*}}}*/
354 private: /*{{{*/
355  Constructor ConstructedBy;
356  /*}}}*/
357 }; /*}}}*/
358 
359 template<> template<class Cont> void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(PackageContainer<Cont> const &pkgcont) {
360  for (typename PackageContainer<Cont>::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p)
361  _cont.push_back(*p);
362 };
363 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
364 // specializations again and again - but we need to see them, so that library users can use them
365 template<> inline bool PackageContainer<std::list<pkgCache::PkgIterator> >::insert(pkgCache::PkgIterator const &P) {
366  if (P.end() == true)
367  return false;
368  _cont.push_back(P);
369  return true;
370 };
371 template<> inline void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(const_iterator begin, const_iterator end) {
372  for (const_iterator p = begin; p != end; ++p)
373  _cont.push_back(*p);
374 };
375 typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet;
376 typedef PackageContainer<std::list<pkgCache::PkgIterator> > PackageList;
377 
382 public:
384  class const_iterator { /*{{{*/
385  public:
386  virtual pkgCache::VerIterator getVer() const = 0;
387  operator pkgCache::VerIterator(void) { return getVer(); }
388 
389  inline pkgCache *Cache() const { return getVer().Cache(); };
390  inline unsigned long Index() const {return getVer().Index();};
391  inline int CompareVer(const pkgCache::VerIterator &B) const { return getVer().CompareVer(B); };
392  inline const char *VerStr() const { return getVer().VerStr(); };
393  inline const char *Section() const { return getVer().Section(); };
394  inline const char *Arch() const { return getVer().Arch(); };
395  inline pkgCache::PkgIterator ParentPkg() const { return getVer().ParentPkg(); };
396  inline pkgCache::DescIterator DescriptionList() const { return getVer().DescriptionList(); };
397  inline pkgCache::DescIterator TranslatedDescription() const { return getVer().TranslatedDescription(); };
398  inline pkgCache::DepIterator DependsList() const { return getVer().DependsList(); };
399  inline pkgCache::PrvIterator ProvidesList() const { return getVer().ProvidesList(); };
400  inline pkgCache::VerFileIterator FileList() const { return getVer().FileList(); };
401  inline bool Downloadable() const { return getVer().Downloadable(); };
402  inline const char *PriorityType() const { return getVer().PriorityType(); };
403  inline std::string RelStr() const { return getVer().RelStr(); };
404  inline bool Automatic() const { return getVer().Automatic(); };
405  inline pkgCache::VerFileIterator NewestFile() const { return getVer().NewestFile(); };
406  // we have only valid iterators here
407  inline bool end() const { return false; };
408 
409  inline pkgCache::Version const * operator->() const { return &*getVer(); };
410  };
411  /*}}}*/
412 
413  virtual bool insert(pkgCache::VerIterator const &V) = 0;
414  virtual bool empty() const = 0;
415  virtual void clear() = 0;
416 
418  enum Version {
433  };
434 
435  struct Modifier {
436  enum Position { NONE, PREFIX, POSTFIX };
437  unsigned short ID;
438  const char * const Alias;
439  Position Pos;
440  Version SelectVersion;
441  Modifier (unsigned short const &id, const char * const alias, Position const &pos,
442  Version const &select) : ID(id), Alias(alias), Pos(pos),
443  SelectVersion(select) {};
444  };
445 
446  static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
447  const char **cmdline, Version const &fallback,
448  CacheSetHelper &helper);
449 
450  static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
451  std::string pkg, Version const &fallback, CacheSetHelper &helper,
452  bool const onlyFromName = false);
453 
454  static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
455  pkgCache::PkgIterator const &P, Version const &fallback,
456  CacheSetHelper &helper);
457 
458  static bool FromModifierCommandLine(unsigned short &modID,
459  VersionContainerInterface * const vci,
460  pkgCacheFile &Cache, const char * cmdline,
461  std::list<Modifier> const &mods,
462  CacheSetHelper &helper);
463 
464 
465  static bool FromDependency(VersionContainerInterface * const vci,
466  pkgCacheFile &Cache,
467  pkgCache::DepIterator const &D,
468  Version const &selector,
469  CacheSetHelper &helper);
470 
471 protected: /*{{{*/
472 
478  pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
479 
485  pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
486  /*}}}*/
487 };
488  /*}}}*/
489 template<class Container> class VersionContainer : public VersionContainerInterface {/*{{{*/
495  Container _cont;
496 public: /*{{{*/
499  public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {/*{{{*/
500  typename Container::const_iterator _iter;
501  public:
502  const_iterator(typename Container::const_iterator i) : _iter(i) {}
503  pkgCache::VerIterator getVer(void) const { return *_iter; }
504  inline pkgCache::VerIterator operator*(void) const { return *_iter; };
505  operator typename Container::const_iterator(void) const { return _iter; }
506  inline const_iterator& operator++() { ++_iter; return *this; }
507  inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
508  inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; };
509  inline bool operator==(const_iterator const &i) const { return _iter == i._iter; };
510  friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
511  };
513  public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
514  typename Container::iterator _iter;
515  public:
516  iterator(typename Container::iterator i) : _iter(i) {}
517  pkgCache::VerIterator getVer(void) const { return *_iter; }
518  inline pkgCache::VerIterator operator*(void) const { return *_iter; };
519  operator typename Container::iterator(void) const { return _iter; }
521  inline iterator& operator++() { ++_iter; return *this; }
522  inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
523  inline bool operator!=(iterator const &i) const { return _iter != i._iter; };
524  inline bool operator==(iterator const &i) const { return _iter == i._iter; };
525  inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; };
526  inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; };
527  friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
528  };
529  /*}}}*/
530 
531  bool insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; _cont.insert(V); return true; };
532  template<class Cont> void insert(VersionContainer<Cont> const &vercont) { _cont.insert((typename Cont::const_iterator)vercont.begin(), (typename Cont::const_iterator)vercont.end()); };
533  void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
534  bool empty() const { return _cont.empty(); };
535  void clear() { return _cont.clear(); };
536  //FIXME: on ABI break, replace the first with the second without bool
537  void erase(iterator position) { _cont.erase((typename Container::iterator)position); };
538  iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); };
539  size_t erase(const pkgCache::VerIterator x) { return _cont.erase(x); };
540  void erase(iterator first, iterator last) { _cont.erase(first, last); };
541  size_t size() const { return _cont.size(); };
542 
543  const_iterator begin() const { return const_iterator(_cont.begin()); };
544  const_iterator end() const { return const_iterator(_cont.end()); };
545  iterator begin() { return iterator(_cont.begin()); };
546  iterator end() { return iterator(_cont.end()); };
547  const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); };
548 
556  static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
557  Version const &fallback, CacheSetHelper &helper) {
558  VersionContainer vercon;
559  VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper);
560  return vercon;
561  }
562  static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
563  Version const &fallback) {
564  CacheSetHelper helper;
565  return FromCommandLine(Cache, cmdline, fallback, helper);
566  }
567  static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
568  return FromCommandLine(Cache, cmdline, CANDINST);
569  }
570 
571  static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,
572  Version const &fallback, CacheSetHelper &helper,
573  bool const onlyFromName = false) {
574  VersionContainer vercon;
575  VersionContainerInterface::FromString(&vercon, Cache, pkg, fallback, helper);
576  return vercon;
577  }
578  static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg,
579  Version const &fallback) {
580  CacheSetHelper helper;
581  return FromString(Cache, pkg, fallback, helper);
582  }
583  static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) {
584  return FromString(Cache, pkg, CANDINST);
585  }
586 
594  Version const &fallback, CacheSetHelper &helper) {
595  VersionContainer vercon;
596  VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper);
597  return vercon;
598  }
600  Version const &fallback) {
601  CacheSetHelper helper;
602  return FromPackage(Cache, P, fallback, helper);
603  }
604  static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
605  return FromPackage(Cache, P, CANDIDATE);
606  }
607 
608  static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
609  pkgCacheFile &Cache,
610  const char **cmdline,
611  std::list<Modifier> const &mods,
612  unsigned short const fallback,
613  CacheSetHelper &helper) {
614  std::map<unsigned short, VersionContainer> versets;
615  for (const char **I = cmdline; *I != 0; ++I) {
616  unsigned short modID = fallback;
617  VersionContainer verset;
618  VersionContainerInterface::FromModifierCommandLine(modID, &verset, Cache, *I, mods, helper);
619  versets[modID].insert(verset);
620  }
621  return versets;
622 
623  }
624  static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
625  pkgCacheFile &Cache, const char **cmdline,
626  std::list<Modifier> const &mods,
627  unsigned short const fallback) {
628  CacheSetHelper helper;
629  return GroupedFromCommandLine(Cache, cmdline,
630  mods, fallback, helper);
631  }
632 
633  static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
634  Version const &selector, CacheSetHelper &helper) {
635  VersionContainer vercon;
636  VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper);
637  return vercon;
638  }
639  static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
640  Version const &selector) {
641  CacheSetHelper helper;
642  return FromPackage(Cache, D, selector, helper);
643  }
644  static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) {
645  return FromPackage(Cache, D, CANDIDATE);
646  }
647  /*}}}*/
648 }; /*}}}*/
649 
650 template<> template<class Cont> void VersionContainer<std::list<pkgCache::VerIterator> >::insert(VersionContainer<Cont> const &vercont) {
651  for (typename VersionContainer<Cont>::const_iterator v = vercont.begin(); v != vercont.end(); ++v)
652  _cont.push_back(*v);
653 };
654 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
655 // specializations again and again - but we need to see them, so that library users can use them
656 template<> inline bool VersionContainer<std::list<pkgCache::VerIterator> >::insert(pkgCache::VerIterator const &V) {
657  if (V.end() == true)
658  return false;
659  _cont.push_back(V);
660  return true;
661 };
662 template<> inline void VersionContainer<std::list<pkgCache::VerIterator> >::insert(const_iterator begin, const_iterator end) {
663  for (const_iterator v = begin; v != end; ++v)
664  _cont.push_back(*v);
665 };
666 typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet;
667 typedef VersionContainer<std::list<pkgCache::VerIterator> > VersionList;
668 }
669 #endif
Definition: cacheiterators.h:136
Definition: cacheiterators.h:315
Version
specifies which version(s) will be returned if non is given
Definition: cacheset.h:418
information for a single version of a package
Definition: pkgcache.h:501
Definition: cacheset.h:512
smell like a pkgCache::VerIterator
Definition: cacheset.h:498
static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper)
returns all packages in the cache who belong to the given task
Definition: cacheset.h:234
Definition: cacheiterators.h:95
pkgCache - Structure definitions for the cache file
static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper)
returns a package specified by a string
Definition: cacheset.h:278
An error does hinder the correct execution and should be corrected.
Definition: error.h:60
Definition: cacheset.h:34
Definition: cacheset.h:420
static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper)
returns all packages in the cache whose name matchs a given pattern
Definition: cacheset.h:252
Definition: cachefile.h:33
Definition: pkgcache.h:86
contains information for a single unique package
Definition: pkgcache.h:361
static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P, Version const &fallback, CacheSetHelper &helper)
returns all versions specified for the package
Definition: cacheset.h:593
static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, Version const &fallback, CacheSetHelper &helper)
returns all versions specified on the commandline
Definition: cacheset.h:556
MsgType
a message can have one of following severity
Definition: error.h:55
smell like a pkgCache::PkgIterator
Definition: cacheset.h:168
static std::map< unsigned short, PackageContainer > GroupedFromCommandLine(pkgCacheFile &Cache, const char **cmdline, std::list< Modifier > const &mods, unsigned short const &fallback, CacheSetHelper &helper)
group packages by a action modifiers
Definition: cacheset.h:329
Definition: cacheiterators.h:264
Definition: cacheset.h:432
static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper)
returns all packages specified by a string
Definition: cacheset.h:291
Definition: cacheiterators.h:185
static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper)
returns the candidate version of the package
Definition: cacheset.cc:546
smell like a pkgCache::VerIterator
Definition: cacheset.h:384
Definition: cacheiterators.h:237
Definition: cacheset.h:159
static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper)
returns all packages specified on the commandline
Definition: cacheset.h:308
Definition: cacheset.h:489
Definition: cacheset.h:378
static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper)
returns the installed version of the package
Definition: cacheset.cc:562
Definition: cacheiterators.h:385
Definition: cacheset.h:182
Definition: cacheset.h:91