X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/446bbcf47d466dc160813db8a331c5cd45395803..488011fa99aee25bedb39ae2cc3115ad1ab000c0:/apt-pkg/cacheset.h

diff --git a/apt-pkg/cacheset.h b/apt-pkg/cacheset.h
index eb4f04d72..d7328d705 100644
--- a/apt-pkg/cacheset.h
+++ b/apt-pkg/cacheset.h
@@ -11,17 +11,26 @@
 // Include Files							/*{{{*/
 #include <iostream>
 #include <fstream>
-#include <list>
 #include <map>
 #include <set>
+#include <list>
 #include <string>
+#include <iterator>
 
-#include <apt-pkg/cachefile.h>
+#include <apt-pkg/error.h>
 #include <apt-pkg/pkgcache.h>
+
+#ifndef APT_8_CLEANER_HEADERS
+#include <apt-pkg/cachefile.h>
+#endif
 									/*}}}*/
+
+class pkgCacheFile;
+
 namespace APT {
-class PackageSet;
-class VersionSet;
+class PackageContainerInterface;
+class VersionContainerInterface;
+
 class CacheSetHelper {							/*{{{*/
 /** \class APT::CacheSetHelper
     Simple base class with a lot of virtual methods which can be overridden
@@ -32,25 +41,28 @@ class CacheSetHelper {							/*{{{*/
     printed out.
 */
 public:									/*{{{*/
-	CacheSetHelper(bool const &ShowError = true,
+	CacheSetHelper(bool const ShowError = true,
 		GlobalError::MsgType ErrorType = GlobalError::ERROR) :
 			ShowError(ShowError), ErrorType(ErrorType) {};
 	virtual ~CacheSetHelper() {};
 
-	virtual void showTaskSelection(PackageSet const &pkgset, string const &pattern) {};
-	virtual void showRegExSelection(PackageSet const &pkgset, string const &pattern) {};
+	virtual void showTaskSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
+	virtual void showRegExSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
 	virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
-				 string const &ver, bool const &verIsRel) {};
+				 std::string const &ver, bool const verIsRel);
 
-	virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
-	virtual PackageSet canNotFindTask(pkgCacheFile &Cache, std::string pattern);
-	virtual PackageSet canNotFindRegEx(pkgCacheFile &Cache, std::string pattern);
-	virtual PackageSet canNotFindPackage(pkgCacheFile &Cache, std::string const &str);
-	virtual VersionSet canNotFindAllVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
-	virtual VersionSet canNotFindInstCandVer(pkgCacheFile &Cache,
+	virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
+	virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
+	virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str);
+
+	virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
+	virtual void canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 				pkgCache::PkgIterator const &Pkg);
-	virtual VersionSet canNotFindCandInstVer(pkgCacheFile &Cache,
+	virtual void canNotFindCandInstVer(VersionContainerInterface * const vci,
+				pkgCacheFile &Cache,
 				pkgCache::PkgIterator const &Pkg);
+
+	virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
 	virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,
 				pkgCache::PkgIterator const &Pkg);
 	virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,
@@ -59,7 +71,7 @@ public:									/*{{{*/
 				pkgCache::PkgIterator const &Pkg);
 
 	bool showErrors() const { return ShowError; };
-	bool showErrors(bool const &newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); };
+	bool showErrors(bool const newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); };
 	GlobalError::MsgType errorType() const { return ErrorType; };
 	GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
 	{
@@ -76,53 +88,139 @@ protected:
 	bool ShowError;
 	GlobalError::MsgType ErrorType;
 };									/*}}}*/
