add d-pointer, virtual destructors and de-inline de/constructors

[apt.git] / apt-pkg / cacheset.h

diff --git a/apt-pkg/cacheset.h b/apt-pkg/cacheset.h
index dde4e221e219e09e9a208ffce1e455fbca17d0c0..1a6feb5f7c95879b43cbaccc055c5cc703c47472 100644 (file)
--- a/apt-pkg/cacheset.h
+++ b/apt-pkg/cacheset.h
@@ -13,14 +13,17 @@
 #include <map>
 #include <set>
 #include <list>
 #include <map>
 #include <set>
 #include <list>

+#include <vector>

 #include <string>
 #include <iterator>
 #include <string>
 #include <iterator>

+#include <algorithm>

 
 #include <stddef.h>
 
 #include <apt-pkg/error.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/cacheiterators.h>
 
 #include <stddef.h>
 
 #include <apt-pkg/error.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/cacheiterators.h>

+#include <apt-pkg/macros.h>

 
 #ifndef APT_8_CLEANER_HEADERS
 #include <apt-pkg/cachefile.h>
 
 #ifndef APT_8_CLEANER_HEADERS
 #include <apt-pkg/cachefile.h>


@@ -47,40 +50,130 @@ class CacheSetHelper {                                                     /*{{{*/
 */
 public:                                                                        /*{{{*/
        CacheSetHelper(bool const ShowError = true,
 */
 public:                                                                        /*{{{*/
        CacheSetHelper(bool const ShowError = true,

-               GlobalError::MsgType ErrorType = GlobalError::ERROR) :
-                       ShowError(ShowError), ErrorType(ErrorType) {}
-       virtual ~CacheSetHelper() {}
-
-       virtual void showTaskSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
-       virtual void showRegExSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
-#if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
-       virtual void showFnmatchSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
-#endif
-       virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
-                                std::string const &ver, bool const verIsRel);
+               GlobalError::MsgType ErrorType = GlobalError::ERROR);
+       virtual ~CacheSetHelper();

 
 

-       virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
-       virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
-#if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
-       virtual void canNotFindFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
-#endif
-       virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str);
+       enum PkgSelector { UNKNOWN, REGEX, TASK, FNMATCH, PACKAGENAME, STRING };

 
 

-       virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
-       virtual void canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
+       virtual bool PackageFrom(enum PkgSelector const select, PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern);
+
+       virtual bool PackageFromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline);
+
+       struct PkgModifier {
+               enum Position { NONE, PREFIX, POSTFIX };
+               unsigned short ID;
+               const char * const Alias;
+               Position Pos;
+               PkgModifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {}
+       };
+       virtual bool PackageFromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
+                                           pkgCacheFile &Cache, const char * cmdline,
+                                           std::list<PkgModifier> const &mods);
+
+       // use PackageFrom(PACKAGENAME, …) instead
+       APT_DEPRECATED pkgCache::PkgIterator PackageFromName(pkgCacheFile &Cache, std::string const &pattern);
+
+       /** \brief be notified about the package being selected via pattern
+        *
+        * Main use is probably to show a message to the user what happened
+        *
+        * \param pkg is the package which was selected
+        * \param select is the selection method which choose the package
+        * \param pattern is the string used by the selection method to pick the package
+        */
+       virtual void showPackageSelection(pkgCache::PkgIterator const &pkg, PkgSelector const select, std::string const &pattern);
+       // use the method above instead, react only on the type you need and let the base handle the rest if need be
+       // this allows use to add new selection methods without breaking the ABI constantly with new virtual methods
+       APT_DEPRECATED virtual void showTaskSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
+       APT_DEPRECATED virtual void showRegExSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
+       APT_DEPRECATED virtual void showFnmatchSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
+
+       /** \brief be notified if a package can't be found via pattern
+        *
+        * Can be used to show a message as well as to try something else to make it match
+        *
+        * \param select is the method tried for selection
+        * \param pci is the container the package should be inserted in
+        * \param Cache is the package universe available
+        * \param pattern is the string not matching anything
+        */
+       virtual void canNotFindPackage(enum PkgSelector const select, PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern);
+       // same as above for showPackageSelection
+       APT_DEPRECATED virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
+       APT_DEPRECATED virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
+       APT_DEPRECATED virtual void canNotFindFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
+       APT_DEPRECATED virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str);
+
+       /** \brief specifies which version(s) we want to refer to */
+       enum VerSelector {
+               /** by release string */
+               RELEASE,
+               /** by version number string */
+               VERSIONNUMBER,
+               /** All versions */
+               ALL,
+               /** Candidate and installed version */
+               CANDANDINST,
+               /** Candidate version */
+               CANDIDATE,
+               /** Installed version */
+               INSTALLED,
+               /** Candidate or if non installed version */
+               CANDINST,
+               /** Installed or if non candidate version */
+               INSTCAND,
+               /** Newest version */
+               NEWEST
+       };
+
+       /** \brief be notified about the version being selected via pattern
+        *
+        * Main use is probably to show a message to the user what happened
+        * Note that at the moment this method is only called for RELEASE
+        * and VERSION selections, not for the others.
+        *
+        * \param Pkg is the package which was selected for
+        * \param Ver is the version selected
+        * \param select is the selection method which choose the version
+        * \param pattern is the string used by the selection method to pick the version
+        */
+       virtual void showVersionSelection(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver,
+             enum VerSelector const select, std::string const &pattern);
+       // renamed to have a similar interface to showPackageSelection
+       APT_DEPRECATED virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
+                                std::string const &ver, bool const verIsRel);
+
+       /** \brief be notified if a version can't be found for a package
+        *
+        * Main use is probably to show a message to the user what happened
+        *
+        * \param select is the method tried for selection
+        * \param vci is the container the version should be inserted in
+        * \param Cache is the package universe available
+        * \param Pkg is the package we wanted a version from
+        */
+       virtual void canNotFindVersion(enum VerSelector const select, VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
+       // same as above for showPackageSelection
+       APT_DEPRECATED virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
+       APT_DEPRECATED virtual void canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,

                                pkgCache::PkgIterator const &Pkg);
                                pkgCache::PkgIterator const &Pkg);

