German translation proof read by Helge Kreutzmann

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

diff --git a/apt-pkg/cachefilter.h b/apt-pkg/cachefilter.h
index 34b7d0b46eb634f4b67ddf9bb7470ecf9b50c33e..30a3368e59df64bdca83f4bec7cff1e81c502f4e 100644 (file)
--- a/apt-pkg/cachefilter.h
+++ b/apt-pkg/cachefilter.h
@@ -7,123 +7,122 @@
 #define APT_CACHEFILTER_H
 // Include Files                                                       /*{{{*/
 #include <apt-pkg/pkgcache.h>
 #define APT_CACHEFILTER_H
 // Include Files                                                       /*{{{*/
 #include <apt-pkg/pkgcache.h>

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

 
 #include <string>
 
 #include <string>

+#include <vector>

 
 #include <regex.h>
 
 #include <regex.h>

+
+class pkgCacheFile;

                                                                        /*}}}*/
 namespace APT {
 namespace CacheFilter {
 
                                                                        /*}}}*/
 namespace APT {
 namespace CacheFilter {
 

-#define PACKAGE_MATCHER_ABI_COMPAT 1
-#ifdef PACKAGE_MATCHER_ABI_COMPAT
-
-// PackageNameMatchesRegEx                                             /*{{{*/
-class PackageNameMatchesRegEx {
-         /** \brief dpointer placeholder (for later in case we need it) */
-         void *d;
-       regex_t* pattern;
+class Matcher {

 public:
 public:

-       PackageNameMatchesRegEx(std::string const &Pattern);
-       bool operator() (pkgCache::PkgIterator const &Pkg);
-       bool operator() (pkgCache::GrpIterator const &Grp);
-       ~PackageNameMatchesRegEx();
+   virtual bool operator() (pkgCache::PkgIterator const &/*Pkg*/) = 0;
+   virtual bool operator() (pkgCache::GrpIterator const &/*Grp*/) = 0;
+   virtual bool operator() (pkgCache::VerIterator const &/*Ver*/) = 0;
+   virtual ~Matcher();

 };
 };

-                                                                       /*}}}*/
-// PackageNameMatchesFnmatch                                           /*{{{*/
- class PackageNameMatchesFnmatch {
-         /** \brief dpointer placeholder (for later in case we need it) */
-         void *d;
-         const std::string Pattern;
+
+class PackageMatcher : public Matcher {

 public:
 public:

-         PackageNameMatchesFnmatch(std::string const &Pattern) 
-            : Pattern(Pattern) {};
-        bool operator() (pkgCache::PkgIterator const &Pkg);
-       bool operator() (pkgCache::GrpIterator const &Grp);
-       ~PackageNameMatchesFnmatch() {};
+   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE = 0;
+   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE { return (*this)(Ver.ParentPkg()); }
+   virtual bool operator() (pkgCache::GrpIterator const &/*Grp*/) APT_OVERRIDE { return false; }
+   virtual ~PackageMatcher();

 };
 };

-                                                                       /*}}}*/
-// PackageArchitectureMatchesSpecification                             /*{{{*/
-/** \class PackageArchitectureMatchesSpecification
-   \brief matching against architecture specification strings
-
-   The strings are of the format <kernel>-<cpu> where either component,
-   or the whole string, can be the wildcard "any" as defined in
-   debian-policy §11.1 "Architecture specification strings".

 
 

-   Examples: i386, mipsel, linux-any, any-amd64, any */
-class PackageArchitectureMatchesSpecification {
-       std::string literal;
-       std::string complete;
-       bool isPattern;
-       /** \brief dpointer placeholder (for later in case we need it) */
-       void *d;
+// Generica like True, False, NOT, AND, OR                             /*{{{*/
+class TrueMatcher : public Matcher {

 public:
 public:

-       /** \brief matching against architecture specification strings
-        *
-        * @param pattern is the architecture specification string
-        * @param isPattern defines if the given \b pattern is a
-        *        architecture specification pattern to match others against
-        *        or if it is the fixed string and matched against patterns
-        */
-       PackageArchitectureMatchesSpecification(std::string const &pattern, bool const isPattern = true);
-       bool operator() (char const * const &arch);
-       bool operator() (pkgCache::PkgIterator const &Pkg);
-       bool operator() (pkgCache::VerIterator const &Ver);
-       ~PackageArchitectureMatchesSpecification();
+   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;

 };
 
 };
 

-#else
+class FalseMatcher : public Matcher {
+public:
+   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
+};

 
 

-class PackageMatcher {
- public:
-   virtual bool operator() (pkgCache::PkgIterator const &Pkg) { return false; };
-   virtual bool operator() (pkgCache::GrpIterator const &Grp) { return false; };
-   virtual bool operator() (pkgCache::VerIterator const &Ver) { return false; };
-   
-   virtual ~PackageMatcher() {};
+class NOTMatcher : public Matcher {
+   Matcher * const matcher;
+public:
+   explicit NOTMatcher(Matcher * const matcher);
+   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
+   virtual ~NOTMatcher();

 };
 
 };
 

-// PackageNameMatchesRegEx                                             /*{{{*/
-class PackageNameMatchesRegEx : public PackageMatcher {
-         /** \brief dpointer placeholder (for later in case we need it) */
-         void *d;
+class ANDMatcher : public Matcher {
+   std::vector<Matcher *> matchers;
+public:
+   // 5 ought to be enough for everybody… c++11 variadic templates would be nice
+   ANDMatcher();
+   explicit ANDMatcher(Matcher * const matcher1);
+   ANDMatcher(Matcher * const matcher1, Matcher * const matcher2);
+   ANDMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3);
+   ANDMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4);
+   ANDMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4, Matcher * const matcher5);
+   ANDMatcher& AND(Matcher * const matcher);
+   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
+   virtual ~ANDMatcher();
+};
+class ORMatcher : public Matcher {
+   std::vector<Matcher *> matchers;
+public:
+   // 5 ought to be enough for everybody… c++11 variadic templates would be nice
+   ORMatcher();
+   explicit ORMatcher(Matcher * const matcher1);
+   ORMatcher(Matcher * const matcher1, Matcher * const matcher2);
+   ORMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3);
+   ORMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4);
+   ORMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4, Matcher * const matcher5);
+   ORMatcher& OR(Matcher * const matcher);
+   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
+   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
+   virtual ~ORMatcher();
+};
+                                                                       /*}}}*/
+class PackageNameMatchesRegEx : public PackageMatcher {                        /*{{{*/

        regex_t* pattern;
 public:
        regex_t* pattern;
 public:

-       PackageNameMatchesRegEx(std::string const &Pattern);
-       virtual bool operator() (pkgCache::PkgIterator const &Pkg);
-       virtual bool operator() (pkgCache::GrpIterator const &Grp);
+       explicit PackageNameMatchesRegEx(std::string const &Pattern);
+       virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
+       virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;

        virtual ~PackageNameMatchesRegEx();
 };
                                                                        /*}}}*/
        virtual ~PackageNameMatchesRegEx();
 };
                                                                        /*}}}*/

