libzypp  17.3.1
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"
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 
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 
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();
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;
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 
292  void StrMatcher::compile() const
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
Interface to gettext.
void setFlags(const Match &flags_r)
Set new search flags.
Definition: StrMatcher.cc:323
std::string asString(const DefaultIntegral< Tp, TInitial > &obj)
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
String matching option flags as used e.g.
Definition: StrMatcher.h:32
void invalidate()
Has to be called if _search or _flags change.
Definition: StrMatcher.cc:231
StrMatcher()
Default ctor matches nothing.
Definition: StrMatcher.cc:260
Match nothing.
Definition: StrMatcher.h:42
static const Match SKIP_KIND
LookupAttr: skip any kind: prefix when looking at a Solvable name.
Definition: StrMatcher.h:74
const std::string & searchstring() const
The current searchstring.
Definition: StrMatcher.cc:214
Impl * clone() const
clone for RWCOW_pointer
Definition: StrMatcher.cc:246
String matching (STRING|SUBSTRING|GLOB|REGEX).
Definition: StrMatcher.h:297
#define OUTS(V)
static const Match CHECKSUMS
LookupAttr: also look for matches in checksums.
Definition: StrMatcher.h:76
Regular Expression.
Definition: StrMatcher.h:48
bool isCompiled() const
Whether the StrMatcher is already compiled.
Definition: StrMatcher.cc:295
String related utilities and Regular expression matching.
std::string asString() const
String representation.
Definition: StrMatcher.cc:83
bool doMatch(const char *string_r) const
Return whether string matches.
Definition: StrMatcher.cc:298
Impl(std::string search_r, const Match &flags_r)
Definition: StrMatcher.cc:173
Definition: Arch.h:344
Exceptions thrown from attribute matching.
Definition: StrMatcher.h:247
void setFlags(const Match &flags_r)
Set new search flags.
Definition: StrMatcher.cc:226
RWCOW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: StrMatcher.h:392
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
Mode mode() const
Return the mode part.
Definition: StrMatcher.cc:52
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
Match at string start.
Definition: StrMatcher.h:44
Unknown match mode.
Definition: StrMatcher.h:257
bool isCompiled() const
Whether the pattern is already compiled.
Definition: StrMatcher.cc:200
void compile() const
Compile the pattern e.g.
Definition: StrMatcher.cc:292
void setSearchstring(const std::string &string_r)
Set a new searchstring.
Definition: StrMatcher.cc:304
std::ostream & operator<<(std::ostream &str, const Exception &obj)
Definition: Exception.cc:147
static const Match NO_STORAGE_SOLVABLE
LookupAttr: internal.
Definition: StrMatcher.h:69
scoped_ptr< sat::detail::CDatamatcher > _matcher
Definition: StrMatcher.cc:241
StrMatcher implementation.
Definition: StrMatcher.cc:168
Match substring.
Definition: StrMatcher.h:46
Match at string end.
Definition: StrMatcher.h:45
#define _(MSG)
Definition: Gettext.h:29
Mode
Mode flags (mutual exclusive).
Definition: StrMatcher.h:40
Invalid regular expression (failed ::regcomp).
Definition: StrMatcher.h:270
int modeval() const
Return the modes integer representation.
Definition: StrMatcher.h:152
const Match & flags() const
The current search flags.
Definition: StrMatcher.cc:222
void compile() const
Compile the pattern.
Definition: StrMatcher.cc:182
MatchUnknownModeException(const std::string &msg_r)
Supplied message.
Definition: StrMatcher.h:260
void setSearchstring(std::string string_r)
Set a new searchstring.
Definition: StrMatcher.cc:218
static const Match DISABLED_REPOS
LookupAttr: internal.
Definition: StrMatcher.h:72
static const Match NOCASE
If set, match case insensitive.
Definition: StrMatcher.h:59
int get() const
Return the integer representation.
Definition: StrMatcher.h:150
Excat matching.
Definition: StrMatcher.h:43
static const Match ARRAYSENTINEL
LookupAttr: internal.
Definition: StrMatcher.h:71
int flagval() const
Return the flags integer representation.
Definition: StrMatcher.h:154
const Match & flags() const
The current search flags.
Definition: StrMatcher.cc:320
static const int _flagmask
Definition: StrMatcher.h:36
static const Match COMPLETE_FILELIST
LookupAttr: internal.
Definition: StrMatcher.h:73
static const Match SUB
LookupAttr: internal.
Definition: StrMatcher.h:70
MatchInvalidRegexException(const std::string &msg_r)
Supplied message.
Definition: StrMatcher.h:273
::_Datamatcher CDatamatcher
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:59
bool operator<(const StrMatcher &lhs, const StrMatcher &rhs)
Definition: StrMatcher.cc:335
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
std::ostream & operator<<(std::ostream &str, const StrMatcher::Impl &obj)
Definition: StrMatcher.cc:251
static const Match FILES
LookupAttr: match full path when matching in filelists, otherwise just the basenames.
Definition: StrMatcher.h:75
std::string hexstring(char n, int w=4)
Definition: String.h:323
static const int _modemask
Definition: StrMatcher.h:35
const std::string & searchstring() const
The current searchstring.
Definition: StrMatcher.cc:301
Something else.
Definition: StrMatcher.h:49
bool doMatch(const char *string_r) const
Return whether string matches.
Definition: StrMatcher.cc:204