-class PackageSet : public std::set<pkgCache::PkgIterator> {		/*{{{*/
-/** \class APT::PackageSet
-
-    Simple wrapper around a std::set to provide a similar interface to
-    a set of packages as to the complete set of all packages in the
-    pkgCache. */
-public:									/*{{{*/
-	/** \brief smell like a pkgCache::PkgIterator */
-	class const_iterator : public std::set<pkgCache::PkgIterator>::const_iterator {/*{{{*/
+class PackageContainerInterface {					/*{{{*/
+/** \class PackageContainerInterface
+
+ * Interface ensuring that all operations can be executed on the yet to
+ * define concrete PackageContainer - access to all methods is possible,
+ * but in general the wrappers provided by the PackageContainer template
+ * are nicer to use.
+
+ * This class mostly protects use from the need to write all implementation
+ * of the methods working on containers in the template */
+public:
+	class const_iterator {						/*{{{*/
 	public:
-		const_iterator(std::set<pkgCache::PkgIterator>::const_iterator x) :
-			 std::set<pkgCache::PkgIterator>::const_iterator(x) {}
-
-		operator pkgCache::PkgIterator(void) { return **this; }
-
-		inline const char *Name() const {return (**this).Name(); }
-		inline std::string FullName(bool const &Pretty) const { return (**this).FullName(Pretty); }
-		inline std::string FullName() const { return (**this).FullName(); }
-		inline const char *Section() const {return (**this).Section(); }
-		inline bool Purge() const {return (**this).Purge(); }
-		inline const char *Arch() const {return (**this).Arch(); }
-		inline pkgCache::GrpIterator Group() const { return (**this).Group(); }
-		inline pkgCache::VerIterator VersionList() const { return (**this).VersionList(); }
-		inline pkgCache::VerIterator CurrentVer() const { return (**this).CurrentVer(); }
-		inline pkgCache::DepIterator RevDependsList() const { return (**this).RevDependsList(); }
-		inline pkgCache::PrvIterator ProvidesList() const { return (**this).ProvidesList(); }
-		inline pkgCache::PkgIterator::OkState State() const { return (**this).State(); }
-		inline const char *CandVersion() const { return (**this).CandVersion(); }
-		inline const char *CurVersion() const { return (**this).CurVersion(); }
-		inline pkgCache *Cache() const { return (**this).Cache(); };
-		inline unsigned long Index() const {return (**this).Index();};
+		virtual pkgCache::PkgIterator getPkg() const = 0;
+		operator pkgCache::PkgIterator(void) const { return getPkg(); }
+
+		inline const char *Name() const {return getPkg().Name(); }
+		inline std::string FullName(bool const Pretty) const { return getPkg().FullName(Pretty); }
+		inline std::string FullName() const { return getPkg().FullName(); }
+		inline const char *Section() const {return getPkg().Section(); }
+		inline bool Purge() const {return getPkg().Purge(); }
+		inline const char *Arch() const {return getPkg().Arch(); }
+		inline pkgCache::GrpIterator Group() const { return getPkg().Group(); }
+		inline pkgCache::VerIterator VersionList() const { return getPkg().VersionList(); }
+		inline pkgCache::VerIterator CurrentVer() const { return getPkg().CurrentVer(); }
+		inline pkgCache::DepIterator RevDependsList() const { return getPkg().RevDependsList(); }
+		inline pkgCache::PrvIterator ProvidesList() const { return getPkg().ProvidesList(); }
+		inline pkgCache::PkgIterator::OkState State() const { return getPkg().State(); }
+		inline const char *CandVersion() const { return getPkg().CandVersion(); }
+		inline const char *CurVersion() const { return getPkg().CurVersion(); }
+		inline pkgCache *Cache() const { return getPkg().Cache(); };
+		inline unsigned long Index() const {return getPkg().Index();};
 		// we have only valid iterators here
 		inline bool end() const { return false; };
 
-		friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, (*i)); }
+		inline pkgCache::Package const * operator->() const {return &*getPkg();};
+	};
+									/*}}}*/
+
+	virtual bool insert(pkgCache::PkgIterator const &P) = 0;
+	virtual bool empty() const = 0;
+	virtual void clear() = 0;
+
+	enum Constructor { UNKNOWN, REGEX, TASK };
+	virtual void setConstructor(Constructor const &con) = 0;
+	virtual Constructor getConstructor() const = 0;
 
-		inline pkgCache::Package const * operator->() const {
-			return &***this;
-		};
+	static bool FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
+	static bool FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
+	static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
+	static bool FromGroup(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
+	static bool FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
+	static bool FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper);
+
+	struct Modifier {
+		enum Position { NONE, PREFIX, POSTFIX };
+		unsigned short ID;
+		const char * const Alias;
+		Position Pos;
+		Modifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {};
+	};
+
+	static bool FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
+					    pkgCacheFile &Cache, const char * cmdline,
+					    std::list<Modifier> const &mods, CacheSetHelper &helper);
+};
+									/*}}}*/
+template<class Container> class PackageContainer : public PackageContainerInterface {/*{{{*/
+/** \class APT::PackageContainer
+
+    Simple wrapper around a container class like std::set to provide a similar
+    interface to a set of packages as to the complete set of all packages in the
+    pkgCache. */
+	Container _cont;
+public:									/*{{{*/
+	/** \brief smell like a pkgCache::PkgIterator */
+	class const_iterator : public PackageContainerInterface::const_iterator,/*{{{*/
+			       public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {
+		typename Container::const_iterator _iter;
+	public:
+		const_iterator(typename Container::const_iterator i) : _iter(i) {}
+		pkgCache::PkgIterator getPkg(void) const { return *_iter; }
+		inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
+		operator typename Container::const_iterator(void) const { return _iter; }
+		inline const_iterator& operator++() { ++_iter; return *this; }
+		inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
+		inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; };
+		inline bool operator==(const_iterator const &i) const { return _iter == i._iter; };
+		friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
+	};
+	class iterator : public PackageContainerInterface::const_iterator,
+			 public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
+		typename Container::iterator _iter;
+	public:
+		iterator(typename Container::iterator i) : _iter(i) {}
+		pkgCache::PkgIterator getPkg(void) const { return *_iter; }
+		inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
+		operator typename Container::iterator(void) const { return _iter; }
+		operator typename PackageContainer<Container>::const_iterator() { return typename PackageContainer<Container>::const_iterator(_iter); }
+		inline iterator& operator++() { ++_iter; return *this; }
+		inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
+		inline bool operator!=(iterator const &i) const { return _iter != i._iter; };
+		inline bool operator==(iterator const &i) const { return _iter == i._iter; };
+		inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; };
+		inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; };
+		friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
 	};
