apt-pkg/cachefilter.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /** \file cachefilter.h
   4    Collection of functor classes */
   5                                                                         /*}}}*/
   6 #ifndef APT_CACHEFILTER_H
   7 #define APT_CACHEFILTER_H
   8 // Include Files                                                        /*{{{*/
   9 #include <apt-pkg/pkgcache.h>
  10 #include <apt-pkg/cacheiterators.h>
  11
  12 #include <string>
  13
  14 #include <regex.h>
  15                                                                         /*}}}*/
  16 namespace APT {
  17 namespace CacheFilter {
  18
  19 #define PACKAGE_MATCHER_ABI_COMPAT 1
  20 #ifdef PACKAGE_MATCHER_ABI_COMPAT
  21
  22 // PackageNameMatchesRegEx                                              /*{{{*/
  23 class PackageNameMatchesRegEx {
  24          /** \brief dpointer placeholder (for later in case we need it) */
  25          void *d;
  26         regex_t* pattern;
  27 public:
  28         PackageNameMatchesRegEx(std::string const &Pattern);
  29         bool operator() (pkgCache::PkgIterator const &Pkg);
  30         bool operator() (pkgCache::GrpIterator const &Grp);
  31         ~PackageNameMatchesRegEx();
  32 };
  33                                                                         /*}}}*/
  34 // PackageNameMatchesFnmatch                                            /*{{{*/
  35  class PackageNameMatchesFnmatch {
  36          /** \brief dpointer placeholder (for later in case we need it) */
  37          void *d;
  38          const std::string Pattern;
  39 public:
  40          PackageNameMatchesFnmatch(std::string const &Pattern)
  41             : Pattern(Pattern) {};
  42         bool operator() (pkgCache::PkgIterator const &Pkg);
  43         bool operator() (pkgCache::GrpIterator const &Grp);
  44         ~PackageNameMatchesFnmatch() {};
  45 };
  46                                                                         /*}}}*/
  47 // PackageArchitectureMatchesSpecification                              /*{{{*/
  48 /** \class PackageArchitectureMatchesSpecification
  49    \brief matching against architecture specification strings
  50
  51    The strings are of the format \<kernel\>-\<cpu\> where either component,
  52    or the whole string, can be the wildcard "any" as defined in
  53    debian-policy §11.1 "Architecture specification strings".
  54
  55    Examples: i386, mipsel, linux-any, any-amd64, any */
  56 class PackageArchitectureMatchesSpecification {
  57         std::string literal;
  58         std::string complete;
  59         bool isPattern;
  60         /** \brief dpointer placeholder (for later in case we need it) */
  61         void *d;
  62 public:
  63         /** \brief matching against architecture specification strings
  64          *
  65          * @param pattern is the architecture specification string
  66          * @param isPattern defines if the given \b pattern is a
  67          *        architecture specification pattern to match others against
  68          *        or if it is the fixed string and matched against patterns
  69          */
  70         PackageArchitectureMatchesSpecification(std::string const &pattern, bool const isPattern = true);
  71         bool operator() (char const * const &arch);
  72         bool operator() (pkgCache::PkgIterator const &Pkg);
  73         bool operator() (pkgCache::VerIterator const &Ver);
  74         ~PackageArchitectureMatchesSpecification();
  75 };
  76
  77 #else
  78
  79 class PackageMatcher {
  80  public:
  81    virtual bool operator() (pkgCache::PkgIterator const &Pkg) { return false; };
  82    virtual bool operator() (pkgCache::GrpIterator const &Grp) { return false; };
  83    virtual bool operator() (pkgCache::VerIterator const &Ver) { return false; };
  84
  85    virtual ~PackageMatcher() {};
  86 };
  87
  88 // PackageNameMatchesRegEx                                              /*{{{*/
  89 class PackageNameMatchesRegEx : public PackageMatcher {
  90          /** \brief dpointer placeholder (for later in case we need it) */
  91          void *d;
  92         regex_t* pattern;
  93 public:
  94         PackageNameMatchesRegEx(std::string const &Pattern);
  95         virtual bool operator() (pkgCache::PkgIterator const &Pkg);
  96         virtual bool operator() (pkgCache::GrpIterator const &Grp);
  97         virtual ~PackageNameMatchesRegEx();
  98 };
  99                                                                         /*}}}*/
 100 // PackageNameMatchesFnmatch                                            /*{{{*/
 101    class PackageNameMatchesFnmatch : public PackageMatcher{
 102          /** \brief dpointer placeholder (for later in case we need it) */
 103          void *d;
 104          const std::string Pattern;
 105 public:
 106          PackageNameMatchesFnmatch(std::string const &Pattern)
 107             : Pattern(Pattern) {};
 108         virtual bool operator() (pkgCache::PkgIterator const &Pkg);
 109         virtual bool operator() (pkgCache::GrpIterator const &Grp);
 110         virtual ~PackageNameMatchesFnmatch() {};
 111 };
 112                                                                         /*}}}*/
 113 // PackageArchitectureMatchesSpecification                              /*{{{*/
 114 /** \class PackageArchitectureMatchesSpecification
 115    \brief matching against architecture specification strings
 116
 117    The strings are of the format <kernel>-<cpu> where either component,
 118    or the whole string, can be the wildcard "any" as defined in
 119    debian-policy §11.1 "Architecture specification strings".
 120
 121    Examples: i386, mipsel, linux-any, any-amd64, any */
 122 class PackageArchitectureMatchesSpecification : public PackageMatcher {
 123         std::string literal;
 124         std::string complete;
 125         bool isPattern;
 126         /** \brief dpointer placeholder (for later in case we need it) */
 127         void *d;
 128 public:
 129         /** \brief matching against architecture specification strings
 130          *
 131          * @param pattern is the architecture specification string
 132          * @param isPattern defines if the given \b pattern is a
 133          *        architecture specification pattern to match others against
 134          *        or if it is the fixed string and matched against patterns
 135          */
 136         PackageArchitectureMatchesSpecification(std::string const &pattern, bool const isPattern = true);
 137         bool operator() (char const * const &arch);
 138         virtual bool operator() (pkgCache::PkgIterator const &Pkg);
 139         virtual bool operator() (pkgCache::VerIterator const &Ver);
 140         virtual ~PackageArchitectureMatchesSpecification();
 141 };
 142 #endif
 143                                                                         /*}}}*/
 144 }
 145 }
 146 #endif