-       virtual void canNotFindCandInstVer(VersionContainerInterface * const vci,
+       APT_DEPRECATED virtual void canNotFindCandInstVer(VersionContainerInterface * const vci,

                                pkgCacheFile &Cache,
                                pkgCache::PkgIterator const &Pkg);
 
                                pkgCacheFile &Cache,
                                pkgCache::PkgIterator const &Pkg);
 

-       virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
-       virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,
+       // the difference between canNotFind and canNotGet is that the later is more low-level
+       // and called from other places: In this case looking into the code is the only real answer…
+       virtual pkgCache::VerIterator canNotGetVersion(enum VerSelector const select, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
+       // same as above for showPackageSelection
+       APT_DEPRECATED virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,

                                pkgCache::PkgIterator const &Pkg);
                                pkgCache::PkgIterator const &Pkg);

-       virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,
+       APT_DEPRECATED virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,

                                pkgCache::PkgIterator const &Pkg);
                                pkgCache::PkgIterator const &Pkg);

-       virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,
+       APT_DEPRECATED virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,

                                pkgCache::PkgIterator const &Pkg);
 
                                pkgCache::PkgIterator const &Pkg);
 

+       virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
+

        bool showErrors() const { return ShowError; }
        bool showErrors(bool const newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); }
        GlobalError::MsgType errorType() const { return ErrorType; }
        bool showErrors() const { return ShowError; }
        bool showErrors(bool const newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); }
        GlobalError::MsgType errorType() const { return ErrorType; }


@@ -98,7 +191,21 @@ public:                                                                     /*{{{*/
 protected:
        bool ShowError;
        GlobalError::MsgType ErrorType;
 protected:
        bool ShowError;
        GlobalError::MsgType ErrorType;

+
+       pkgCache::VerIterator canNotGetInstCandVer(pkgCacheFile &Cache,
+               pkgCache::PkgIterator const &Pkg);
+       pkgCache::VerIterator canNotGetCandInstVer(pkgCacheFile &Cache,
+               pkgCache::PkgIterator const &Pkg);
+
+       bool PackageFromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
+       bool PackageFromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
+       bool PackageFromFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
+       bool PackageFromPackageName(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
+       bool PackageFromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern);
+private:
+       void *d;

 };                                                                     /*}}}*/
 };                                                                     /*}}}*/