-	// 103. set::iterator is required to be modifiable, but this allows modification of keys
-	typedef APT::PackageSet::const_iterator iterator;
 									/*}}}*/
 
-	using std::set<pkgCache::PkgIterator>::insert;
-	inline void insert(pkgCache::PkgIterator const &P) { if (P.end() == false) std::set<pkgCache::PkgIterator>::insert(P); };
-	inline void insert(PackageSet const &pkgset) { insert(pkgset.begin(), pkgset.end()); };
+	bool insert(pkgCache::PkgIterator const &P) { if (P.end() == true) return false; _cont.insert(P); return true; };
+	template<class Cont> void insert(PackageContainer<Cont> const &pkgcont) { _cont.insert((typename Cont::const_iterator)pkgcont.begin(), (typename Cont::const_iterator)pkgcont.end()); };
+	void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
+
+	bool empty() const { return _cont.empty(); };
+	void clear() { return _cont.clear(); };
+	//FIXME: on ABI break, replace the first with the second without bool
+	void erase(iterator position) { _cont.erase((typename Container::iterator)position); };
+	iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); };
+	size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); };
+	void erase(iterator first, iterator last) { _cont.erase(first, last); };
+	size_t size() const { return _cont.size(); };
+
+	const_iterator begin() const { return const_iterator(_cont.begin()); };
+	const_iterator end() const { return const_iterator(_cont.end()); };
+	iterator begin() { return iterator(_cont.begin()); };
+	iterator end() { return iterator(_cont.end()); };
+	const_iterator find(pkgCache::PkgIterator const &P) const { return const_iterator(_cont.find(P)); };
+
+	void setConstructor(Constructor const &by) { ConstructedBy = by; };
+	Constructor getConstructor() const { return ConstructedBy; };
+
+	PackageContainer() : ConstructedBy(UNKNOWN) {};
+	PackageContainer(Constructor const &by) : ConstructedBy(by) {};
 
 	/** \brief returns all packages in the cache who belong to the given task
 
@@ -132,8 +230,12 @@ public:									/*{{{*/
 	    \param Cache the packages are in
 	    \param pattern name of the task
 	    \param helper responsible for error and message handling */
-	static APT::PackageSet FromTask(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
-	static APT::PackageSet FromTask(pkgCacheFile &Cache, std::string const &pattern) {
+	static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
+		PackageContainer cont(TASK);
+		PackageContainerInterface::FromTask(&cont, Cache, pattern, helper);
+		return cont;
+	}
+	static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern) {
 		CacheSetHelper helper;
 		return FromTask(Cache, pattern, helper);
 	}
