be sure that the RFC1123StrToTime method is run in a LANG=C environment

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

diff --git a/apt-pkg/cacheset.h b/apt-pkg/cacheset.h
index 7c05face69dbeab1f5366847405ade8a3148a7e3..668d8039e0254a134a01135112ab0e74201650af 100644 (file)
--- a/apt-pkg/cacheset.h
+++ b/apt-pkg/cacheset.h
@@ -11,18 +11,21 @@
 // Include Files                                                       /*{{{*/
 #include <iostream>
 #include <fstream>
 // Include Files                                                       /*{{{*/
 #include <iostream>
 #include <fstream>

+#include <list>
+#include <map>

 #include <set>
 #include <string>
 
 #include <set>
 #include <string>
 

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

 #include <apt-pkg/pkgcache.h>
                                                                        /*}}}*/
 namespace APT {
 #include <apt-pkg/pkgcache.h>
                                                                        /*}}}*/
 namespace APT {

+class PackageSet : public std::set<pkgCache::PkgIterator> {            /*{{{*/

 /** \class APT::PackageSet
 
     Simple wrapper around a std::set to provide a similar interface to
     a set of packages as to the complete set of all packages in the
     pkgCache. */
 /** \class APT::PackageSet
 
     Simple wrapper around a std::set to provide a similar interface to
     a set of packages as to the complete set of all packages in the
     pkgCache. */

-class PackageSet : public std::set<pkgCache::PkgIterator> {            /*{{{*/

 public:                                                                        /*{{{*/
        /** \brief smell like a pkgCache::PkgIterator */
        class const_iterator : public std::set<pkgCache::PkgIterator>::const_iterator {
 public:                                                                        /*{{{*/
        /** \brief smell like a pkgCache::PkgIterator */
        class const_iterator : public std::set<pkgCache::PkgIterator>::const_iterator {


@@ -58,7 +61,10 @@ public:                                                                      /*{{{*/
                };
        };
        // 103. set::iterator is required to be modifiable, but this allows modification of keys
                };
        };
        // 103. set::iterator is required to be modifiable, but this allows modification of keys

-       typedef typename APT::PackageSet::const_iterator iterator;
+       typedef APT::PackageSet::const_iterator iterator;
+
+       using std::set<pkgCache::PkgIterator>::insert;
+       inline void insert(pkgCache::PkgIterator const &P) { if (P.end() == false) std::set<pkgCache::PkgIterator>::insert(P); };

 
        /** \brief returns all packages in the cache whose name matchs a given pattern
 
 
        /** \brief returns all packages in the cache whose name matchs a given pattern
 


@@ -68,12 +74,23 @@ public:                                                                     /*{{{*/
            \param Cache the packages are in
            \param pattern regular expression for package names
            \param out stream to print the notice to */
            \param Cache the packages are in
            \param pattern regular expression for package names
            \param out stream to print the notice to */

-       static APT::PackageSet FromRegEx(pkgCache &Cache, std::string pattern, std::ostream &out);
-       static APT::PackageSet FromRegEx(pkgCache &Cache, std::string const &pattern) {
+       static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string pattern, std::ostream &out);
+       static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {

                std::ostream out (std::ofstream("/dev/null").rdbuf());
                return APT::PackageSet::FromRegEx(Cache, pattern, out);
        }
 
                std::ostream out (std::ofstream("/dev/null").rdbuf());
                return APT::PackageSet::FromRegEx(Cache, pattern, out);
        }
 

+       /** \brief returns all packages specified by a string
+
+           \param Cache the packages are in
+           \param string String the package name(s) should be extracted from
+           \param out stream to print various notices to */
+       static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string, std::ostream &out);
+       static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string) {
+               std::ostream out (std::ofstream("/dev/null").rdbuf());
+               return APT::PackageSet::FromString(Cache, string, out);
+       }
+

        /** \brief returns all packages specified on the commandline
 
            Get all package names from the commandline and executes regex's if needed.
        /** \brief returns all packages specified on the commandline
 
            Get all package names from the commandline and executes regex's if needed.


@@ -81,16 +98,142 @@ public:                                                                    /*{{{*/
            \param Cache the packages are in
            \param cmdline Command line the package names should be extracted from
            \param out stream to print various notices to */
            \param Cache the packages are in
            \param cmdline Command line the package names should be extracted from
            \param out stream to print various notices to */

-       static APT::PackageSet FromCommandLine(pkgCache &Cache, const char **cmdline, std::ostream &out);
-       static APT::PackageSet FromCommandLine(pkgCache &Cache, const char **cmdline) {
+       static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline, std::ostream &out);
+       static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {

                std::ostream out (std::ofstream("/dev/null").rdbuf());
                return APT::PackageSet::FromCommandLine(Cache, cmdline, out);
        }
 
                std::ostream out (std::ofstream("/dev/null").rdbuf());
                return APT::PackageSet::FromCommandLine(Cache, cmdline, out);
        }
 

