libzypp: zypp/base/StrMatcher.cc Source File

libzypp 17.25.10

StrMatcher.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 extern "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
24 #include <zypp/base/StrMatcher.h>
25 #include <zypp/sat/detail/PoolMember.h>
26
27 using std::endl;
28
30 namespace 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
52 Match::Mode Match::mode() const
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
168 struct StrMatcher::Impl
169 {
170 Impl()
171 {}
172
173 Impl( std::string search_r, const Match & flags_r )
174 : _search( std::move(search_r) )
175 , _flags( flags_r )
176 {}
177
178 ~Impl()
179 { invalidate(); }
180
182 void compile() const
183 {
184 if ( !_matcher )
185 {
186 if ( _flags.mode() == Match::OTHER )
187 ZYPP_THROW( MatchUnknownModeException( _flags, _search ) );
188
189 _matcher.reset( new sat::detail::CDatamatcher );
190 int res = ::datamatcher_init( _matcher.get(), _search.c_str(), _flags.get() );
191 if ( res )
192 {
193 _matcher.reset();
194 ZYPP_THROW( MatchInvalidRegexException( _search, res ) );
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:
231 void invalidate()
232 {
233 if ( _matcher )
234 ::datamatcher_free( _matcher.get() );
235 _matcher.reset();
236 }
237
238 private:
239 std::string _search;
240 Match _flags;
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
260 StrMatcher::StrMatcher()
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
292 void StrMatcher::compile() const
293 { return _pimpl->compile(); }
294
295 bool StrMatcher::isCompiled() const
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
ZYPP_THROW
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
Gettext.h
Interface to gettext.
_
#define _(MSG)
Definition: Gettext.h:37
LogTools.h
PoolMember.h
OUTS
#define OUTS(V)
StrMatcher.h
String.h
zypp::Match
String matching option flags as used e.g.
Definition: StrMatcher.h:33
zypp::Match::DISABLED_REPOS
static const Match DISABLED_REPOS
LookupAttr: internal.
Definition: StrMatcher.h:72
zypp::Match::flagval
int flagval() const
Return the flags integer representation.
Definition: StrMatcher.h:154
zypp::Match::get
int get() const
Return the integer representation.
Definition: StrMatcher.h:150
zypp::Match::asString
std::string asString() const
String representation.
Definition: StrMatcher.cc:83
zypp::Match::ARRAYSENTINEL
static const Match ARRAYSENTINEL
LookupAttr: internal.
Definition: StrMatcher.h:71
zypp::Match::SUB
static const Match SUB
LookupAttr: internal.
Definition: StrMatcher.h:70
zypp::Match::Mode
Mode
Mode flags (mutual exclusive).
Definition: StrMatcher.h:41
zypp::Match::STRINGEND
@ STRINGEND
Match at string end.
Definition: StrMatcher.h:45
zypp::Match::NOTHING
@ NOTHING
Match nothing.
Definition: StrMatcher.h:42
zypp::Match::OTHER
@ OTHER
Something else.
Definition: StrMatcher.h:49
zypp::Match::REGEX
@ REGEX
Regular Expression.
Definition: StrMatcher.h:48
zypp::Match::STRINGSTART
@ STRINGSTART
Match at string start.
Definition: StrMatcher.h:44
zypp::Match::GLOB
@ GLOB
Glob.
Definition: StrMatcher.h:47
zypp::Match::SUBSTRING
@ SUBSTRING
Match substring.
Definition: StrMatcher.h:46
zypp::Match::STRING
@ STRING
Excat matching.
Definition: StrMatcher.h:43
zypp::Match::COMPLETE_FILELIST
static const Match COMPLETE_FILELIST
LookupAttr: internal.
Definition: StrMatcher.h:73
zypp::Match::CHECKSUMS
static const Match CHECKSUMS
LookupAttr: also look for matches in checksums.
Definition: StrMatcher.h:76
zypp::Match::_flagmask
static const int _flagmask
Definition: StrMatcher.h:36
zypp::Match::NO_STORAGE_SOLVABLE
static const Match NO_STORAGE_SOLVABLE
LookupAttr: internal.
Definition: StrMatcher.h:69
zypp::Match::FILES
static const Match FILES
LookupAttr: match full path when matching in filelists, otherwise just the basenames.
Definition: StrMatcher.h:75
zypp::Match::SKIP_KIND
static const Match SKIP_KIND
LookupAttr: skip any kind: prefix when looking at a Solvable name.
Definition: StrMatcher.h:74
zypp::Match::NOCASE
static const Match NOCASE
If set, match case insensitive.
Definition: StrMatcher.h:59
zypp::Match::modeval
int modeval() const
Return the modes integer representation.
Definition: StrMatcher.h:152
zypp::Match::_modemask
static const int _modemask
Definition: StrMatcher.h:35
zypp::Match::mode
Mode mode() const
Return the mode part.
Definition: StrMatcher.cc:52
zypp::StrMatcher
String matching (STRING|SUBSTRING|GLOB|REGEX).
Definition: StrMatcher.h:298
zypp::StrMatcher::doMatch
bool doMatch(const char *string_r) const
Return whether string matches.
Definition: StrMatcher.cc:298
zypp::StrMatcher::searchstring
const std::string & searchstring() const
The current searchstring.
Definition: StrMatcher.cc:301
zypp::StrMatcher::flags
const Match & flags() const
The current search flags.
Definition: StrMatcher.cc:320
zypp::StrMatcher::_pimpl
RWCOW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: StrMatcher.h:392
zypp::StrMatcher::StrMatcher
StrMatcher()
Default ctor matches nothing.
Definition: StrMatcher.cc:260
zypp::StrMatcher::setSearchstring
void setSearchstring(const std::string &string_r)
Set a new searchstring.
Definition: StrMatcher.cc:304
zypp::StrMatcher::setFlags
void setFlags(const Match &flags_r)
Set new search flags.
Definition: StrMatcher.cc:323
zypp::StrMatcher::isCompiled
bool isCompiled() const
Whether the StrMatcher is already compiled.
Definition: StrMatcher.cc:295
zypp::StrMatcher::compile
void compile() const
Compile the pattern e.g.
Definition: StrMatcher.cc:292
std
Definition: Arch.h:348
str
String related utilities and Regular expression matching.
zypp::sat::detail::CDatamatcher
::s_Datamatcher CDatamatcher
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:59
zypp::str::form
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
zypp::str::hexstring
std::string hexstring(char n, int w=4)
Definition: String.h:321
zypp
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
zypp::operator<
bool operator<(const StrMatcher &lhs, const StrMatcher &rhs)
Definition: StrMatcher.cc:335
zypp::asString
std::string asString(const DefaultIntegral< Tp, TInitial > &obj)
Definition: DefaultIntegral.h:98
zypp::operator==
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...
Definition: SetRelationMixin.h:84
zypp::operator<<
std::ostream & operator<<(std::ostream &str, const Exception &obj)
Definition: Exception.cc:147
zypp::MatchException
Exceptions thrown from attribute matching.
Definition: StrMatcher.h:248
zypp::MatchInvalidRegexException
Invalid regular expression (failed ::regcomp).
Definition: StrMatcher.h:271
zypp::MatchInvalidRegexException::MatchInvalidRegexException
MatchInvalidRegexException(const std::string &msg_r)
Supplied message.
Definition: StrMatcher.h:273
zypp::MatchUnknownModeException
Unknown match mode.
Definition: StrMatcher.h:258
zypp::MatchUnknownModeException::MatchUnknownModeException
MatchUnknownModeException(const std::string &msg_r)
Supplied message.
Definition: StrMatcher.h:260
zypp::StrMatcher::Impl
StrMatcher implementation.
Definition: StrMatcher.cc:169
zypp::StrMatcher::Impl::Impl
Impl()
Definition: StrMatcher.cc:170
zypp::StrMatcher::Impl::~Impl
~Impl()
Definition: StrMatcher.cc:178
zypp::StrMatcher::Impl::compile
void compile() const
Compile the pattern.
Definition: StrMatcher.cc:182
zypp::StrMatcher::Impl::clone
Impl * clone() const
clone for RWCOW_pointer
Definition: StrMatcher.cc:246
zypp::StrMatcher::Impl::isCompiled
bool isCompiled() const
Whether the pattern is already compiled.
Definition: StrMatcher.cc:200
zypp::StrMatcher::Impl::_flags
Match _flags
Definition: StrMatcher.cc:240
zypp::StrMatcher::Impl::doMatch
bool doMatch(const char *string_r) const
Return whether string matches.
Definition: StrMatcher.cc:204
zypp::StrMatcher::Impl::invalidate
void invalidate()
Has to be called if _search or _flags change.
Definition: StrMatcher.cc:231
zypp::StrMatcher::Impl::setSearchstring
void setSearchstring(std::string string_r)
Set a new searchstring.
Definition: StrMatcher.cc:218
zypp::StrMatcher::Impl::operator<<
std::ostream & operator<<(std::ostream &str, const StrMatcher::Impl &obj)
Stream output.
Definition: StrMatcher.cc:251
zypp::StrMatcher::Impl::_search
std::string _search
Definition: StrMatcher.cc:239
zypp::StrMatcher::Impl::Impl
Impl(std::string search_r, const Match &flags_r)
Definition: StrMatcher.cc:173
zypp::StrMatcher::Impl::setFlags
void setFlags(const Match &flags_r)
Set new search flags.
Definition: StrMatcher.cc:226
zypp::StrMatcher::Impl::_matcher
scoped_ptr< sat::detail::CDatamatcher > _matcher
Definition: StrMatcher.cc:241
zypp::StrMatcher::Impl::searchstring
const std::string & searchstring() const
The current searchstring.
Definition: StrMatcher.cc:214
zypp::StrMatcher::Impl::flags
const Match & flags() const
The current search flags.
Definition: StrMatcher.cc:222