-// PackageNameMatchesFnmatch                                           /*{{{*/
-   class PackageNameMatchesFnmatch : public PackageMatcher{
-         /** \brief dpointer placeholder (for later in case we need it) */
-         void *d;
-         const std::string Pattern;
+class PackageNameMatchesFnmatch : public PackageMatcher {              /*{{{*/
+       const std::string Pattern;

 public:
 public:

-         PackageNameMatchesFnmatch(std::string const &Pattern) 
-            : Pattern(Pattern) {};
-        virtual bool operator() (pkgCache::PkgIterator const &Pkg);
-       virtual bool operator() (pkgCache::GrpIterator const &Grp);
+       explicit PackageNameMatchesFnmatch(std::string const &Pattern);
+       virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
+       virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;

        virtual ~PackageNameMatchesFnmatch() {};
 };
                                                                        /*}}}*/
        virtual ~PackageNameMatchesFnmatch() {};
 };
                                                                        /*}}}*/

-// PackageArchitectureMatchesSpecification                             /*{{{*/
+class PackageArchitectureMatchesSpecification : public PackageMatcher {        /*{{{*/

 /** \class PackageArchitectureMatchesSpecification
    \brief matching against architecture specification strings
 
 /** \class PackageArchitectureMatchesSpecification
    \brief matching against architecture specification strings
 

-   The strings are of the format <kernel>-<cpu> where either component,
+   The strings are of the format <libc>-<kernel>-<cpu> where either component,

    or the whole string, can be the wildcard "any" as defined in
    debian-policy §11.1 "Architecture specification strings".
 
    or the whole string, can be the wildcard "any" as defined in
    debian-policy §11.1 "Architecture specification strings".
 

-   Examples: i386, mipsel, linux-any, any-amd64, any */
-class PackageArchitectureMatchesSpecification : public PackageMatcher {
+   Examples: i386, mipsel, musl-linux-amd64, linux-any, any-amd64, any */

        std::string literal;
        std::string complete;
        bool isPattern;
        std::string literal;
        std::string complete;
        bool isPattern;

-       /** \brief dpointer placeholder (for later in case we need it) */
-       void *d;

 public:
        /** \brief matching against architecture specification strings
         *
 public:
        /** \brief matching against architecture specification strings
         *


@@ -134,12 +133,19 @@ public:
         */
        PackageArchitectureMatchesSpecification(std::string const &pattern, bool const isPattern = true);
        bool operator() (char const * const &arch);
         */
        PackageArchitectureMatchesSpecification(std::string const &pattern, bool const isPattern = true);
        bool operator() (char const * const &arch);

-       virtual bool operator() (pkgCache::PkgIterator const &Pkg);
-       virtual bool operator() (pkgCache::VerIterator const &Ver);
+       virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;

        virtual ~PackageArchitectureMatchesSpecification();
 };
        virtual ~PackageArchitectureMatchesSpecification();
 };

-#endif

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

+class PackageIsNewInstall : public PackageMatcher {                    /*{{{*/
+       pkgCacheFile * const Cache;
+public:
+       explicit PackageIsNewInstall(pkgCacheFile * const Cache);
+       virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
+       virtual ~PackageIsNewInstall();
+};
+                                                                       /*}}}*/
+

 }
 }
 #endif
 }
 }
 #endif