@@ -146,32 +248,43 @@ public:									/*{{{*/
 	    \param Cache the packages are in
 	    \param pattern regular expression for package names
 	    \param helper responsible for error and message handling */
-	static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
-	static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
+	static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
+		PackageContainer cont(REGEX);
+		PackageContainerInterface::FromRegEx(&cont, Cache, pattern, helper);
+		return cont;
+	}
+
+	static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
 		CacheSetHelper helper;
 		return FromRegEx(Cache, pattern, helper);
 	}
 
-	/** \brief returns all packages specified by a string
+	/** \brief returns a package specified by a string
 
-	    \param Cache the packages are in
-	    \param string String the package name(s) should be extracted from
+	    \param Cache the package is in
+	    \param pattern String the package name should be extracted from
 	    \param helper responsible for error and message handling */
-	static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string, CacheSetHelper &helper);
-	static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string) {
+	static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
+		return PackageContainerInterface::FromName(Cache, pattern, helper);
+	}
+	static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) {
 		CacheSetHelper helper;
-		return FromString(Cache, string, helper);
+		return PackageContainerInterface::FromName(Cache, pattern, helper);
 	}
 
-	/** \brief returns a package specified by a string
+	/** \brief returns all packages specified by a string
 
-	    \param Cache the package is in
-	    \param string String the package name should be extracted from
+	    \param Cache the packages are in
+	    \param pattern String the package name(s) should be extracted from
 	    \param helper responsible for error and message handling */
-	static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &string, CacheSetHelper &helper);
-	static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &string) {
+	static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
+		PackageContainer cont;
+		PackageContainerInterface::FromString(&cont, Cache, pattern, helper);
+		return cont;
+	}
+	static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) {
 		CacheSetHelper helper;
-		return FromName(Cache, string, helper);
+		return FromString(Cache, pattern, helper);
 	}
 
 	/** \brief returns all packages specified on the commandline
@@ -181,20 +294,16 @@ public:									/*{{{*/
 	    \param Cache the packages are in
 	    \param cmdline Command line the package names should be extracted from
 	    \param helper responsible for error and message handling */
-	static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper);
-	static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
+	static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
+		PackageContainer cont;
+		PackageContainerInterface::FromCommandLine(&cont, Cache, cmdline, helper);
+		return cont;
+	}
+	static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
 		CacheSetHelper helper;
 		return FromCommandLine(Cache, cmdline, helper);
 	}
 
-	struct Modifier {
-		enum Position { NONE, PREFIX, POSTFIX };
-		unsigned short ID;
-		const char * const Alias;
-		Position Pos;
-		Modifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {};
-	};
-
 	/** \brief group packages by a action modifiers
 
 	    At some point it is needed to get from the same commandline
@@ -206,78 +315,93 @@ public:									/*{{{*/
 	    \param mods list of modifiers the method should accept
 	    \param fallback the default modifier group for a package
 	    \param helper responsible for error and message handling */
-	static std::map<unsigned short, PackageSet> GroupedFromCommandLine(
-		pkgCacheFile &Cache, const char **cmdline,
-		std::list<PackageSet::Modifier> const &mods,
-		unsigned short const &fallback, CacheSetHelper &helper);
-	static std::map<unsigned short, PackageSet> GroupedFromCommandLine(
-		pkgCacheFile &Cache, const char **cmdline,
-		std::list<PackageSet::Modifier> const &mods,
-		unsigned short const &fallback) {
+	static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
+										 pkgCacheFile &Cache,
+										 const char **cmdline,
+										 std::list<Modifier> const &mods,
+										 unsigned short const &fallback,
+										 CacheSetHelper &helper) {
+		std::map<unsigned short, PackageContainer> pkgsets;
+		for (const char **I = cmdline; *I != 0; ++I) {
+			unsigned short modID = fallback;
+			PackageContainer pkgset;
+			PackageContainerInterface::FromModifierCommandLine(modID, &pkgset, Cache, *I, mods, helper);
+			pkgsets[modID].insert(pkgset);
+		}
+		return pkgsets;
+	}
+	static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
+										 pkgCacheFile &Cache,
+										 const char **cmdline,
+										 std::list<Modifier> const &mods,
+										 unsigned short const &fallback) {
 		CacheSetHelper helper;
 		return GroupedFromCommandLine(Cache, cmdline,
 				mods, fallback, helper);
 	}