+

 class PackageContainerInterface {                                      /*{{{*/
 /** \class PackageContainerInterface
 
 class PackageContainerInterface {                                      /*{{{*/
 /** \class PackageContainerInterface
 


@@ -118,7 +225,11 @@ public:
                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 *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(); }
+               APT_DEPRECATED inline const char *Section() const {
+                  APT_IGNORE_DEPRECATED_PUSH
+                     return getPkg().Section();
+                  APT_IGNORE_DEPRECATED_POP
+               }

                inline bool Purge() const {return getPkg().Purge(); }
                inline const char *Arch() const {return getPkg().Arch(); }
                inline pkgCache::GrpIterator Group() const { return getPkg().Group(); }
                inline bool Purge() const {return getPkg().Purge(); }
                inline const char *Arch() const {return getPkg().Arch(); }
                inline pkgCache::GrpIterator Group() const { return getPkg().Group(); }


@@ -142,29 +253,48 @@ public:
        virtual bool empty() const = 0;
        virtual void clear() = 0;
 
        virtual bool empty() const = 0;
        virtual void clear() = 0;
 

-       enum Constructor { UNKNOWN, REGEX, TASK, FNMATCH };
-       virtual void setConstructor(Constructor const &con) = 0;
-       virtual Constructor getConstructor() const = 0;
-
-       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 FromFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string 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);
+       // FIXME: This is a bloody hack removed soon. Use CacheSetHelper::PkgSelector !
+       enum APT_DEPRECATED Constructor { UNKNOWN = CacheSetHelper::UNKNOWN,
+               REGEX = CacheSetHelper::REGEX,
+               TASK = CacheSetHelper::TASK,
+               FNMATCH = CacheSetHelper::FNMATCH };
+APT_IGNORE_DEPRECATED_PUSH
+       void setConstructor(Constructor const by) { ConstructedBy = (CacheSetHelper::PkgSelector)by; }
+APT_IGNORE_DEPRECATED_POP
+
+       void setConstructor(CacheSetHelper::PkgSelector const by) { ConstructedBy = by; }
+       CacheSetHelper::PkgSelector getConstructor() const { return ConstructedBy; }
+       PackageContainerInterface();
+       PackageContainerInterface(CacheSetHelper::PkgSelector const by);
+       virtual ~PackageContainerInterface();
+
+       APT_DEPRECATED static bool FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
+          return helper.PackageFrom(CacheSetHelper::TASK, pci, Cache, pattern); }
+       APT_DEPRECATED static bool FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
+          return helper.PackageFrom(CacheSetHelper::REGEX, pci, Cache, pattern); }
+       APT_DEPRECATED static bool FromFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
+          return helper.PackageFrom(CacheSetHelper::FNMATCH, pci, Cache, pattern); }
+       APT_DEPRECATED static bool FromGroup(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
+          return helper.PackageFrom(CacheSetHelper::PACKAGENAME, pci, Cache, pattern); }
+       APT_DEPRECATED static bool FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
+          return helper.PackageFrom(CacheSetHelper::STRING, pci, Cache, pattern); }
+       APT_DEPRECATED static bool FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
+          return helper.PackageFromCommandLine(pci, Cache, cmdline); }
+
+       APT_DEPRECATED typedef CacheSetHelper::PkgModifier Modifier;
+
+APT_IGNORE_DEPRECATED_PUSH
+       APT_DEPRECATED static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
+          return helper.PackageFromName(Cache, pattern); }
+       APT_DEPRECATED static bool FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
+             pkgCacheFile &Cache, const char * cmdline,
+             std::list<Modifier> const &mods, CacheSetHelper &helper) {
+          return helper.PackageFromModifierCommandLine(modID, pci, Cache, cmdline, mods); }
+APT_IGNORE_DEPRECATED_POP
+
+private:
+       CacheSetHelper::PkgSelector ConstructedBy;
+       void *d;

 };
                                                                        /*}}}*/
 template<class Container> class PackageContainer : public PackageContainerInterface {/*{{{*/
 };
                                                                        /*}}}*/
 template<class Container> class PackageContainer : public PackageContainerInterface {/*{{{*/


@@ -228,11 +358,23 @@ public:                                                                   /*{{{*/
        iterator end() { return iterator(_cont.end()); }
        const_iterator find(pkgCache::PkgIterator const &P) const { return const_iterator(_cont.find(P)); }
 
        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() : PackageContainerInterface(CacheSetHelper::UNKNOWN) {}
+       PackageContainer(CacheSetHelper::PkgSelector const &by) : PackageContainerInterface(by) {}
+APT_IGNORE_DEPRECATED_PUSH
+       APT_DEPRECATED PackageContainer(Constructor const &by) : PackageContainerInterface((CacheSetHelper::PkgSelector)by) {}
+APT_IGNORE_DEPRECATED_POP

 
 

-       PackageContainer() : ConstructedBy(UNKNOWN) {}
-       PackageContainer(Constructor const &by) : ConstructedBy(by) {}
+       /** \brief sort all included versions with given comparer
+
+           Some containers are sorted by default, some are not and can't be,
+           but a few like std::vector can be sorted if need be, so this can be
+           specialized in later on. The default is that this will fail though.
+           Specifically, already sorted containers like std::set will return
+           false as well as there is no easy way to check that the given comparer
+           would sort in the same way the set is currently sorted
+
+           \return \b true if the set was sorted, \b false if not. */
+       template<class Compare> bool sort(Compare /*Comp*/) { return false; }

 
        /** \brief returns all packages in the cache who belong to the given task
 
 
        /** \brief returns all packages in the cache who belong to the given task
 


@@ -243,8 +385,8 @@ public:                                                                     /*{{{*/
            \param pattern name of the task
            \param helper responsible for error and message handling */
        static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
            \param pattern name of the task
            \param helper responsible for error and message handling */
        static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {

-               PackageContainer cont(TASK);
-               PackageContainerInterface::FromTask(&cont, Cache, pattern, helper);
+               PackageContainer cont(CacheSetHelper::TASK);
+               helper.PackageFrom(CacheSetHelper::TASK, &cont, Cache, pattern);

                return cont;
        }
        static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern) {
                return cont;
        }
        static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern) {


@@ -260,9 +402,9 @@ public:                                                                     /*{{{*/
            \param Cache the packages are in
            \param pattern regular expression for package names
            \param helper responsible for error and message handling */
            \param Cache the packages are in
            \param pattern regular expression for package names
            \param helper responsible for error and message handling */

-       static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
-               PackageContainer cont(REGEX);
-               PackageContainerInterface::FromRegEx(&cont, Cache, pattern, helper);
+       static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
+               PackageContainer cont(CacheSetHelper::REGEX);
+               helper.PackageFrom(CacheSetHelper::REGEX, &cont, Cache, pattern);

                return cont;
        }
 
                return cont;
        }
 


