Merge remote-tracking branch 'mvo/feature/apt-binary2' into debian/sid

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

diff --git a/apt-pkg/cacheset.h b/apt-pkg/cacheset.h
index d1e396e0f1dae5d6d79b806a81a69a7d765daac0..29103aad9c3f4cffb5dd66c498cb20a5bb02dc57 100644 (file)
--- a/apt-pkg/cacheset.h
+++ b/apt-pkg/cacheset.h
@@ -11,7 +11,6 @@
 // Include Files                                                       /*{{{*/
 #include <iostream>
 #include <fstream>
 // Include Files                                                       /*{{{*/
 #include <iostream>
 #include <fstream>

-#include <list>

 #include <map>
 #include <set>
 #include <list>
 #include <map>
 #include <set>
 #include <list>


@@ -20,6 +19,10 @@
 
 #include <apt-pkg/error.h>
 #include <apt-pkg/pkgcache.h>
 
 #include <apt-pkg/error.h>
 #include <apt-pkg/pkgcache.h>

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

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


@@ -128,13 +131,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);
 


@@ -182,11 +187,13 @@ public:                                                                   /*{{{*/
                pkgCache::PkgIterator getPkg(void) const { return *_iter; }
                inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
                operator typename Container::iterator(void) const { return _iter; }
                pkgCache::PkgIterator getPkg(void) const { return *_iter; }
                inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
                operator typename Container::iterator(void) const { return _iter; }

-               operator typename PackageContainer<Container>::const_iterator() { return 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 bool operator!=(iterator const &i) const { return _iter != i._iter; };
                inline bool operator==(iterator const &i) const { return _iter == i._iter; };
                inline iterator& operator++() { ++_iter; return *this; }
                inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
                inline bool operator!=(iterator const &i) const { return _iter != i._iter; };
                inline bool operator==(iterator const &i) const { return _iter == i._iter; };

+               inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; };
+               inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; };

                friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
        };
                                                                        /*}}}*/
                friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
        };
                                                                        /*}}}*/


@@ -197,7 +204,9 @@ public:                                                                     /*{{{*/
 
        bool empty() const { return _cont.empty(); };
        void clear() { return _cont.clear(); };
 
        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); };
        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(); };
        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(); };


@@ -251,6 +260,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


@@ -498,11 +517,13 @@ public:                                                                   /*{{{*/
                pkgCache::VerIterator getVer(void) const { return *_iter; }
                inline pkgCache::VerIterator operator*(void) const { return *_iter; };
                operator typename Container::iterator(void) const { return _iter; }
                pkgCache::VerIterator getVer(void) const { return *_iter; }
                inline pkgCache::VerIterator operator*(void) const { return *_iter; };
                operator typename Container::iterator(void) const { return _iter; }

-               operator typename VersionContainer<Container>::const_iterator() { return 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 bool operator!=(iterator const &i) const { return _iter != i._iter; };
                inline bool operator==(iterator const &i) const { return _iter == i._iter; };
                inline iterator& operator++() { ++_iter; return *this; }
                inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
                inline bool operator!=(iterator const &i) const { return _iter != i._iter; };
                inline bool operator==(iterator const &i) const { return _iter == i._iter; };

+               inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; };
+               inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; };

                friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
        };
                                                                        /*}}}*/
                friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
        };
                                                                        /*}}}*/


@@ -512,7 +533,9 @@ public:                                                                     /*{{{*/
        void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
        bool empty() const { return _cont.empty(); };
        void clear() { return _cont.clear(); };
        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); };
        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(); };
        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(); };