+       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 std::map<unsigned short, PackageSet> GroupedFromCommandLine(
+               pkgCacheFile &Cache, const char **cmdline,
+               std::list<PackageSet::Modifier> const &mods,
+               unsigned short const &fallback, std::ostream &out);
+       static std::map<unsigned short, PackageSet> GroupedFromCommandLine(
+               pkgCacheFile &Cache, const char **cmdline,
+               std::list<PackageSet::Modifier> const &mods,
+               unsigned short const &fallback) {
+               std::ostream out (std::ofstream("/dev/null").rdbuf());
+               return APT::PackageSet::GroupedFromCommandLine(Cache, cmdline,
+                               mods, fallback, out);
+       }
+                                                                       /*}}}*/
+};                                                                     /*}}}*/
+class VersionSet : public std::set<pkgCache::VerIterator> {            /*{{{*/
+/** \class APT::VersionSet
+
+    Simple wrapper around a std::set to provide a similar interface to
+    a set of versions as to the complete set of all versions in the
+    pkgCache. */
+public:                                                                        /*{{{*/
+       /** \brief smell like a pkgCache::VerIterator */
+       class const_iterator : public std::set<pkgCache::VerIterator>::const_iterator {
+       public:
+               const_iterator(std::set<pkgCache::VerIterator>::const_iterator x) :
+                        std::set<pkgCache::VerIterator>::const_iterator(x) {}

 
 

+               operator pkgCache::VerIterator(void) { return **this; }
+
+               inline pkgCache *Cache() const { return (**this).Cache(); };
+               inline unsigned long Index() const {return (**this).Index();};
+               // we have only valid iterators here
+               inline bool end() const { return false; };
+
+               inline pkgCache::Version const * operator->() const {
+                       return &***this;
+               };
+
+               inline int CompareVer(const pkgCache::VerIterator &B) const { return (**this).CompareVer(B); };
+               inline const char *VerStr() const { return (**this).VerStr(); };
+               inline const char *Section() const { return (**this).Section(); };
+               inline const char *Arch() const { return (**this).Arch(); };
+               inline const char *Arch(bool const pseudo) const { return (**this).Arch(pseudo); };
+               inline pkgCache::PkgIterator ParentPkg() const { return (**this).ParentPkg(); };
+               inline pkgCache::DescIterator DescriptionList() const { return (**this).DescriptionList(); };
+               inline pkgCache::DescIterator TranslatedDescription() const { return (**this).TranslatedDescription(); };
+               inline pkgCache::DepIterator DependsList() const { return (**this).DependsList(); };
+               inline pkgCache::PrvIterator ProvidesList() const { return (**this).ProvidesList(); };
+               inline pkgCache::VerFileIterator FileList() const { return (**this).FileList(); };
+               inline bool Downloadable() const { return (**this).Downloadable(); };
+               inline const char *PriorityType() const { return (**this).PriorityType(); };
+               inline string RelStr() const { return (**this).RelStr(); };
+               inline bool Automatic() const { return (**this).Automatic(); };
+               inline bool Pseudo() const { return (**this).Pseudo(); };
+               inline pkgCache::VerFileIterator NewestFile() const { return (**this).NewestFile(); };
+       };
+       // 103. set::iterator is required to be modifiable, but this allows modification of keys
+       typedef APT::VersionSet::const_iterator iterator;
+
+       using std::set<pkgCache::VerIterator>::insert;
+       inline void insert(pkgCache::VerIterator const &V) { if (V.end() == false) std::set<pkgCache::VerIterator>::insert(V); };
+
+       /** \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
+       };
+
+       /** \brief returns all versions specified on the commandline
+
+           Get all versions from the commandline, uses given default version if
+           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 out stream to print various notices to */
+       static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
+                       APT::VersionSet::Version const &fallback, std::ostream &out);
+       static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
+                       APT::VersionSet::Version const &fallback) {
+               std::ostream out (std::ofstream("/dev/null").rdbuf());
+               return APT::VersionSet::FromCommandLine(Cache, cmdline, fallback, out);
+       }
+       static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
+               return APT::VersionSet::FromCommandLine(Cache, cmdline, CANDINST);
+       }

                                                                        /*}}}*/
                                                                        /*}}}*/

-};
+protected:                                                             /*{{{*/
+
+       /** \brief returns the candidate version of the package
+
+           \param Cache to be used to query for information
+           \param Pkg we want the candidate version from this package
+           \param AllowError add an error to the stack if not */
+       static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache,
+               pkgCache::PkgIterator const &Pkg, bool const &AllowError = false);
+
+       /** \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 AllowError add an error to the stack if not */
+       static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
+               pkgCache::PkgIterator const &Pkg, bool const &AllowError = false);
+
+
+       static bool AddSelectedVersion(pkgCacheFile &Cache, VersionSet &verset,
+               pkgCache::PkgIterator const &P, VersionSet::Version const &fallback,
+               bool const &AllowError = false);
+

                                                                        /*}}}*/
                                                                        /*}}}*/

+};                                                                     /*}}}*/

 }
 #endif
 }
 #endif