@@ -271,9 +413,9 @@ public:                                                                     /*{{{*/
                return FromRegEx(Cache, pattern, helper);
        }
 
                return FromRegEx(Cache, pattern, helper);
        }
 

-       static PackageContainer FromFnmatch(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
-               PackageContainer cont(FNMATCH);
-               PackageContainerInterface::FromFnmatch(&cont, Cache, pattern, helper);
+       static PackageContainer FromFnmatch(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
+               PackageContainer cont(CacheSetHelper::FNMATCH);
+               helper.PackageFrom(CacheSetHelper::FNMATCH, &cont, Cache, pattern);

                return cont;
        }
        static PackageContainer FromFnMatch(pkgCacheFile &Cache, std::string const &pattern) {
                return cont;
        }
        static PackageContainer FromFnMatch(pkgCacheFile &Cache, std::string const &pattern) {


@@ -281,18 +423,20 @@ public:                                                                   /*{{{*/
                return FromFnmatch(Cache, pattern, helper);
        }
 
                return FromFnmatch(Cache, pattern, helper);
        }
 

+APT_IGNORE_DEPRECATED_PUSH

        /** \brief returns a package specified by a string
 
            \param Cache the package is in
            \param pattern String the package name should be extracted from
            \param helper responsible for error and message handling */
        /** \brief returns a package specified by a string
 
            \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 pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
-               return PackageContainerInterface::FromName(Cache, pattern, helper);
+       APT_DEPRECATED static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
+               return helper.PackageFromName(Cache, pattern);

        }
        }

-       static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) {
+       APT_DEPRECATED static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) {

                CacheSetHelper helper;
                CacheSetHelper helper;

-               return PackageContainerInterface::FromName(Cache, pattern, helper);
+               return FromName(Cache, pattern, helper);

        }
        }

+APT_IGNORE_DEPRECATED_POP

 
        /** \brief returns all packages specified by a string
 
 
        /** \brief returns all packages specified by a string
 


@@ -301,7 +445,7 @@ public:                                                                     /*{{{*/
            \param helper responsible for error and message handling */
        static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
                PackageContainer cont;
            \param helper responsible for error and message handling */
        static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
                PackageContainer cont;

-               PackageContainerInterface::FromString(&cont, Cache, pattern, helper);
+               helper.PackageFrom(CacheSetHelper::PACKAGENAME, &cont, Cache, pattern);

                return cont;
        }
        static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) {
                return cont;
        }
        static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) {


@@ -318,7 +462,7 @@ public:                                                                     /*{{{*/
            \param helper responsible for error and message handling */
        static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
                PackageContainer cont;
            \param helper responsible for error and message handling */
        static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
                PackageContainer cont;

-               PackageContainerInterface::FromCommandLine(&cont, Cache, cmdline, helper);
+               helper.PackageFromCommandLine(&cont, Cache, cmdline);

                return cont;
        }
        static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
                return cont;
        }
        static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {


@@ -340,14 +484,14 @@ public:                                                                   /*{{{*/
        static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
                                                                                 pkgCacheFile &Cache,
                                                                                 const char **cmdline,
        static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
                                                                                 pkgCacheFile &Cache,
                                                                                 const char **cmdline,

-                                                                                std::list<Modifier> const &mods,
+                                                                                std::list<CacheSetHelper::PkgModifier> 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;
                                                                                 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);