-
-	enum Constructor { UNKNOWN, REGEX, TASK };
-	Constructor getConstructor() const { return ConstructedBy; };
-
-	PackageSet() : ConstructedBy(UNKNOWN) {};
-	PackageSet(Constructor const &by) : ConstructedBy(by) {};
 									/*}}}*/
 private:								/*{{{*/
 	Constructor ConstructedBy;
 									/*}}}*/
 };									/*}}}*/
-class VersionSet : public std::set<pkgCache::VerIterator> {		/*{{{*/
-/** \class APT::VersionSet
 
-    Simple wrapper around a std::set to provide a similar interface to
-    a set of versions as to the complete set of all versions in the
-    pkgCache. */
-public:									/*{{{*/
+template<> template<class Cont> void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(PackageContainer<Cont> const &pkgcont) {
+	for (typename PackageContainer<Cont>::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p)
+		_cont.push_back(*p);
+};
+// these two are 'inline' as otherwise the linker has problems with seeing these untemplated
+// specializations again and again - but we need to see them, so that library users can use them
+template<> inline bool PackageContainer<std::list<pkgCache::PkgIterator> >::insert(pkgCache::PkgIterator const &P) {
+	if (P.end() == true)
+		return false;
+	_cont.push_back(P);
+	return true;
+};
+template<> inline void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(const_iterator begin, const_iterator end) {
+	for (const_iterator p = begin; p != end; ++p)
+		_cont.push_back(*p);
+};
+typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet;
+typedef PackageContainer<std::list<pkgCache::PkgIterator> > PackageList;
+
+class VersionContainerInterface {					/*{{{*/
+/** \class APT::VersionContainerInterface
+
+    Same as APT::PackageContainerInterface, just for Versions */
+public:
 	/** \brief smell like a pkgCache::VerIterator */
-	class const_iterator : public std::set<pkgCache::VerIterator>::const_iterator {/*{{{*/
+	class const_iterator {						/*{{{*/
 	public:
-		const_iterator(std::set<pkgCache::VerIterator>::const_iterator x) :
-			 std::set<pkgCache::VerIterator>::const_iterator(x) {}
-
-		operator pkgCache::VerIterator(void) { return **this; }
-
-		inline pkgCache *Cache() const { return (**this).Cache(); };
-		inline unsigned long Index() const {return (**this).Index();};
+		virtual pkgCache::VerIterator getVer() const = 0;
+		operator pkgCache::VerIterator(void) { return getVer(); }
+
+		inline pkgCache *Cache() const { return getVer().Cache(); };
+		inline unsigned long Index() const {return getVer().Index();};
+		inline int CompareVer(const pkgCache::VerIterator &B) const { return getVer().CompareVer(B); };
+		inline const char *VerStr() const { return getVer().VerStr(); };
+		inline const char *Section() const { return getVer().Section(); };
+		inline const char *Arch() const { return getVer().Arch(); };
+		inline pkgCache::PkgIterator ParentPkg() const { return getVer().ParentPkg(); };
+		inline pkgCache::DescIterator DescriptionList() const { return getVer().DescriptionList(); };
+		inline pkgCache::DescIterator TranslatedDescription() const { return getVer().TranslatedDescription(); };
+		inline pkgCache::DepIterator DependsList() const { return getVer().DependsList(); };
+		inline pkgCache::PrvIterator ProvidesList() const { return getVer().ProvidesList(); };
+		inline pkgCache::VerFileIterator FileList() const { return getVer().FileList(); };
+		inline bool Downloadable() const { return getVer().Downloadable(); };
+		inline const char *PriorityType() const { return getVer().PriorityType(); };
+		inline std::string RelStr() const { return getVer().RelStr(); };
+		inline bool Automatic() const { return getVer().Automatic(); };
+		inline pkgCache::VerFileIterator NewestFile() const { return getVer().NewestFile(); };
 		// we have only valid iterators here
 		inline bool end() const { return false; };
 
-		inline pkgCache::Version const * operator->() const {
-			return &***this;
-		};
-
-		inline int CompareVer(const pkgCache::VerIterator &B) const { return (**this).CompareVer(B); };
-		inline const char *VerStr() const { return (**this).VerStr(); };
-		inline const char *Section() const { return (**this).Section(); };
-		inline const char *Arch() const { return (**this).Arch(); };
-		__deprecated inline const char *Arch(bool const pseudo) const { return (**this).Arch(); };
-		inline pkgCache::PkgIterator ParentPkg() const { return (**this).ParentPkg(); };
-		inline pkgCache::DescIterator DescriptionList() const { return (**this).DescriptionList(); };
-		inline pkgCache::DescIterator TranslatedDescription() const { return (**this).TranslatedDescription(); };
-		inline pkgCache::DepIterator DependsList() const { return (**this).DependsList(); };
-		inline pkgCache::PrvIterator ProvidesList() const { return (**this).ProvidesList(); };
-		inline pkgCache::VerFileIterator FileList() const { return (**this).FileList(); };
-		inline bool Downloadable() const { return (**this).Downloadable(); };
-		inline const char *PriorityType() const { return (**this).PriorityType(); };
-		inline string RelStr() const { return (**this).RelStr(); };
-		inline bool Automatic() const { return (**this).Automatic(); };
-		__deprecated inline bool Pseudo() const { return false; };
-		inline pkgCache::VerFileIterator NewestFile() const { return (**this).NewestFile(); };
+		inline pkgCache::Version const * operator->() const { return &*getVer(); };
 	};
 									/*}}}*/
-	// 103. set::iterator is required to be modifiable, but this allows modification of keys
-	typedef APT::VersionSet::const_iterator iterator;
 
-	using std::set<pkgCache::VerIterator>::insert;
-	inline void insert(pkgCache::VerIterator const &V) { if (V.end() == false) std::set<pkgCache::VerIterator>::insert(V); };
-	inline void insert(VersionSet const &verset) { insert(verset.begin(), verset.end()); };
+	virtual bool insert(pkgCache::VerIterator const &V) = 0;
+	virtual bool empty() const = 0;
+	virtual void clear() = 0;
 
 	/** \brief specifies which version(s) will be returned if non is given */
 	enum Version {
@@ -297,6 +421,120 @@ public:									/*{{{*/
 		NEWEST
 	};
 
+	struct Modifier {
+		enum Position { NONE, PREFIX, POSTFIX };
+		unsigned short ID;
+		const char * const Alias;
+		Position Pos;
+		Version SelectVersion;
+		Modifier (unsigned short const &id, const char * const alias, Position const &pos,
+			  Version const &select) : ID(id), Alias(alias), Pos(pos),
+			 SelectVersion(select) {};
+	};
+
+	static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
+				    const char **cmdline, Version const &fallback,
+				    CacheSetHelper &helper);
+
+	static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
+			       std::string pkg, Version const &fallback, CacheSetHelper &helper,
+			       bool const onlyFromName = false);
+
+	static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
+				pkgCache::PkgIterator const &P, Version const &fallback,
+				CacheSetHelper &helper);
+
+	static bool FromModifierCommandLine(unsigned short &modID,
+					    VersionContainerInterface * const vci,
+					    pkgCacheFile &Cache, const char * cmdline,
+					    std::list<Modifier> const &mods,
+					    CacheSetHelper &helper);
+
+
+	static bool FromDependency(VersionContainerInterface * const vci,
+				   pkgCacheFile &Cache,
+				   pkgCache::DepIterator const &D,
+				   Version const &selector,
+				   CacheSetHelper &helper);
+
+protected:								/*{{{*/
+
+	/** \brief returns the candidate version of the package
+
+	    \param Cache to be used to query for information
+	    \param Pkg we want the candidate version from this package */
+	static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache,
+		pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
+
+	/** \brief returns the installed version of the package
+
+	    \param Cache to be used to query for information
+	    \param Pkg we want the installed version from this package */
+	static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
+		pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
+									/*}}}*/
+};
+									/*}}}*/
+template<class Container> class VersionContainer : public VersionContainerInterface {/*{{{*/
+/** \class APT::VersionContainer
+
+    Simple wrapper around a container class like std::set to provide a similar
+    interface to a set of versions as to the complete set of all versions in the
+    pkgCache. */
+	Container _cont;
+public:									/*{{{*/
+	/** \brief smell like a pkgCache::VerIterator */
+	class const_iterator : public VersionContainerInterface::const_iterator,
+			       public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {/*{{{*/
+		typename Container::const_iterator _iter;
+	public:
+		const_iterator(typename Container::const_iterator i) : _iter(i) {}
+		pkgCache::VerIterator getVer(void) const { return *_iter; }
+		inline pkgCache::VerIterator operator*(void) const { return *_iter; };
+		operator typename Container::const_iterator(void) const { return _iter; }
+		inline const_iterator& operator++() { ++_iter; return *this; }
+		inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
+		inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; };
+		inline bool operator==(const_iterator const &i) const { return _iter == i._iter; };
+		friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
+	};
+	class iterator : public VersionContainerInterface::const_iterator,
+			 public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
+		typename Container::iterator _iter;
+	public:
+		iterator(typename Container::iterator i) : _iter(i) {}
+		pkgCache::VerIterator getVer(void) const { return *_iter; }
+		inline pkgCache::VerIterator operator*(void) const { return *_iter; };
+		operator typename Container::iterator(void) const { return _iter; }
+		operator typename VersionContainer<Container>::const_iterator() { return typename VersionContainer<Container>::const_iterator(_iter); }
+		inline iterator& operator++() { ++_iter; return *this; }
+		inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
+		inline bool operator!=(iterator const &i) const { return _iter != i._iter; };
+		inline bool operator==(iterator const &i) const { return _iter == i._iter; };
+		inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; };
+		inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; };
+		friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
+	};
+									/*}}}*/
+
+	bool insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; _cont.insert(V); return true; };
+	template<class Cont> void insert(VersionContainer<Cont> const &vercont) { _cont.insert((typename Cont::const_iterator)vercont.begin(), (typename Cont::const_iterator)vercont.end()); };
+	void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
+	bool empty() const { return _cont.empty(); };
+	void clear() { return _cont.clear(); };
+	//FIXME: on ABI break, replace the first with the second without bool
+	void erase(iterator position) { _cont.erase((typename Container::iterator)position); };
+	iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); };
+	size_t erase(const pkgCache::VerIterator x) { return _cont.erase(x); };
+	void erase(iterator first, iterator last) { _cont.erase(first, last); };
+	size_t size() const { return _cont.size(); };
+
+	const_iterator begin() const { return const_iterator(_cont.begin()); };
+	const_iterator end() const { return const_iterator(_cont.end()); };
+	iterator begin() { return iterator(_cont.begin()); };
+	iterator end() { return iterator(_cont.end()); };
+	const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); };
+
 	/** \brief returns all versions specified on the commandline
 
 	    Get all versions from the commandline, uses given default version if
@@ -304,26 +542,34 @@ public:									/*{{{*/
 	    \param Cache the packages and versions are in
 	    \param cmdline Command line the versions should be extracted from
 	    \param helper responsible for error and message handling */
