libzypp  17.14.0
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