+                       helper.PackageFromModifierCommandLine(modID, &pkgset, Cache, *I, mods);

                        pkgsets[modID].insert(pkgset);
                }
                return pkgsets;
                        pkgsets[modID].insert(pkgset);
                }
                return pkgsets;


@@ -355,22 +499,23 @@ public:                                                                   /*{{{*/
        static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
                                                                                 pkgCacheFile &Cache,
                                                                                 const char **cmdline,
        static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
                                                                                 pkgCacheFile &Cache,
                                                                                 const char **cmdline,

-                                                                                std::list<Modifier> const &mods,
+                                                                                std::list<CacheSetHelper::PkgModifier> const &mods,

                                                                                 unsigned short const &fallback) {
                CacheSetHelper helper;
                return GroupedFromCommandLine(Cache, cmdline,
                                mods, fallback, helper);
        }
                                                                        /*}}}*/
                                                                                 unsigned short const &fallback) {
                CacheSetHelper helper;
                return GroupedFromCommandLine(Cache, cmdline,
                                mods, fallback, helper);
        }
                                                                        /*}}}*/

-private:                                                               /*{{{*/
-       Constructor ConstructedBy;
-                                                                       /*}}}*/

 };                                                                     /*}}}*/
 };                                                                     /*}}}*/

-
+// specialisations for push_back containers: std::list & std::vector   /*{{{*/

 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);
 }
 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);
 }

+template<> template<class Cont> void PackageContainer<std::vector<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) {
 // 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) {


@@ -379,12 +524,67 @@ template<> inline bool PackageContainer<std::list<pkgCache::PkgIterator> >::inse
        _cont.push_back(P);
        return true;
 }
        _cont.push_back(P);
        return true;
 }

+template<> inline bool PackageContainer<std::vector<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);
 }
 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);
 }

+template<> inline void PackageContainer<std::vector<pkgCache::PkgIterator> >::insert(const_iterator begin, const_iterator end) {
+       for (const_iterator p = begin; p != end; ++p)
+               _cont.push_back(*p);
+}
+                                                                       /*}}}*/
+
+template<> template<class Compare> inline bool PackageContainer<std::vector<pkgCache::PkgIterator> >::sort(Compare Comp) {
+       std::sort(_cont.begin(), _cont.end(), Comp);
+       return true;
+}
+
+// class PackageUniverse - pkgCache as PackageContainerInterface       /*{{{*/
+/** \class PackageUniverse
+
+    Wraps around our usual pkgCache, so that it can be stuffed into methods
+    expecting a PackageContainer.
+
+    The wrapping is read-only in practice modeled by making erase and co
+    private methods. */
+class APT_HIDDEN PackageUniverse : public PackageContainerInterface {
+       pkgCache * const _cont;
+       void *d;
+public:
+       typedef pkgCache::PkgIterator iterator;
+       typedef pkgCache::PkgIterator const_iterator;
+
+       APT_PUBLIC bool empty() const { return false; }
+       APT_PUBLIC size_t size() const { return _cont->Head().PackageCount; }
+
+       APT_PUBLIC const_iterator begin() const { return _cont->PkgBegin(); }
+       APT_PUBLIC const_iterator end() const { return  _cont->PkgEnd(); }
+       APT_PUBLIC iterator begin() { return _cont->PkgBegin(); }
+       APT_PUBLIC iterator end() { return _cont->PkgEnd(); }
+
+       APT_PUBLIC PackageUniverse(pkgCache * const Owner);
+       APT_PUBLIC virtual ~PackageUniverse();
+
+private:
+       bool insert(pkgCache::PkgIterator const &) { return true; }
+       template<class Cont> void insert(PackageContainer<Cont> const &) { }
+       void insert(const_iterator, const_iterator) { }
+
+       void clear() { }
+       iterator& erase(iterator &iter) { return iter; }
+       size_t erase(const pkgCache::PkgIterator) { return 0; }
+       void erase(iterator, iterator) { }
+};
+                                                                       /*}}}*/

 typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet;
 typedef PackageContainer<std::list<pkgCache::PkgIterator> > PackageList;
 typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet;
 typedef PackageContainer<std::list<pkgCache::PkgIterator> > PackageList;

