1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
/** \file cachefilter.h
Collection of functor classes */
/*}}}*/
#ifndef APT_CACHEFILTER_H
#define APT_CACHEFILTER_H
// Include Files /*{{{*/
#include <apt-pkg/pkgcache.h>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
#include <regex.h>
class pkgCacheFile;
/*}}}*/
namespace APT {
namespace CacheFilter {
class APT_PUBLIC Matcher {
public:
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();
};
class APT_PUBLIC PackageMatcher : public Matcher {
public:
bool operator() (pkgCache::PkgIterator const &Pkg) override = 0;
bool operator() (pkgCache::VerIterator const &Ver) override { return (*this)(Ver.ParentPkg()); }
bool operator() (pkgCache::GrpIterator const &/*Grp*/) override { return false; }
~PackageMatcher() override;
};
// Generica like True, False, NOT, AND, OR /*{{{*/
class APT_PUBLIC TrueMatcher : public Matcher {
public:
bool operator() (pkgCache::PkgIterator const &Pkg) override;
bool operator() (pkgCache::GrpIterator const &Grp) override;
bool operator() (pkgCache::VerIterator const &Ver) override;
};
class APT_PUBLIC FalseMatcher : public Matcher {
public:
bool operator() (pkgCache::PkgIterator const &Pkg) override;
bool operator() (pkgCache::GrpIterator const &Grp) override;
bool operator() (pkgCache::VerIterator const &Ver) override;
};
class APT_PUBLIC NOTMatcher : public Matcher {
Matcher * const matcher;
public:
explicit NOTMatcher(Matcher * const matcher);
bool operator() (pkgCache::PkgIterator const &Pkg) override;
bool operator() (pkgCache::GrpIterator const &Grp) override;
bool operator() (pkgCache::VerIterator const &Ver) override;
~NOTMatcher() override;
};
class APT_PUBLIC 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);
bool operator() (pkgCache::PkgIterator const &Pkg) override;
bool operator() (pkgCache::GrpIterator const &Grp) override;
bool operator() (pkgCache::VerIterator const &Ver) override;
~ANDMatcher() override;
};
class APT_PUBLIC 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);
bool operator() (pkgCache::PkgIterator const &Pkg) override;
bool operator() (pkgCache::GrpIterator const &Grp) override;
bool operator() (pkgCache::VerIterator const &Ver) override;
~ORMatcher() override;
};
/*}}}*/
class APT_PUBLIC PackageNameMatchesRegEx : public PackageMatcher { /*{{{*/
regex_t* pattern;
public:
explicit PackageNameMatchesRegEx(std::string const &Pattern);
bool operator() (pkgCache::PkgIterator const &Pkg) override;
bool operator() (pkgCache::GrpIterator const &Grp) override;
~PackageNameMatchesRegEx() override;
};
/*}}}*/
class APT_PUBLIC PackageNameMatchesFnmatch : public PackageMatcher { /*{{{*/
const std::string Pattern;
public:
explicit PackageNameMatchesFnmatch(std::string const &Pattern);
bool operator() (pkgCache::PkgIterator const &Pkg) override;
bool operator() (pkgCache::GrpIterator const &Grp) override;
~PackageNameMatchesFnmatch() override = default;
};
/*}}}*/
class APT_PUBLIC PackageArchitectureMatchesSpecification : public PackageMatcher { /*{{{*/
/** \class PackageArchitectureMatchesSpecification
\brief matching against architecture specification strings
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".
Examples: i386, mipsel, musl-linux-amd64, linux-any, any-amd64, any */
std::string literal;
std::string complete;
bool isPattern;
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);
using PackageMatcher::operator();
bool operator() (pkgCache::PkgIterator const &Pkg) override;
~PackageArchitectureMatchesSpecification() override;
};
/*}}}*/
class APT_PUBLIC PackageIsNewInstall : public PackageMatcher { /*{{{*/
pkgCacheFile * const Cache;
public:
explicit PackageIsNewInstall(pkgCacheFile * const Cache);
using PackageMatcher::operator();
bool operator() (pkgCache::PkgIterator const &Pkg) override;
~PackageIsNewInstall() override;
};
/*}}}*/
/// \brief Parse a pattern, return nullptr or pattern
APT_PUBLIC std::unique_ptr<APT::CacheFilter::Matcher> ParsePattern(std::string_view pattern, pkgCacheFile *file);
}
}
#endif
|
