libzypp 17.31.7
StrMatcher.cc
Go to the documentation of this file.
1/*---------------------------------------------------------------------\
2| ____ _ __ __ ___ |
3| |__ / \ / / . \ . \ |
4| / / \ V /| _/ _/ |
5| / /__ | | | | | | |
6| /_____||_| |_| |_| |
7| |
8\---------------------------------------------------------------------*/
12extern "C"
13{
14#include <solv/repo.h>
15}
16
17#include <iostream>
18#include <sstream>
19
20#include <zypp/base/LogTools.h>
21#include <zypp/base/Gettext.h>
22#include <zypp/base/String.h>
23
26
27using std::endl;
28
30namespace zypp
31{
33 // class Match
35
36 const int Match::_modemask = SEARCH_STRINGMASK;
37 const int Match::_flagmask = ~_modemask;
38
39 // option flags
40 const Match Match::NOCASE (SEARCH_NOCASE);
41
42 // sat::LookupAttr option flags
43 const Match Match::NO_STORAGE_SOLVABLE(SEARCH_NO_STORAGE_SOLVABLE);
44 const Match Match::SUB (SEARCH_SUB);
45 const Match Match::ARRAYSENTINEL (SEARCH_ARRAYSENTINEL);
46 const Match Match::DISABLED_REPOS (SEARCH_DISABLED_REPOS);
47 const Match Match::COMPLETE_FILELIST (SEARCH_COMPLETE_FILELIST);
48 const Match Match::SKIP_KIND (SEARCH_SKIP_KIND);
49 const Match Match::FILES (SEARCH_FILES);
50 const Match Match::CHECKSUMS (SEARCH_CHECKSUMS);
51
53 {
54 switch ( modeval() )
55 {
56 case 0: return NOTHING; break;
57 case SEARCH_STRING: return STRING; break;
58 case SEARCH_STRINGSTART: return STRINGSTART; break;
59 case SEARCH_STRINGEND: return STRINGEND; break;
60 case SEARCH_SUBSTRING: return SUBSTRING; break;
61 case SEARCH_GLOB: return GLOB; break;
62 case SEARCH_REGEX: return REGEX; break;
63 }
64 return OTHER;
65 }
66
67 int Match::modeval( Mode mode_r )
68 {
69 switch ( mode_r )
70 {
71 case NOTHING: return 0; break;
72 case STRING: return SEARCH_STRING; break;
73 case STRINGSTART: return SEARCH_STRINGSTART; break;
74 case STRINGEND: return SEARCH_STRINGEND; break;
75 case SUBSTRING: return SEARCH_SUBSTRING; break;
76 case GLOB: return SEARCH_GLOB; break;
77 case REGEX: return SEARCH_REGEX; break;
78 case OTHER: return SEARCH_STRINGMASK; break;
79 }
80 return SEARCH_STRINGMASK;
81 }
82
83 std::string Match::asString() const
84 { std::ostringstream str; str << *this; return str.str(); }
85
86 std::ostream & operator<<( std::ostream & str, Match::Mode obj )
87 {
88 switch ( obj )
89 {
90#define OUTS(V) case Match::V: return str << #V; break
91 OUTS( NOTHING );
92 OUTS( STRING );
93 OUTS( STRINGSTART );
94 OUTS( STRINGEND );
95 OUTS( SUBSTRING );
96 OUTS( GLOB );
97 OUTS( REGEX );
98 OUTS( OTHER );
99#undef OUTS
100 }
101 return str << "Match::Mode::UNKNOWN";
102 }
103
104 std::ostream & operator<<( std::ostream & str, const Match & obj )
105 {
106 if ( ! obj )
107 return str << "NOTHING";
108
109 const char * sep = "|";
110 Match::Mode mode( obj.mode() );
111 switch ( mode )
112 {
113 case Match::NOTHING:
114 sep = 0; // suppress 'NOTHING|'
115 break;
116 case Match::OTHER:
117 str << mode<<"("<<obj.modeval()<<")"; // check whether libsolv has introduced new modes!
118 break;
119 default:
120 str << mode;
121 break;
122 }
123
124 int val = obj.flagval();
125 if ( val )
126 {
127#define OUTS(V) if ( val & Match::V.get() ) { val &= ~Match::V.get(); if ( sep ) str << sep; else sep = "|"; str << #V; }
128 OUTS( NOCASE );
129 OUTS( NO_STORAGE_SOLVABLE );
130 OUTS( SUB );
131 OUTS( ARRAYSENTINEL );
132 OUTS( DISABLED_REPOS );
133 OUTS( COMPLETE_FILELIST );
134 OUTS( SKIP_KIND );
135 OUTS( FILES );
136 OUTS( CHECKSUMS );
137#undef OUTS
138 if ( val )
139 {
140 if ( sep ) str << sep;
141 str << zypp::str::hexstring( val ); // check whether libsolv has introduced new flags.
142 }
143 }
144 return str;
145 }
146
148 // class MatchException
150
151 MatchUnknownModeException::MatchUnknownModeException( const Match & mode_r, const std::string & msg_r )
152 : MatchException( msg_r.empty() ? str::form(_("Unknown match mode '%s'"), mode_r.asString().c_str() )
153 : str::form(_("Unknown match mode '%s' for pattern '%s'"), mode_r.asString().c_str(), msg_r.c_str() ) )
154 {}
155
156 MatchInvalidRegexException::MatchInvalidRegexException( const std::string & regex_r, int regcomp_r )
157 : MatchException( regcomp_r ? str::form(_("Invalid regular expression '%s': regcomp returned %d"), regex_r.c_str(), regcomp_r )
158 : str::form(_("Invalid regular expression '%s'"), regex_r.c_str() ) )
159 {}
160
169 {
171 {}
172
173 Impl( std::string search_r, const Match & flags_r )
174 : _search( std::move(search_r) )
175 , _flags( flags_r )
176 {}
177
179 { invalidate(); }
180
182 void compile() const
183 {
184 if ( !_matcher )
185 {
186 if ( _flags.mode() == Match::OTHER )
188
190 int res = ::datamatcher_init( _matcher.get(), _search.c_str(), _flags.get() );
191 if ( res )
192 {
193 _matcher.reset();
195 }
196 }
197 }
198
200 bool isCompiled() const
201 { return _matcher != nullptr; }
202
204 bool doMatch( const char * string_r ) const
205 {
206 compile(); // nop if already compiled.
207
208 if ( ! string_r )
209 return false; // NULL never matches
210 return ::datamatcher_match( _matcher.get(), string_r );
211 }
212
214 const std::string & searchstring() const
215 { return _search; }
216
218 void setSearchstring( std::string string_r )
219 { invalidate(); _search = std::move(string_r); }
220
222 const Match & flags() const
223 { return _flags; }
224
226 void setFlags( const Match & flags_r )
227 { invalidate(); _flags = flags_r; }
228
229 private:
232 {
233 if ( _matcher )
234 ::datamatcher_free( _matcher.get() );
235 _matcher.reset();
236 }
237
238 private:
239 std::string _search;
241 mutable scoped_ptr< sat::detail::CDatamatcher> _matcher;
242
243 private:
244 friend Impl * rwcowClone<Impl>( const Impl * rhs );
246 Impl * clone() const
247 { return new Impl( _search, _flags ); }
248 };
249
251 inline std::ostream & operator<<( std::ostream & str, const StrMatcher::Impl & obj )
252 {
253 return str << "\"" << obj.searchstring() << "\"{" << obj.flags() << "}";
254 }
255
257 // class StrMatcher
259
261 : _pimpl( new Impl )
262 {}
263
264 StrMatcher::StrMatcher( const std::string & search_r )
265 : _pimpl( new Impl( search_r, Match::STRING ) )
266 {}
267 StrMatcher::StrMatcher( std::string && search_r )
268 : _pimpl( new Impl( std::move(search_r), Match::STRING ) )
269 {}
270
271 StrMatcher::StrMatcher( const std::string & search_r, const Match & flags_r )
272 : _pimpl( new Impl( search_r, flags_r ) )
273 {}
274 StrMatcher::StrMatcher( std::string && search_r, const Match & flags_r )
275 : _pimpl( new Impl( std::move(search_r), flags_r ) )
276 {}
277
278 StrMatcher::StrMatcher( const std::string & search_r, const Match::Mode & flags_r )
279 : _pimpl( new Impl( search_r, flags_r ) )
280 {}
281 StrMatcher::StrMatcher( std::string && search_r, const Match::Mode & flags_r )
282 : _pimpl( new Impl( std::move(search_r), flags_r ) )
283 {}
284
285 StrMatcher::StrMatcher( const std::string & search_r, int flags_r )
286 : _pimpl( new Impl( search_r, Match(flags_r) ) )
287 {}
288 StrMatcher::StrMatcher( std::string && search_r, int flags_r )
289 : _pimpl( new Impl( std::move(search_r), Match(flags_r) ) )
290 {}
291
293 { return _pimpl->compile(); }
294
296 { return _pimpl->isCompiled(); }
297
298 bool StrMatcher::doMatch( const char * string_r ) const
299 { return _pimpl->doMatch( string_r ); }
300
301 const std::string & StrMatcher::searchstring() const
302 { return _pimpl->searchstring(); }
303
304 void StrMatcher::setSearchstring( const std::string & string_r )
305 { _pimpl->setSearchstring( string_r ); }
306 void StrMatcher::setSearchstring( std::string && string_r )
307 { _pimpl->setSearchstring( std::move(string_r) ); }
308
309 void StrMatcher::setSearchstring( const std::string & string_r, const Match & flags_r )
310 {
311 _pimpl->setSearchstring( string_r );
312 _pimpl->setFlags( flags_r );
313 }
314 void StrMatcher::setSearchstring( std::string && string_r, const Match & flags_r )
315 {
316 _pimpl->setSearchstring( std::move(string_r) );
317 _pimpl->setFlags( flags_r );
318 }
319
320 const Match & StrMatcher::flags() const
321 { return _pimpl->flags(); }
322
323 void StrMatcher::setFlags( const Match & flags_r )
324 { _pimpl->setFlags( flags_r ); }
325
326 std::ostream & operator<<( std::ostream & str, const StrMatcher & obj )
327 { return str << *obj._pimpl; }
328
329 bool operator==( const StrMatcher & lhs, const StrMatcher & rhs )
330 {
331 return ( lhs.flags() == rhs.flags()
332 && lhs.searchstring() == rhs.searchstring() );
333 }
334
335 bool operator<( const StrMatcher & lhs, const StrMatcher & rhs )
336 {
337 if ( lhs.flags().get() != rhs.flags().get() )
338 return ( lhs.flags().get() < rhs.flags().get() );
339
340 return ( lhs.searchstring() < rhs.searchstring() );
341 }
342
343} // namespace zypp
#define OUTS(V)
String matching option flags as used e.g.
Definition: StrMatcher.h:33
static const Match DISABLED_REPOS
LookupAttr: internal.
Definition: StrMatcher.h:72
int flagval() const
Return the flags integer representation.
Definition: StrMatcher.h:154
int get() const
Return the integer representation.
Definition: StrMatcher.h:150
std::string asString() const
String representation.
Definition: StrMatcher.cc:83
static const Match ARRAYSENTINEL
LookupAttr: internal.
Definition: StrMatcher.h:71
static const Match SUB
LookupAttr: internal.
Definition: StrMatcher.h:70
Mode
Mode flags (mutual exclusive).
Definition: StrMatcher.h:41
@ STRINGEND
Match at string end.
Definition: StrMatcher.h:45
@ NOTHING
Match nothing.
Definition: StrMatcher.h:42
@ OTHER
Something else.
Definition: StrMatcher.h:49
@ REGEX
Regular Expression.
Definition: StrMatcher.h:48
@ STRINGSTART
Match at string start.
Definition: StrMatcher.h:44
@ GLOB
Glob.
Definition: StrMatcher.h:47
@ SUBSTRING
Match substring.
Definition: StrMatcher.h:46
@ STRING
Excat matching.
Definition: StrMatcher.h:43
static const Match COMPLETE_FILELIST
LookupAttr: internal.
Definition: StrMatcher.h:73
static const Match CHECKSUMS
LookupAttr: also look for matches in checksums.
Definition: StrMatcher.h:76
static const int _flagmask
Definition: StrMatcher.h:36
static const Match NO_STORAGE_SOLVABLE
LookupAttr: internal.
Definition: StrMatcher.h:69
static const Match FILES
LookupAttr: match full path when matching in filelists, otherwise just the basenames.
Definition: StrMatcher.h:75
static const Match SKIP_KIND
LookupAttr: skip any kind: prefix when looking at a Solvable name.
Definition: StrMatcher.h:74
static const Match NOCASE
If set, match case insensitive.
Definition: StrMatcher.h:59
int modeval() const
Return the modes integer representation.
Definition: StrMatcher.h:152
static const int _modemask
Definition: StrMatcher.h:35
Mode mode() const
Return the mode part.
Definition: StrMatcher.cc:52
String matching (STRING|SUBSTRING|GLOB|REGEX).
Definition: StrMatcher.h:298
bool doMatch(const char *string_r) const
Return whether string matches.
Definition: StrMatcher.cc:298
const std::string & searchstring() const
The current searchstring.
Definition: StrMatcher.cc:301
const Match & flags() const
The current search flags.
Definition: StrMatcher.cc:320
RWCOW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: StrMatcher.h:392
StrMatcher()
Default ctor matches nothing.
Definition: StrMatcher.cc:260
void setSearchstring(const std::string &string_r)
Set a new searchstring.
Definition: StrMatcher.cc:304
void setFlags(const Match &flags_r)
Set new search flags.
Definition: StrMatcher.cc:323
bool isCompiled() const
Whether the StrMatcher is already compiled.
Definition: StrMatcher.cc:295
void compile() const
Compile the pattern e.g.
Definition: StrMatcher.cc:292
Definition: Arch.h:352
String related utilities and Regular expression matching.
::s_Datamatcher CDatamatcher
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:59
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
std::string hexstring(char n, int w=4)
Definition: String.h:324
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
bool operator<(const StrMatcher &lhs, const StrMatcher &rhs)
Definition: StrMatcher.cc:335
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
Definition: SerialNumber.cc:52
std::string asString(const Patch::Category &obj)
Definition: Patch.cc:122
Exceptions thrown from attribute matching.
Definition: StrMatcher.h:248
Invalid regular expression (failed ::regcomp).
Definition: StrMatcher.h:271
MatchInvalidRegexException(const std::string &msg_r)
Supplied message.
Definition: StrMatcher.h:273
MatchUnknownModeException(const std::string &msg_r)
Supplied message.
Definition: StrMatcher.h:260
StrMatcher implementation.
Definition: StrMatcher.cc:169
Impl * clone() const
clone for RWCOW_pointer
Definition: StrMatcher.cc:246
const Match & flags() const
The current search flags.
Definition: StrMatcher.cc:222
const std::string & searchstring() const
The current searchstring.
Definition: StrMatcher.cc:214
void compile() const
Compile the pattern.
Definition: StrMatcher.cc:182
bool isCompiled() const
Whether the pattern is already compiled.
Definition: StrMatcher.cc:200
bool doMatch(const char *string_r) const
Return whether string matches.
Definition: StrMatcher.cc:204
void invalidate()
Has to be called if _search or _flags change.
Definition: StrMatcher.cc:231
void setSearchstring(std::string string_r)
Set a new searchstring.
Definition: StrMatcher.cc:218
std::ostream & operator<<(std::ostream &str, const StrMatcher::Impl &obj)
Stream output.
Definition: StrMatcher.cc:251
Impl(std::string search_r, const Match &flags_r)
Definition: StrMatcher.cc:173
void setFlags(const Match &flags_r)
Set new search flags.
Definition: StrMatcher.cc:226
scoped_ptr< sat::detail::CDatamatcher > _matcher
Definition: StrMatcher.cc:241
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:428
#define _(MSG)
Definition: Gettext.h:37