+typedef PackageContainer<std::vector<pkgCache::PkgIterator> > PackageVector;

 
 class VersionContainerInterface {                                      /*{{{*/
 /** \class APT::VersionContainerInterface
 
 class VersionContainerInterface {                                      /*{{{*/
 /** \class APT::VersionContainerInterface


@@ -426,45 +626,63 @@ public:
        virtual void clear() = 0;
 
        /** \brief specifies which version(s) will be returned if non is given */
        virtual void clear() = 0;
 
        /** \brief specifies which version(s) will be returned if non is given */

-       enum Version {
-               /** All versions */
-               ALL,
-               /** Candidate and installed version */
-               CANDANDINST,
-               /** Candidate version */
-               CANDIDATE,
-               /** Installed version */
-               INSTALLED,
-               /** Candidate or if non installed version */
-               CANDINST,
-               /** Installed or if non candidate version */
-               INSTCAND,
-               /** Newest version */
-               NEWEST
+       enum APT_DEPRECATED Version {
+               ALL = CacheSetHelper::ALL,
+               CANDANDINST = CacheSetHelper::CANDANDINST,
+               CANDIDATE = CacheSetHelper::CANDIDATE,
+               INSTALLED = CacheSetHelper::INSTALLED,
+               CANDINST = CacheSetHelper::CANDINST,
+               INSTCAND = CacheSetHelper::INSTCAND,
+               NEWEST = CacheSetHelper::NEWEST

        };
 
        struct Modifier {
        };
 
        struct Modifier {

-               enum Position { NONE, PREFIX, POSTFIX };
-               unsigned short ID;
+               unsigned short const ID;

                const char * const Alias;
                const char * const Alias;

-               Position Pos;
-               Version SelectVersion;
+               enum Position { NONE, PREFIX, POSTFIX } const Pos;
+               enum CacheSetHelper::VerSelector const SelectVersion;

                Modifier (unsigned short const &id, const char * const alias, Position const &pos,
                Modifier (unsigned short const &id, const char * const alias, Position const &pos,

-                         Version const &select) : ID(id), Alias(alias), Pos(pos),
+                         enum CacheSetHelper::VerSelector const select) : ID(id), Alias(alias), Pos(pos),

                         SelectVersion(select) {}
                         SelectVersion(select) {}

+APT_IGNORE_DEPRECATED_PUSH
+               APT_DEPRECATED Modifier(unsigned short const &id, const char * const alias, Position const &pos,
+                         Version const &select) : ID(id), Alias(alias), Pos(pos),
+                        SelectVersion((CacheSetHelper::VerSelector)select) {}
+APT_IGNORE_DEPRECATED_POP

        };
 
        static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
        };
 
        static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,

-                                   const char **cmdline, Version const &fallback,
+                                   const char **cmdline, CacheSetHelper::VerSelector const fallback,

                                    CacheSetHelper &helper);
                                    CacheSetHelper &helper);

+APT_IGNORE_DEPRECATED_PUSH
+       APT_DEPRECATED static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
+                                   const char **cmdline, Version const &fallback,
+                                   CacheSetHelper &helper) {
+          return FromCommandLine(vci, Cache, cmdline, (CacheSetHelper::VerSelector)fallback, helper);
+       }
+APT_IGNORE_DEPRECATED_POP

 
        static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 
        static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,

-                              std::string pkg, Version const &fallback, CacheSetHelper &helper,
+                              std::string pkg, CacheSetHelper::VerSelector const fallback, CacheSetHelper &helper,

                               bool const onlyFromName = false);
                               bool const onlyFromName = false);

+APT_IGNORE_DEPRECATED_PUSH
+       APT_DEPRECATED static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
+                              std::string pkg, Version const &fallback, CacheSetHelper &helper,
+                              bool const onlyFromName = false) {
+          return FromString(vci, Cache, pkg, (CacheSetHelper::VerSelector)fallback, helper, onlyFromName);
+       }
+APT_IGNORE_DEPRECATED_POP

 
        static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 
        static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,

-                               pkgCache::PkgIterator const &P, Version const &fallback,
+                               pkgCache::PkgIterator const &P, CacheSetHelper::VerSelector const fallback,

                                CacheSetHelper &helper);
                                CacheSetHelper &helper);