-	static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
-			APT::VersionSet::Version const &fallback, CacheSetHelper &helper);
-	static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
-			APT::VersionSet::Version const &fallback) {
+	static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
+			Version const &fallback, CacheSetHelper &helper) {
+		VersionContainer vercon;
+		VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper);
+		return vercon;
+	}
+	static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
+			Version const &fallback) {
 		CacheSetHelper helper;
 		return FromCommandLine(Cache, cmdline, fallback, helper);
 	}
-	static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
+	static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
 		return FromCommandLine(Cache, cmdline, CANDINST);
 	}
 
-	static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
-			APT::VersionSet::Version const &fallback, CacheSetHelper &helper,
-			bool const &onlyFromName = false);
-	static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
-			APT::VersionSet::Version const &fallback) {
+	static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,
+			Version const &fallback, CacheSetHelper &helper,
+			bool const onlyFromName = false) {
+		VersionContainer vercon;
+		VersionContainerInterface::FromString(&vercon, Cache, pkg, fallback, helper);
+		return vercon;
+	}
+	static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg,
+			Version const &fallback) {
 		CacheSetHelper helper;
 		return FromString(Cache, pkg, fallback, helper);
 	}
-	static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg) {
+	static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) {
 		return FromString(Cache, pkg, CANDINST);
 	}
 
