Ensure we have a Policy in CacheFile.BuildDepCache()
[ntk/apt.git] / apt-pkg / cacheset.h
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 /** \file cacheset.h
4 Wrappers around std::set to have set::iterators which behave
5 similar to the Iterators of the cache structures.
6
7 Provides also a few helper methods which work with these sets */
8 /*}}}*/
9 #ifndef APT_CACHESET_H
10 #define APT_CACHESET_H
11 // Include Files /*{{{*/
12 #include <fstream>
13 #include <map>
14 #include <set>
15 #include <list>
16 #include <string>
17 #include <iterator>
18
19 #include <stddef.h>
20
21 #include <apt-pkg/error.h>
22 #include <apt-pkg/pkgcache.h>
23 #include <apt-pkg/cacheiterators.h>
24
25 #ifndef APT_8_CLEANER_HEADERS
26 #include <apt-pkg/cachefile.h>
27 #endif
28 #ifndef APT_10_CLEANER_HEADERS
29 #include <iostream>
30 #endif
31 /*}}}*/
32
33 class pkgCacheFile;
34
35 namespace APT {
36 class PackageContainerInterface;
37 class VersionContainerInterface;
38
39 class CacheSetHelper { /*{{{*/
40 /** \class APT::CacheSetHelper
41 Simple base class with a lot of virtual methods which can be overridden
42 to alter the behavior or the output of the CacheSets.
43
44 This helper is passed around by the static methods in the CacheSets and
45 used every time they hit an error condition or something could be
46 printed out.
47 */
48 public: /*{{{*/
49 CacheSetHelper(bool const ShowError = true,
50 GlobalError::MsgType ErrorType = GlobalError::ERROR) :
51 ShowError(ShowError), ErrorType(ErrorType) {}
52 virtual ~CacheSetHelper() {}
53
54 virtual void showTaskSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
55 virtual void showRegExSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
56 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
57 virtual void showFnmatchSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
58 #endif
59 virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
60 std::string const &ver, bool const verIsRel);
61
62 virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
63 virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
64 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
65 virtual void canNotFindFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
66 #endif
67 virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str);
68
69 virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
70 virtual void canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
71 pkgCache::PkgIterator const &Pkg);
72 virtual void canNotFindCandInstVer(VersionContainerInterface * const vci,
73 pkgCacheFile &Cache,
74 pkgCache::PkgIterator const &Pkg);
75
76 virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
77 virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,
78 pkgCache::PkgIterator const &Pkg);
79 virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,
80 pkgCache::PkgIterator const &Pkg);
81 virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,
82 pkgCache::PkgIterator const &Pkg);
83
84 bool showErrors() const { return ShowError; }
85 bool showErrors(bool const newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); }
86 GlobalError::MsgType errorType() const { return ErrorType; }
87 GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
88 {
89 if (ErrorType == newValue) return ErrorType;
90 else {
91 GlobalError::MsgType const &oldValue = ErrorType;
92 ErrorType = newValue;
93 return oldValue;
94 }
95 }
96
97 /*}}}*/
98 protected:
99 bool ShowError;
100 GlobalError::MsgType ErrorType;
101 }; /*}}}*/
102 class PackageContainerInterface { /*{{{*/
103 /** \class PackageContainerInterface
104
105 * Interface ensuring that all operations can be executed on the yet to
106 * define concrete PackageContainer - access to all methods is possible,
107 * but in general the wrappers provided by the PackageContainer template
108 * are nicer to use.
109
110 * This class mostly protects use from the need to write all implementation
111 * of the methods working on containers in the template */
112 public:
113 class const_iterator { /*{{{*/
114 public:
115 virtual pkgCache::PkgIterator getPkg() const = 0;
116 operator pkgCache::PkgIterator(void) const { return getPkg(); }
117
118 inline const char *Name() const {return getPkg().Name(); }
119 inline std::string FullName(bool const Pretty) const { return getPkg().FullName(Pretty); }
120 inline std::string FullName() const { return getPkg().FullName(); }
121 inline const char *Section() const {return getPkg().Section(); }
122 inline bool Purge() const {return getPkg().Purge(); }
123 inline const char *Arch() const {return getPkg().Arch(); }
124 inline pkgCache::GrpIterator Group() const { return getPkg().Group(); }
125 inline pkgCache::VerIterator VersionList() const { return getPkg().VersionList(); }
126 inline pkgCache::VerIterator CurrentVer() const { return getPkg().CurrentVer(); }
127 inline pkgCache::DepIterator RevDependsList() const { return getPkg().RevDependsList(); }
128 inline pkgCache::PrvIterator ProvidesList() const { return getPkg().ProvidesList(); }
129 inline pkgCache::PkgIterator::OkState State() const { return getPkg().State(); }
130 inline const char *CandVersion() const { return getPkg().CandVersion(); }
131 inline const char *CurVersion() const { return getPkg().CurVersion(); }
132 inline pkgCache *Cache() const { return getPkg().Cache(); }
133 inline unsigned long Index() const {return getPkg().Index();}
134 // we have only valid iterators here
135 inline bool end() const { return false; }
136
137 inline pkgCache::Package const * operator->() const {return &*getPkg();}
138 };
139 /*}}}*/
140
141 virtual bool insert(pkgCache::PkgIterator const &P) = 0;
142 virtual bool empty() const = 0;
143 virtual void clear() = 0;
144
145 enum Constructor { UNKNOWN, REGEX, TASK, FNMATCH };
146 virtual void setConstructor(Constructor const &con) = 0;
147 virtual Constructor getConstructor() const = 0;
148
149 static bool FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
150 static bool FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
151 static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
152 static bool FromFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
153 static bool FromGroup(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
154 static bool FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
155 static bool FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper);
156
157 struct Modifier {
158 enum Position { NONE, PREFIX, POSTFIX };
159 unsigned short ID;
160 const char * const Alias;
161 Position Pos;
162 Modifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {}
163 };
164
165 static bool FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
166 pkgCacheFile &Cache, const char * cmdline,
167 std::list<Modifier> const &mods, CacheSetHelper &helper);
168 };
169 /*}}}*/
170 template<class Container> class PackageContainer : public PackageContainerInterface {/*{{{*/
171 /** \class APT::PackageContainer
172
173 Simple wrapper around a container class like std::set to provide a similar
174 interface to a set of packages as to the complete set of all packages in the
175 pkgCache. */
176 Container _cont;
177 public: /*{{{*/
178 /** \brief smell like a pkgCache::PkgIterator */
179 class const_iterator : public PackageContainerInterface::const_iterator,/*{{{*/
180 public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {
181 typename Container::const_iterator _iter;
182 public:
183 const_iterator(typename Container::const_iterator i) : _iter(i) {}
184 pkgCache::PkgIterator getPkg(void) const { return *_iter; }
185 inline pkgCache::PkgIterator operator*(void) const { return *_iter; }
186 operator typename Container::const_iterator(void) const { return _iter; }
187 inline const_iterator& operator++() { ++_iter; return *this; }
188 inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
189 inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; }
190 inline bool operator==(const_iterator const &i) const { return _iter == i._iter; }
191 friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
192 };
193 class iterator : public PackageContainerInterface::const_iterator,
194 public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
195 typename Container::iterator _iter;
196 public:
197 iterator(typename Container::iterator i) : _iter(i) {}
198 pkgCache::PkgIterator getPkg(void) const { return *_iter; }
199 inline pkgCache::PkgIterator operator*(void) const { return *_iter; }
200 operator typename Container::iterator(void) const { return _iter; }
201 operator typename PackageContainer<Container>::const_iterator() { return typename PackageContainer<Container>::const_iterator(_iter); }
202 inline iterator& operator++() { ++_iter; return *this; }
203 inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
204 inline bool operator!=(iterator const &i) const { return _iter != i._iter; }
205 inline bool operator==(iterator const &i) const { return _iter == i._iter; }
206 inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; }
207 inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; }
208 friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
209 };
210 /*}}}*/
211
212 bool insert(pkgCache::PkgIterator const &P) { if (P.end() == true) return false; _cont.insert(P); return true; }
213 template<class Cont> void insert(PackageContainer<Cont> const &pkgcont) { _cont.insert((typename Cont::const_iterator)pkgcont.begin(), (typename Cont::const_iterator)pkgcont.end()); }
214 void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); }
215
216 bool empty() const { return _cont.empty(); }
217 void clear() { return _cont.clear(); }
218 //FIXME: on ABI break, replace the first with the second without bool
219 void erase(iterator position) { _cont.erase((typename Container::iterator)position); }
220 iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); }
221 size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); }
222 void erase(iterator first, iterator last) { _cont.erase(first, last); }
223 size_t size() const { return _cont.size(); }
224
225 const_iterator begin() const { return const_iterator(_cont.begin()); }
226 const_iterator end() const { return const_iterator(_cont.end()); }
227 iterator begin() { return iterator(_cont.begin()); }
228 iterator end() { return iterator(_cont.end()); }
229 const_iterator find(pkgCache::PkgIterator const &P) const { return const_iterator(_cont.find(P)); }
230
231 void setConstructor(Constructor const &by) { ConstructedBy = by; }
232 Constructor getConstructor() const { return ConstructedBy; }
233
234 PackageContainer() : ConstructedBy(UNKNOWN) {}
235 PackageContainer(Constructor const &by) : ConstructedBy(by) {}
236
237 /** \brief returns all packages in the cache who belong to the given task
238
239 A simple helper responsible for search for all members of a task
240 in the cache. Optional it prints a a notice about the
241 packages chosen cause of the given task.
242 \param Cache the packages are in
243 \param pattern name of the task
244 \param helper responsible for error and message handling */
245 static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
246 PackageContainer cont(TASK);
247 PackageContainerInterface::FromTask(&cont, Cache, pattern, helper);
248 return cont;
249 }
250 static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern) {
251 CacheSetHelper helper;
252 return FromTask(Cache, pattern, helper);
253 }
254
255 /** \brief returns all packages in the cache whose name matchs a given pattern
256
257 A simple helper responsible for executing a regular expression on all
258 package names in the cache. Optional it prints a a notice about the
259 packages chosen cause of the given package.
260 \param Cache the packages are in
261 \param pattern regular expression for package names
262 \param helper responsible for error and message handling */
263 static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
264 PackageContainer cont(REGEX);
265 PackageContainerInterface::FromRegEx(&cont, Cache, pattern, helper);
266 return cont;
267 }
268
269 static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
270 CacheSetHelper helper;
271 return FromRegEx(Cache, pattern, helper);
272 }
273
274 static PackageContainer FromFnmatch(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
275 PackageContainer cont(FNMATCH);
276 PackageContainerInterface::FromFnmatch(&cont, Cache, pattern, helper);
277 return cont;
278 }
279 static PackageContainer FromFnMatch(pkgCacheFile &Cache, std::string const &pattern) {
280 CacheSetHelper helper;
281 return FromFnmatch(Cache, pattern, helper);
282 }
283
284 /** \brief returns a package specified by a string
285
286 \param Cache the package is in
287 \param pattern String the package name should be extracted from
288 \param helper responsible for error and message handling */
289 static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
290 return PackageContainerInterface::FromName(Cache, pattern, helper);
291 }
292 static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) {
293 CacheSetHelper helper;
294 return PackageContainerInterface::FromName(Cache, pattern, helper);
295 }
296
297 /** \brief returns all packages specified by a string
298
299 \param Cache the packages are in
300 \param pattern String the package name(s) should be extracted from
301 \param helper responsible for error and message handling */
302 static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
303 PackageContainer cont;
304 PackageContainerInterface::FromString(&cont, Cache, pattern, helper);
305 return cont;
306 }
307 static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) {
308 CacheSetHelper helper;
309 return FromString(Cache, pattern, helper);
310 }
311
312 /** \brief returns all packages specified on the commandline
313
314 Get all package names from the commandline and executes regex's if needed.
315 No special package command is supported, just plain names.
316 \param Cache the packages are in
317 \param cmdline Command line the package names should be extracted from
318 \param helper responsible for error and message handling */
319 static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
320 PackageContainer cont;
321 PackageContainerInterface::FromCommandLine(&cont, Cache, cmdline, helper);
322 return cont;
323 }
324 static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
325 CacheSetHelper helper;
326 return FromCommandLine(Cache, cmdline, helper);
327 }
328
329 /** \brief group packages by a action modifiers
330
331 At some point it is needed to get from the same commandline
332 different package sets grouped by a modifier. Take
333 apt-get install apt awesome-
334 as an example.
335 \param Cache the packages are in
336 \param cmdline Command line the package names should be extracted from
337 \param mods list of modifiers the method should accept
338 \param fallback the default modifier group for a package
339 \param helper responsible for error and message handling */
340 static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
341 pkgCacheFile &Cache,
342 const char **cmdline,
343 std::list<Modifier> const &mods,
344 unsigned short const &fallback,
345 CacheSetHelper &helper) {
346 std::map<unsigned short, PackageContainer> pkgsets;
347 for (const char **I = cmdline; *I != 0; ++I) {
348 unsigned short modID = fallback;
349 PackageContainer pkgset;
350 PackageContainerInterface::FromModifierCommandLine(modID, &pkgset, Cache, *I, mods, helper);
351 pkgsets[modID].insert(pkgset);
352 }
353 return pkgsets;
354 }
355 static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
356 pkgCacheFile &Cache,
357 const char **cmdline,
358 std::list<Modifier> const &mods,
359 unsigned short const &fallback) {
360 CacheSetHelper helper;
361 return GroupedFromCommandLine(Cache, cmdline,
362 mods, fallback, helper);
363 }
364 /*}}}*/
365 private: /*{{{*/
366 Constructor ConstructedBy;
367 /*}}}*/
368 }; /*}}}*/
369
370 template<> template<class Cont> void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(PackageContainer<Cont> const &pkgcont) {
371 for (typename PackageContainer<Cont>::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p)
372 _cont.push_back(*p);
373 }
374 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
375 // specializations again and again - but we need to see them, so that library users can use them
376 template<> inline bool PackageContainer<std::list<pkgCache::PkgIterator> >::insert(pkgCache::PkgIterator const &P) {
377 if (P.end() == true)
378 return false;
379 _cont.push_back(P);
380 return true;
381 }
382 template<> inline void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(const_iterator begin, const_iterator end) {
383 for (const_iterator p = begin; p != end; ++p)
384 _cont.push_back(*p);
385 }
386 typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet;
387 typedef PackageContainer<std::list<pkgCache::PkgIterator> > PackageList;
388
389 class VersionContainerInterface { /*{{{*/
390 /** \class APT::VersionContainerInterface
391
392 Same as APT::PackageContainerInterface, just for Versions */
393 public:
394 /** \brief smell like a pkgCache::VerIterator */
395 class const_iterator { /*{{{*/
396 public:
397 virtual pkgCache::VerIterator getVer() const = 0;
398 operator pkgCache::VerIterator(void) { return getVer(); }
399
400 inline pkgCache *Cache() const { return getVer().Cache(); }
401 inline unsigned long Index() const {return getVer().Index();}
402 inline int CompareVer(const pkgCache::VerIterator &B) const { return getVer().CompareVer(B); }
403 inline const char *VerStr() const { return getVer().VerStr(); }
404 inline const char *Section() const { return getVer().Section(); }
405 inline const char *Arch() const { return getVer().Arch(); }
406 inline pkgCache::PkgIterator ParentPkg() const { return getVer().ParentPkg(); }
407 inline pkgCache::DescIterator DescriptionList() const { return getVer().DescriptionList(); }
408 inline pkgCache::DescIterator TranslatedDescription() const { return getVer().TranslatedDescription(); }
409 inline pkgCache::DepIterator DependsList() const { return getVer().DependsList(); }
410 inline pkgCache::PrvIterator ProvidesList() const { return getVer().ProvidesList(); }
411 inline pkgCache::VerFileIterator FileList() const { return getVer().FileList(); }
412 inline bool Downloadable() const { return getVer().Downloadable(); }
413 inline const char *PriorityType() const { return getVer().PriorityType(); }
414 inline std::string RelStr() const { return getVer().RelStr(); }
415 inline bool Automatic() const { return getVer().Automatic(); }
416 inline pkgCache::VerFileIterator NewestFile() const { return getVer().NewestFile(); }
417 // we have only valid iterators here
418 inline bool end() const { return false; }
419
420 inline pkgCache::Version const * operator->() const { return &*getVer(); }
421 };
422 /*}}}*/
423
424 virtual bool insert(pkgCache::VerIterator const &V) = 0;
425 virtual bool empty() const = 0;
426 virtual void clear() = 0;
427
428 /** \brief specifies which version(s) will be returned if non is given */
429 enum Version {
430 /** All versions */
431 ALL,
432 /** Candidate and installed version */
433 CANDANDINST,
434 /** Candidate version */
435 CANDIDATE,
436 /** Installed version */
437 INSTALLED,
438 /** Candidate or if non installed version */
439 CANDINST,
440 /** Installed or if non candidate version */
441 INSTCAND,
442 /** Newest version */
443 NEWEST
444 };
445
446 struct Modifier {
447 enum Position { NONE, PREFIX, POSTFIX };
448 unsigned short ID;
449 const char * const Alias;
450 Position Pos;
451 Version SelectVersion;
452 Modifier (unsigned short const &id, const char * const alias, Position const &pos,
453 Version const &select) : ID(id), Alias(alias), Pos(pos),
454 SelectVersion(select) {}
455 };
456
457 static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
458 const char **cmdline, Version const &fallback,
459 CacheSetHelper &helper);
460
461 static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
462 std::string pkg, Version const &fallback, CacheSetHelper &helper,
463 bool const onlyFromName = false);
464
465 static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
466 pkgCache::PkgIterator const &P, Version const &fallback,
467 CacheSetHelper &helper);
468
469 static bool FromModifierCommandLine(unsigned short &modID,
470 VersionContainerInterface * const vci,
471 pkgCacheFile &Cache, const char * cmdline,
472 std::list<Modifier> const &mods,
473 CacheSetHelper &helper);
474
475
476 static bool FromDependency(VersionContainerInterface * const vci,
477 pkgCacheFile &Cache,
478 pkgCache::DepIterator const &D,
479 Version const &selector,
480 CacheSetHelper &helper);
481
482 protected: /*{{{*/
483
484 /** \brief returns the candidate version of the package
485
486 \param Cache to be used to query for information
487 \param Pkg we want the candidate version from this package
488 \param helper used in this container instance */
489 static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache,
490 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
491
492 /** \brief returns the installed version of the package
493
494 \param Cache to be used to query for information
495 \param Pkg we want the installed version from this package
496 \param helper used in this container instance */
497 static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
498 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
499 /*}}}*/
500 };
501 /*}}}*/
502 template<class Container> class VersionContainer : public VersionContainerInterface {/*{{{*/
503 /** \class APT::VersionContainer
504
505 Simple wrapper around a container class like std::set to provide a similar
506 interface to a set of versions as to the complete set of all versions in the
507 pkgCache. */
508 Container _cont;
509 public: /*{{{*/
510 /** \brief smell like a pkgCache::VerIterator */
511 class const_iterator : public VersionContainerInterface::const_iterator,
512 public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {/*{{{*/
513 typename Container::const_iterator _iter;
514 public:
515 const_iterator(typename Container::const_iterator i) : _iter(i) {}
516 pkgCache::VerIterator getVer(void) const { return *_iter; }
517 inline pkgCache::VerIterator operator*(void) const { return *_iter; }
518 operator typename Container::const_iterator(void) const { return _iter; }
519 inline const_iterator& operator++() { ++_iter; return *this; }
520 inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
521 inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; }
522 inline bool operator==(const_iterator const &i) const { return _iter == i._iter; }
523 friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
524 };
525 class iterator : public VersionContainerInterface::const_iterator,
526 public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
527 typename Container::iterator _iter;
528 public:
529 iterator(typename Container::iterator i) : _iter(i) {}
530 pkgCache::VerIterator getVer(void) const { return *_iter; }
531 inline pkgCache::VerIterator operator*(void) const { return *_iter; }
532 operator typename Container::iterator(void) const { return _iter; }
533 operator typename VersionContainer<Container>::const_iterator() { return typename VersionContainer<Container>::const_iterator(_iter); }
534 inline iterator& operator++() { ++_iter; return *this; }
535 inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
536 inline bool operator!=(iterator const &i) const { return _iter != i._iter; }
537 inline bool operator==(iterator const &i) const { return _iter == i._iter; }
538 inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; }
539 inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; }
540 friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
541 };
542 /*}}}*/
543
544 bool insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; _cont.insert(V); return true; }
545 template<class Cont> void insert(VersionContainer<Cont> const &vercont) { _cont.insert((typename Cont::const_iterator)vercont.begin(), (typename Cont::const_iterator)vercont.end()); }
546 void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); }
547 bool empty() const { return _cont.empty(); }
548 void clear() { return _cont.clear(); }
549 //FIXME: on ABI break, replace the first with the second without bool
550 void erase(iterator position) { _cont.erase((typename Container::iterator)position); }
551 iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); }
552 size_t erase(const pkgCache::VerIterator x) { return _cont.erase(x); }
553 void erase(iterator first, iterator last) { _cont.erase(first, last); }
554 size_t size() const { return _cont.size(); }
555
556 const_iterator begin() const { return const_iterator(_cont.begin()); }
557 const_iterator end() const { return const_iterator(_cont.end()); }
558 iterator begin() { return iterator(_cont.begin()); }
559 iterator end() { return iterator(_cont.end()); }
560 const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); }
561
562 /** \brief returns all versions specified on the commandline
563
564 Get all versions from the commandline, uses given default version if
565 non specifically requested and executes regex's if needed on names.
566 \param Cache the packages and versions are in
567 \param cmdline Command line the versions should be extracted from
568 \param fallback version specification
569 \param helper responsible for error and message handling */
570 static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
571 Version const &fallback, CacheSetHelper &helper) {
572 VersionContainer vercon;
573 VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper);
574 return vercon;
575 }
576 static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
577 Version const &fallback) {
578 CacheSetHelper helper;
579 return FromCommandLine(Cache, cmdline, fallback, helper);
580 }
581 static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
582 return FromCommandLine(Cache, cmdline, CANDINST);
583 }
584
585 static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,
586 Version const &fallback, CacheSetHelper &helper,
587 bool const onlyFromName = false) {
588 VersionContainer vercon;
589 VersionContainerInterface::FromString(&vercon, Cache, pkg, fallback, helper);
590 return vercon;
591 }
592 static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg,
593 Version const &fallback) {
594 CacheSetHelper helper;
595 return FromString(Cache, pkg, fallback, helper);
596 }
597 static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) {
598 return FromString(Cache, pkg, CANDINST);
599 }
600
601 /** \brief returns all versions specified for the package
602
603 \param Cache the package and versions are in
604 \param P the package in question
605 \param fallback the version(s) you want to get
606 \param helper the helper used for display and error handling */
607 static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
608 Version const &fallback, CacheSetHelper &helper) {
609 VersionContainer vercon;
610 VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper);
611 return vercon;
612 }
613 static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
614 Version const &fallback) {
615 CacheSetHelper helper;
616 return FromPackage(Cache, P, fallback, helper);
617 }
618 static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
619 return FromPackage(Cache, P, CANDIDATE);
620 }
621
622 static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
623 pkgCacheFile &Cache,
624 const char **cmdline,
625 std::list<Modifier> const &mods,
626 unsigned short const fallback,
627 CacheSetHelper &helper) {
628 std::map<unsigned short, VersionContainer> versets;
629 for (const char **I = cmdline; *I != 0; ++I) {
630 unsigned short modID = fallback;
631 VersionContainer verset;
632 VersionContainerInterface::FromModifierCommandLine(modID, &verset, Cache, *I, mods, helper);
633 versets[modID].insert(verset);
634 }
635 return versets;
636
637 }
638 static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
639 pkgCacheFile &Cache, const char **cmdline,
640 std::list<Modifier> const &mods,
641 unsigned short const fallback) {
642 CacheSetHelper helper;
643 return GroupedFromCommandLine(Cache, cmdline,
644 mods, fallback, helper);
645 }
646
647 static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
648 Version const &selector, CacheSetHelper &helper) {
649 VersionContainer vercon;
650 VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper);
651 return vercon;
652 }
653 static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
654 Version const &selector) {
655 CacheSetHelper helper;
656 return FromPackage(Cache, D, selector, helper);
657 }
658 static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) {
659 return FromPackage(Cache, D, CANDIDATE);
660 }
661 /*}}}*/
662 }; /*}}}*/
663
664 template<> template<class Cont> void VersionContainer<std::list<pkgCache::VerIterator> >::insert(VersionContainer<Cont> const &vercont) {
665 for (typename VersionContainer<Cont>::const_iterator v = vercont.begin(); v != vercont.end(); ++v)
666 _cont.push_back(*v);
667 }
668 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
669 // specializations again and again - but we need to see them, so that library users can use them
670 template<> inline bool VersionContainer<std::list<pkgCache::VerIterator> >::insert(pkgCache::VerIterator const &V) {
671 if (V.end() == true)
672 return false;
673 _cont.push_back(V);
674 return true;
675 }
676 template<> inline void VersionContainer<std::list<pkgCache::VerIterator> >::insert(const_iterator begin, const_iterator end) {
677 for (const_iterator v = begin; v != end; ++v)
678 _cont.push_back(*v);
679 }
680 typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet;
681 typedef VersionContainer<std::list<pkgCache::VerIterator> > VersionList;
682 }
683 #endif