+APT_IGNORE_DEPRECATED_PUSH
+       APT_DEPRECATED static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
+                               pkgCache::PkgIterator const &P, Version const &fallback,
+                               CacheSetHelper &helper) {
+          return FromPackage(vci, Cache, P, (CacheSetHelper::VerSelector)fallback, helper);
+       }
+APT_IGNORE_DEPRECATED_POP

 
        static bool FromModifierCommandLine(unsigned short &modID,
                                            VersionContainerInterface * const vci,
 
        static bool FromModifierCommandLine(unsigned short &modID,
                                            VersionContainerInterface * const vci,


@@ -476,8 +694,22 @@ public:
        static bool FromDependency(VersionContainerInterface * const vci,
                                   pkgCacheFile &Cache,
                                   pkgCache::DepIterator const &D,
        static bool FromDependency(VersionContainerInterface * const vci,
                                   pkgCacheFile &Cache,
                                   pkgCache::DepIterator const &D,

-                                  Version const &selector,
+                                  CacheSetHelper::VerSelector const selector,

                                   CacheSetHelper &helper);
                                   CacheSetHelper &helper);

+APT_IGNORE_DEPRECATED_PUSH
+       APT_DEPRECATED static bool FromDependency(VersionContainerInterface * const vci,
+                                  pkgCacheFile &Cache,
+                                  pkgCache::DepIterator const &D,
+                                  Version const &selector,
+                                  CacheSetHelper &helper) {
+          return FromDependency(vci, Cache, D, (CacheSetHelper::VerSelector)selector, helper);
+       }
+APT_IGNORE_DEPRECATED_POP
+
+       VersionContainerInterface();
+       virtual ~VersionContainerInterface();
+private:
+       void *d;

 
 protected:                                                             /*{{{*/
 
 
 protected:                                                             /*{{{*/
 


@@ -559,6 +791,18 @@ public:                                                                    /*{{{*/
        iterator end() { return iterator(_cont.end()); }
        const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); }
 
        iterator end() { return iterator(_cont.end()); }
        const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); }
 

+       /** \brief sort all included versions with given comparer
+
+           Some containers are sorted by default, some are not and can't be,
+           but a few like std::vector can be sorted if need be, so this can be
+           specialized in later on. The default is that this will fail though.
+           Specifically, already sorted containers like std::set will return
+           false as well as there is no easy way to check that the given comparer
+           would sort in the same way the set is currently sorted
+
+           \return \b true if the set was sorted, \b false if not. */
+       template<class Compare> bool sort(Compare /*Comp*/) { return false; }
+

        /** \brief returns all versions specified on the commandline
 
            Get all versions from the commandline, uses given default version if
        /** \brief returns all versions specified on the commandline
 
            Get all versions from the commandline, uses given default version if


@@ -568,35 +812,59 @@ public:                                                                   /*{{{*/
            \param fallback version specification
            \param helper responsible for error and message handling */
        static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
            \param fallback version specification
            \param helper responsible for error and message handling */
        static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,

-                       Version const &fallback, CacheSetHelper &helper) {
+                       CacheSetHelper::VerSelector const fallback, CacheSetHelper &helper) {

                VersionContainer vercon;
                VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper);
                return vercon;
        }
        static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
                VersionContainer vercon;
                VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper);
                return vercon;
        }
        static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,

-                       Version const &fallback) {
+                       CacheSetHelper::VerSelector const fallback) {

                CacheSetHelper helper;
                return FromCommandLine(Cache, cmdline, fallback, helper);
        }
        static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
                CacheSetHelper helper;
                return FromCommandLine(Cache, cmdline, fallback, helper);
        }
        static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {

-               return FromCommandLine(Cache, cmdline, CANDINST);
+               return FromCommandLine(Cache, cmdline, CacheSetHelper::CANDINST);

        }
        }

-

        static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,
        static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,

-                       Version const &fallback, CacheSetHelper &helper,
+                       CacheSetHelper::VerSelector 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,
                                            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::VerSelector const fallback) {

                CacheSetHelper helper;
                return FromString(Cache, pkg, fallback, helper);
        }
        static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) {
                CacheSetHelper helper;
                return FromString(Cache, pkg, fallback, helper);
        }
        static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) {

-               return FromString(Cache, pkg, CANDINST);
+               return FromString(Cache, pkg, CacheSetHelper::CANDINST);
+       }
+APT_IGNORE_DEPRECATED_PUSH
+       static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
+                       Version const &fallback, CacheSetHelper &helper) {
+               VersionContainer vercon;
+               VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, (CacheSetHelper::VerSelector)fallback, helper);
+               return vercon;
+       }
+       static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
+                       Version const &fallback) {
+               CacheSetHelper helper;
+               return FromCommandLine(Cache, cmdline, (CacheSetHelper::VerSelector)fallback, helper);
+       }
+       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, (CacheSetHelper::VerSelector)fallback, helper);
+               return vercon;
+       }
+       static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg,
+                       Version const &fallback) {
+               CacheSetHelper helper;
+               return FromString(Cache, pkg, (CacheSetHelper::VerSelector)fallback, helper);

        }
        }

