initialize Verify in second pkgAcqIndex constructor

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

diff --git a/apt-pkg/cacheset.h b/apt-pkg/cacheset.h
index d1e396e0f1dae5d6d79b806a81a69a7d765daac0..16a3daa423cfcb8101c85c4712aee14d302da44c 100644 (file)
--- a/apt-pkg/cacheset.h
+++ b/apt-pkg/cacheset.h
@@ -9,17 +9,25 @@
 #ifndef APT_CACHESET_H
 #define APT_CACHESET_H
 // Include Files                                                       /*{{{*/
 #ifndef APT_CACHESET_H
 #define APT_CACHESET_H
 // Include Files                                                       /*{{{*/

-#include <iostream>

 #include <fstream>
 #include <fstream>

-#include <list>

 #include <map>
 #include <set>
 #include <list>
 #include <string>
 #include <iterator>
 
 #include <map>
 #include <set>
 #include <list>
 #include <string>
 #include <iterator>
 

+#include <stddef.h>
+

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

+#include <apt-pkg/cacheiterators.h>
+
+#ifndef APT_8_CLEANER_HEADERS
+#include <apt-pkg/cachefile.h>
+#endif
+#ifndef APT_10_CLEANER_HEADERS
+#include <iostream>
+#endif

                                                                        /*}}}*/
 
 class pkgCacheFile;
                                                                        /*}}}*/
 
 class pkgCacheFile;


@@ -40,16 +48,22 @@ class CacheSetHelper {                                                      /*{{{*/
 public:                                                                        /*{{{*/
        CacheSetHelper(bool const ShowError = true,
                GlobalError::MsgType ErrorType = GlobalError::ERROR) :
 public:                                                                        /*{{{*/
        CacheSetHelper(bool const ShowError = true,
                GlobalError::MsgType ErrorType = GlobalError::ERROR) :

-                       ShowError(ShowError), ErrorType(ErrorType) {};
-       virtual ~CacheSetHelper() {};
+                       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);
 
        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);
 
        virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
        virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
        virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
                                 std::string const &ver, bool const verIsRel);
 
        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);
 
        virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
        virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str);
 
        virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);


@@ -67,9 +81,9 @@ public:                                                                       /*{{{*/
        virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,
                                pkgCache::PkgIterator const &Pkg);
 
        virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,
                                pkgCache::PkgIterator const &Pkg);
 

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

        GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
        {
                if (ErrorType == newValue) return ErrorType;
        GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
        {
                if (ErrorType == newValue) return ErrorType;


@@ -78,7 +92,7 @@ public:                                                                       /*{{{*/
                        ErrorType = newValue;
                        return oldValue;
                }
                        ErrorType = newValue;
                        return oldValue;
                }

-       };
+       }

 
                                                                        /*}}}*/
 protected:
 
                                                                        /*}}}*/
 protected:


@@ -115,12 +129,12 @@ public:
                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::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();};
+               inline pkgCache *Cache() const { return getPkg().Cache(); }
+               inline unsigned long Index() const {return getPkg().Index();}

                // we have only valid iterators here
                // we have only valid iterators here

-               inline bool end() const { return false; };
+               inline bool end() const { return false; }

 
 

-               inline pkgCache::Package const * operator->() const {return &*getPkg();};
+               inline pkgCache::Package const * operator->() const {return &*getPkg();}

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


@@ -128,13 +142,15 @@ public:
        virtual bool empty() const = 0;
        virtual void clear() = 0;
 
        virtual bool empty() const = 0;
        virtual void clear() = 0;
 

-       enum Constructor { UNKNOWN, REGEX, TASK };
+       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);
        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);
 
        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);
 


@@ -143,7 +159,7 @@ public:
                unsigned short ID;
                const char * const Alias;
                Position Pos;
                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) {};
+               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,
        };
 
        static bool FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,


@@ -166,12 +182,12 @@ public:                                                                   /*{{{*/
        public:
                const_iterator(typename Container::const_iterator i) : _iter(i) {}
                pkgCache::PkgIterator getPkg(void) const { return *_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; };
+               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; }
                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; };
+               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,
                friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
        };
        class iterator : public PackageContainerInterface::const_iterator,


@@ -180,39 +196,43 @@ public:                                                                   /*{{{*/
        public:
                iterator(typename Container::iterator i) : _iter(i) {}
                pkgCache::PkgIterator getPkg(void) const { return *_iter; }
        public:
                iterator(typename Container::iterator i) : _iter(i) {}
                pkgCache::PkgIterator getPkg(void) const { return *_iter; }

-               inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
+               inline pkgCache::PkgIterator operator*(void) const { return *_iter; }

                operator typename Container::iterator(void) const { return _iter; }
                operator typename Container::iterator(void) const { return _iter; }