@@ -333,57 +579,80 @@ public:									/*{{{*/
 	    \param P the package in question
 	    \param fallback the version(s) you want to get
 	    \param helper the helper used for display and error handling */
-	static APT::VersionSet FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
-		VersionSet::Version const &fallback, CacheSetHelper &helper);
-	static APT::VersionSet FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
-			APT::VersionSet::Version const &fallback) {
+	static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
+		Version const &fallback, CacheSetHelper &helper) {
+		VersionContainer vercon;
+		VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper);
+		return vercon;
+	}
+	static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
+					    Version const &fallback) {
 		CacheSetHelper helper;
 		return FromPackage(Cache, P, fallback, helper);
 	}
-	static APT::VersionSet FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
-		return FromPackage(Cache, P, CANDINST);
+	static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
+		return FromPackage(Cache, P, CANDIDATE);
 	}
 
-	struct Modifier {
-		enum Position { NONE, PREFIX, POSTFIX };
-		unsigned short ID;
-		const char * const Alias;
-		Position Pos;
-		VersionSet::Version SelectVersion;
-		Modifier (unsigned short const &id, const char * const alias, Position const &pos,
-			  VersionSet::Version const &select) : ID(id), Alias(alias), Pos(pos),
-			 SelectVersion(select) {};
-	};
+	static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
+										 pkgCacheFile &Cache,
+										 const char **cmdline,
+										 std::list<Modifier> const &mods,
+										 unsigned short const fallback,
+										 CacheSetHelper &helper) {
+		std::map<unsigned short, VersionContainer> versets;
+		for (const char **I = cmdline; *I != 0; ++I) {
+			unsigned short modID = fallback;
+			VersionContainer verset;
+			VersionContainerInterface::FromModifierCommandLine(modID, &verset, Cache, *I, mods, helper);
+			versets[modID].insert(verset);
+		}
+		return versets;
 
-	static std::map<unsigned short, VersionSet> GroupedFromCommandLine(
-		pkgCacheFile &Cache, const char **cmdline,
-		std::list<VersionSet::Modifier> const &mods,
-		unsigned short const &fallback, CacheSetHelper &helper);
-	static std::map<unsigned short, VersionSet> GroupedFromCommandLine(
+	}
+	static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
 		pkgCacheFile &Cache, const char **cmdline,
-		std::list<VersionSet::Modifier> const &mods,
-		unsigned short const &fallback) {
+		std::list<Modifier> const &mods,
+		unsigned short const fallback) {
 		CacheSetHelper helper;
 		return GroupedFromCommandLine(Cache, cmdline,
 				mods, fallback, helper);
 	}