+APT_IGNORE_DEPRECATED_POP

 
        /** \brief returns all versions specified for the package
 
 
        /** \brief returns all versions specified for the package
 


@@ -605,18 +873,31 @@ public:                                                                   /*{{{*/
            \param fallback the version(s) you want to get
            \param helper the helper used for display and error handling */
        static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
            \param fallback the version(s) you want to get
            \param helper the helper used for display and error handling */
        static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,

-               Version const &fallback, CacheSetHelper &helper) {
+               CacheSetHelper::VerSelector const fallback, CacheSetHelper &helper) {

                VersionContainer vercon;
                VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper);
                return vercon;
        }
        static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
                VersionContainer vercon;
                VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper);
                return vercon;
        }
        static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,

-                                           Version const &fallback) {
+                                           CacheSetHelper::VerSelector const fallback) {

                CacheSetHelper helper;
                return FromPackage(Cache, P, fallback, helper);
        }
                CacheSetHelper helper;
                return FromPackage(Cache, P, fallback, helper);
        }

+APT_IGNORE_DEPRECATED_PUSH
+       static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
+               Version const &fallback, CacheSetHelper &helper) {
+               VersionContainer vercon;
+               VersionContainerInterface::FromPackage(&vercon, Cache, P, (CacheSetHelper::VerSelector)fallback, helper);
+               return vercon;
+       }
+       static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
+                                           Version const &fallback) {
+               CacheSetHelper helper;
+               return FromPackage(Cache, P, (CacheSetHelper::VerSelector)fallback, helper);
+       }
+APT_IGNORE_DEPRECATED_POP

        static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
        static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {

-               return FromPackage(Cache, P, CANDIDATE);
+               return FromPackage(Cache, P, CacheSetHelper::CANDIDATE);

        }
 
        static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
        }
 
        static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(


@@ -645,26 +926,43 @@ public:                                                                   /*{{{*/
        }
 
        static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
        }
 
        static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,

-                                              Version const &selector, CacheSetHelper &helper) {
+                                              CacheSetHelper::VerSelector const selector, CacheSetHelper &helper) {

                VersionContainer vercon;
                VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper);
                return vercon;
        }
        static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
                VersionContainer vercon;
                VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper);
                return vercon;
        }
        static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,

-                                              Version const &selector) {
+                                              CacheSetHelper::VerSelector const selector) {

                CacheSetHelper helper;
                return FromPackage(Cache, D, selector, helper);
        }
                CacheSetHelper helper;
                return FromPackage(Cache, D, selector, helper);
        }

+APT_IGNORE_DEPRECATED_PUSH
+       static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
+                                              Version const &selector, CacheSetHelper &helper) {
+               VersionContainer vercon;
+               VersionContainerInterface::FromDependency(&vercon, Cache, D, (CacheSetHelper::VerSelector)selector, helper);
+               return vercon;
+       }
+       static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
+                                              Version const &selector) {
+               CacheSetHelper helper;
+               return FromPackage(Cache, D, (CacheSetHelper::VerSelector)selector, helper);
+       }
+APT_IGNORE_DEPRECATED_POP

        static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) {
        static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) {

-               return FromPackage(Cache, D, CANDIDATE);
+               return FromPackage(Cache, D, CacheSetHelper::CANDIDATE);

        }
                                                                        /*}}}*/
 };                                                                     /*}}}*/
        }
                                                                        /*}}}*/
 };                                                                     /*}}}*/

-
+// specialisations for push_back containers: std::list & std::vector   /*{{{*/

 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);
 }
 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);
 }

+template<> template<class Cont> void VersionContainer<std::vector<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) {
 // 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) {


@@ -673,11 +971,29 @@ template<> inline bool VersionContainer<std::list<pkgCache::VerIterator> >::inse
        _cont.push_back(V);
        return true;
 }
        _cont.push_back(V);
        return true;
 }

+template<> inline bool VersionContainer<std::vector<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);
 }
 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);
 }

+template<> inline void VersionContainer<std::vector<pkgCache::VerIterator> >::insert(const_iterator begin, const_iterator end) {
+       for (const_iterator v = begin; v != end; ++v)
+               _cont.push_back(*v);
+}
+                                                                       /*}}}*/
+
+template<> template<class Compare> inline bool VersionContainer<std::vector<pkgCache::VerIterator> >::sort(Compare Comp) {
+       std::sort(_cont.begin(), _cont.end(), Comp);
+       return true;
+}
+

 typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet;
 typedef VersionContainer<std::list<pkgCache::VerIterator> > VersionList;
 typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet;
 typedef VersionContainer<std::list<pkgCache::VerIterator> > VersionList;

+typedef VersionContainer<std::vector<pkgCache::VerIterator> > VersionVector;

 }
 #endif
 }
 #endif