-               operator typename PackageContainer<Container>::const_iterator() { return PackageContainer<Container>::const_iterator(_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 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 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); }
        };
                                                                        /*}}}*/
 
                friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
        };
                                                                        /*}}}*/
 

-       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 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(); };
-       void erase(iterator 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(); };
+       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)); };
+       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; };
+       void setConstructor(Constructor const &by) { ConstructedBy = by; }
+       Constructor getConstructor() const { return ConstructedBy; }

 
 

-       PackageContainer() : ConstructedBy(UNKNOWN) {};
-       PackageContainer(Constructor const &by) : ConstructedBy(by) {};
+       PackageContainer() : ConstructedBy(UNKNOWN) {}
+       PackageContainer(Constructor const &by) : ConstructedBy(by) {}

 
        /** \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
 


@@ -251,6 +271,16 @@ 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);
+               return cont;
+       }
+       static PackageContainer FromFnMatch(pkgCacheFile &Cache, std::string const &pattern) {
+               CacheSetHelper helper;
+               return FromFnmatch(Cache, pattern, helper);
+       }
+

        /** \brief returns a package specified by a string
 
            \param Cache the package is in
        /** \brief returns a package specified by a string
 
            \param Cache the package is in


@@ -340,7 +370,7 @@ private:                                                            /*{{{*/
 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);

-};
+}

 // 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) {


@@ -348,11 +378,11 @@ template<> inline bool PackageContainer<std::list<pkgCache::PkgIterator> >::inse
                return false;
        _cont.push_back(P);
        return 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);

-};
+}

 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;
 


@@ -367,27 +397,27 @@ public:
                virtual pkgCache::VerIterator getVer() const = 0;
                operator pkgCache::VerIterator(void) { return getVer(); }
 
                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(); };
+               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
                // we have only valid iterators here

-               inline bool end() const { return false; };
+               inline bool end() const { return false; }

 
 

-               inline pkgCache::Version const * operator->() const { return &*getVer(); };
+               inline pkgCache::Version const * operator->() const { return &*getVer(); }

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


@@ -421,7 +451,7 @@ public:
                Version SelectVersion;
                Modifier (unsigned short const &id, const char * const alias, Position const &pos,
                          Version const &select) : ID(id), Alias(alias), Pos(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) {};
+                        SelectVersion(select) {}

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


@@ -454,14 +484,16 @@ protected:                                                                /*{{{*/
        /** \brief returns the candidate version of the package
 
            \param Cache to be used to query for information
        /** \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 */
+           \param Pkg we want the candidate version from this package
+           \param helper used in this container instance */

        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
        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 */
+           \param Pkg we want the installed version from this package
+           \param helper used in this container instance */

        static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
                pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
                                                                        /*}}}*/
        static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
                pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
                                                                        /*}}}*/


@@ -482,12 +514,12 @@ public:                                                                   /*{{{*/
        public:
                const_iterator(typename Container::const_iterator i) : _iter(i) {}
                pkgCache::VerIterator getVer(void) const { return *_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; };
+               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; }
                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; };
+               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,
                friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
        };
        class iterator : public VersionContainerInterface::const_iterator,


@@ -496,32 +528,36 @@ public:                                                                   /*{{{*/
        public:
                iterator(typename Container::iterator i) : _iter(i) {}
                pkgCache::VerIterator getVer(void) const { return *_iter; }
        public:
                iterator(typename Container::iterator i) : _iter(i) {}
                pkgCache::VerIterator getVer(void) const { return *_iter; }

-               inline pkgCache::VerIterator operator*(void) const { return *_iter; };
+               inline pkgCache::VerIterator operator*(void) const { return *_iter; }

                operator typename Container::iterator(void) const { return _iter; }
                operator typename Container::iterator(void) const { return _iter; }

-               operator typename VersionContainer<Container>::const_iterator() { return VersionContainer<Container>::const_iterator(_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 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 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); }
        };
                                                                        /*}}}*/
 
                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(); };
-       void erase(iterator 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)); };
+       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
 
 
        /** \brief returns all versions specified on the commandline
 


@@ -529,6 +565,7 @@ public:                                                                     /*{{{*/
            non specifically requested  and executes regex's if needed on names.
            \param Cache the packages and versions are in
            \param cmdline Command line the versions should be extracted from
            non specifically requested  and executes regex's if needed on names.
            \param Cache the packages and versions are in
            \param cmdline Command line the versions should be extracted from

+           \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) {
            \param helper responsible for error and message handling */
        static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
                        Version const &fallback, CacheSetHelper &helper) {


@@ -627,7 +664,7 @@ public:                                                                     /*{{{*/
 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);

-};
+}

 // 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) {


@@ -635,11 +672,11 @@ template<> inline bool VersionContainer<std::list<pkgCache::VerIterator> >::inse
                return false;
        _cont.push_back(V);
        return 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);

-};
+}

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