-									/*}}}*/
-protected:								/*{{{*/
-
-	/** \brief returns the candidate version of the package
-
-	    \param Cache to be used to query for information
-	    \param Pkg we want the candidate version from this package */
-	static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache,
-		pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
-
-	/** \brief returns the installed version of the package
 
-	    \param Cache to be used to query for information
-	    \param Pkg we want the installed version from this package */
-	static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
-		pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
+	static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
+					       Version const &selector, CacheSetHelper &helper) {
+		VersionContainer vercon;
+		VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper);
+		return vercon;
+	}
+	static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
+					       Version const &selector) {
+		CacheSetHelper helper;
+		return FromPackage(Cache, D, selector, helper);
+	}
+	static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) {
+		return FromPackage(Cache, D, CANDIDATE);
+	}
 									/*}}}*/
 };									/*}}}*/
+
+template<> template<class Cont> void VersionContainer<std::list<pkgCache::VerIterator> >::insert(VersionContainer<Cont> const &vercont) {
+	for (typename VersionContainer<Cont>::const_iterator v = vercont.begin(); v != vercont.end(); ++v)
+		_cont.push_back(*v);
+};
+// these two are 'inline' as otherwise the linker has problems with seeing these untemplated
+// specializations again and again - but we need to see them, so that library users can use them
+template<> inline bool VersionContainer<std::list<pkgCache::VerIterator> >::insert(pkgCache::VerIterator const &V) {
+	if (V.end() == true)
+		return false;
+	_cont.push_back(V);
+	return true;
+};
+template<> inline void VersionContainer<std::list<pkgCache::VerIterator> >::insert(const_iterator begin, const_iterator end) {
+	for (const_iterator v = begin; v != end; ++v)
+		_cont.push_back(*v);
+};
+typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet;
+typedef VersionContainer<std::list<pkgCache::VerIterator> > VersionList;
 }
 #endif