libzypp  17.32.5
LogTools.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_BASE_LOGTOOLS_H
13 #define ZYPP_BASE_LOGTOOLS_H
14 
15 #include <iostream>
16 #include <string>
17 #include <vector>
18 #include <list>
19 #include <set>
20 #include <map>
21 
22 #include <zypp-core/base/Hash.h>
23 #include <zypp-core/base/Logger.h>
24 #include <zypp-core/base/String.h>
26 #include <zypp-core/Globals.h>
27 
28 #ifdef __GNUG__
29 #include <cstdlib>
30 #include <memory>
31 #include <cxxabi.h>
32 #endif
33 
35 namespace zypp
36 {
37 
38  using std::endl;
39 
51  struct MLSep
52  {
53  MLSep() {}
54  MLSep( char sep_r ) : _sep { sep_r } {}
55  bool _first = true;
56  char _sep = '\n';
57  };
58  inline std::ostream & operator<<( std::ostream & str, MLSep & obj )
59  { if ( obj._first ) obj._first = false; else str << obj._sep; return str; }
60 
118  template<class TIterator>
119  std::ostream & dumpRange( std::ostream & str,
120  TIterator begin, TIterator end,
121  const std::string & intro = "{",
122  const std::string & pfx = "\n ",
123  const std::string & sep = "\n ",
124  const std::string & sfx = "\n",
125  const std::string & extro = "}" )
126  {
127  str << intro;
128  if ( begin != end )
129  {
130  str << pfx << *begin;
131  for ( ++begin; begin != end; ++begin )
132  str << sep << *begin;
133  str << sfx;
134  }
135  return str << extro;
136  }
137 
141  template<class TIterator>
142  std::ostream & dumpRangeLine( std::ostream & str,
143  TIterator begin, TIterator end )
144  { return dumpRange( str, begin, end, "(", "", ", ", "", ")" ); }
146  template<class TContainer>
147  std::ostream & dumpRangeLine( std::ostream & str, const TContainer & cont )
148  { return dumpRangeLine( str, cont.begin(), cont.end() ); }
149 
150 
152  namespace iomanip
153  {
158  template<class TIterator>
159  struct RangeLine
160  {
161  RangeLine( TIterator begin, TIterator end )
162  : _begin( begin )
163  , _end( end )
164  {}
165  TIterator _begin;
166  TIterator _end;
167  };
168 
170  template<class TIterator>
171  std::ostream & operator<<( std::ostream & str, const RangeLine<TIterator> & obj )
172  { return dumpRangeLine( str, obj._begin, obj._end ); }
173 
174  } // namespce iomanip
176 
184  template<class TIterator>
185  iomanip::RangeLine<TIterator> rangeLine( TIterator begin, TIterator end )
186  { return iomanip::RangeLine<TIterator>( begin, end ); }
188  template<class TContainer>
189  auto rangeLine( const TContainer & cont ) -> decltype( rangeLine( cont.begin(), cont.end() ) )
190  { return rangeLine( cont.begin(), cont.end() ); }
191 
192  template<class Tp>
193  std::ostream & operator<<( std::ostream & str, const std::vector<Tp> & obj )
194  { return dumpRange( str, obj.begin(), obj.end() ); }
195 
196  template<class Tp, class TCmp, class TAlloc>
197  std::ostream & operator<<( std::ostream & str, const std::set<Tp,TCmp,TAlloc> & obj )
198  { return dumpRange( str, obj.begin(), obj.end() ); }
199 
200  template<class Tp>
201  std::ostream & operator<<( std::ostream & str, const std::unordered_set<Tp> & obj )
202  { return dumpRange( str, obj.begin(), obj.end() ); }
203 
204  template<class Tp>
205  std::ostream & operator<<( std::ostream & str, const std::multiset<Tp> & obj )
206  { return dumpRange( str, obj.begin(), obj.end() ); }
207 
208  template<class Tp>
209  std::ostream & operator<<( std::ostream & str, const std::list<Tp> & obj )
210  { return dumpRange( str, obj.begin(), obj.end() ); }
211 
212  template<class Tp>
213  std::ostream & operator<<( std::ostream & str, const Iterable<Tp> & obj )
214  { return dumpRange( str, obj.begin(), obj.end() ); }
215 
217  namespace _logtoolsdetail
218  {
219 
221  // mapEntry
223 
229  template<class TPair>
230  class MapEntry
231  {
232  public:
233  MapEntry( const TPair & pair_r )
234  : _pair( &pair_r )
235  {}
236 
237  const TPair & pair() const
238  { return *_pair; }
239 
240  private:
241  const TPair *const _pair;
242  };
243 
245  template<class TPair>
246  std::ostream & operator<<( std::ostream & str, const MapEntry<TPair> & obj )
247  {
248  return str << '[' << obj.pair().first << "] = " << obj.pair().second;
249  }
250 
252  template<class TPair>
253  MapEntry<TPair> mapEntry( const TPair & pair_r )
254  { return MapEntry<TPair>( pair_r ); }
255 
257  // dumpMap
259 
264  template<class TMap>
265  class DumpMap
266  {
267  public:
268  using MapType = TMap;
269  using PairType = typename TMap::value_type;
271 
272  struct Transformer
273  {
274  MapEntryType operator()( const PairType & pair_r ) const
275  { return mapEntry( pair_r ); }
276  };
277 
278  using MapEntry_const_iterator = transform_iterator<Transformer, typename MapType::const_iterator>;
279 
280  public:
281  DumpMap( const TMap & map_r )
282  : _map( &map_r )
283  {}
284 
285  const TMap & map() const
286  { return *_map; }
287 
289  { return make_transform_iterator( map().begin(), Transformer() ); }
290 
292  { return make_transform_iterator( map().end(), Transformer() );}
293 
294  private:
295  const TMap *const _map;
296  };
297 
299  template<class TMap>
300  std::ostream & operator<<( std::ostream & str, const DumpMap<TMap> & obj )
301  { return dumpRange( str, obj.begin(), obj.end() ); }
302 
304  template<class TMap>
305  DumpMap<TMap> dumpMap( const TMap & map_r )
306  { return DumpMap<TMap>( map_r ); }
307 
309  // dumpKeys
311 
319  template<class TMap>
320  class DumpKeys
321  {
322  public:
324 
325  public:
326  DumpKeys( const TMap & map_r )
327  : _map( &map_r )
328  {}
329 
330  const TMap & map() const
331  { return *_map; }
332 
334  { return make_map_key_begin( map() ); }
335 
337  { return make_map_key_end( map() ); }
338 
339  private:
340  const TMap *const _map;
341  };
342 
344  template<class TMap>
345  std::ostream & operator<<( std::ostream & str, const DumpKeys<TMap> & obj )
346  { return dumpRange( str, obj.begin(), obj.end() ); }
347 
349  template<class TMap>
350  DumpKeys<TMap> dumpKeys( const TMap & map_r )
351  { return DumpKeys<TMap>( map_r ); }
352 
354  // dumpValues
356 
364  template<class TMap>
366  {
367  public:
369 
370  public:
371  DumpValues( const TMap & map_r )
372  : _map( &map_r )
373  {}
374 
375  const TMap & map() const
376  { return *_map; }
377 
379  { return make_map_value_begin( map() ); }
380 
382  { return make_map_value_end( map() ); }
383 
384  private:
385  const TMap *const _map;
386  };
387 
389  template<class TMap>
390  std::ostream & operator<<( std::ostream & str, const DumpValues<TMap> & obj )
391  { return dumpRange( str, obj.begin(), obj.end() ); }
392 
394  template<class TMap>
395  DumpValues<TMap> dumpValues( const TMap & map_r )
396  { return DumpValues<TMap>( map_r ); }
397 
399  } // namespace _logtoolsdetail
401 
402  // iomanipulator
403  using _logtoolsdetail::mapEntry; // std::pair as '[key] = value'
404  using _logtoolsdetail::dumpMap; // dumpRange '[key] = value'
405  using _logtoolsdetail::dumpKeys; // dumpRange keys
406  using _logtoolsdetail::dumpValues; // dumpRange values
407 
408  template<class TKey, class Tp>
409  std::ostream & operator<<( std::ostream & str, const std::map<TKey, Tp> & obj )
410  { return str << dumpMap( obj ); }
411 
412  template<class TKey, class Tp>
413  std::ostream & operator<<( std::ostream & str, const std::unordered_map<TKey, Tp> & obj )
414  { return str << dumpMap( obj ); }
415 
416  template<class TKey, class Tp>
417  std::ostream & operator<<( std::ostream & str, const std::multimap<TKey, Tp> & obj )
418  { return str << dumpMap( obj ); }
419 
429  inline std::ostream & operator<<( std::ostream & str, const std::basic_ios<char> & obj )
430  {
431  std::string ret( "[" );
432  ret += ( obj.good() ? 'g' : '_' );
433  ret += ( obj.eof() ? 'e' : '_' );
434  ret += ( obj.fail() ? 'F' : '_' );
435  ret += ( obj.bad() ? 'B' : '_' );
436  ret += "]";
437  return str << ret;
438  }
439 
441  // iomanipulator: str << dump(val) << ...
442  // calls: std::ostream & dumpOn( std::ostream & str, const Type & obj )
444 
445  namespace detail
446  {
447  template<class Tp>
448  struct Dump
449  {
450  Dump( const Tp & obj_r ) : _obj( obj_r ) {}
451  const Tp & _obj;
452  };
453 
454  template<class Tp>
455  std::ostream & operator<<( std::ostream & str, const Dump<Tp> & obj )
456  { return dumpOn( str, obj._obj ); }
457  }
458 
459  template<class Tp>
460  detail::Dump<Tp> dump( const Tp & obj_r )
461  { return detail::Dump<Tp>(obj_r); }
462 
471  inline std::ostream & hexdumpOn( std::ostream & outs, const unsigned char *ptr, size_t size )
472  {
473  size_t i = 0,c = 0;
474  unsigned width = 0x10;
475  outs << str::form( "hexdump %10.10ld bytes (0x%8.8lx):\n", (long)size, (long)size );
476 
477  for ( i = 0; i < size; i += width ) {
478  outs << str::form( "%4.4lx: ", (long)i );
479  /* show hex to the left */
480  for ( c = 0; c < width; ++c ) {
481  if ( i+c < size )
482  outs << str::form( "%02x ", ptr[i+c] );
483  else
484  outs << (" ");
485  }
486  /* show data on the right */
487  for ( c = 0; (c < width) && (i+c < size); ++c ) {
488  char x = (ptr[i+c] >= 0x20 && ptr[i+c] < 0x7f) ? ptr[i+c] : '.';
489  outs << x;
490  }
491  outs << std::endl;
492  }
493  return outs;
494  }
496  inline std::ostream & hexdumpOn( std::ostream & outs, const char *ptr, size_t size )
497  { return hexdumpOn( outs, (const unsigned char *)ptr, size ); }
498 
503  inline std::ostream & operator<<( std::ostream & str, const std::type_info &info )
504  {
505 #ifdef __GNUG__
506  int status = -4; // some arbitrary value to eliminate the compiler warning
507 
508  // enable c++11 by passing the flag -std=c++11 to g++
509  std::unique_ptr<char, void(*)(void*)> res {
510  abi::__cxa_demangle(info.name(), NULL, NULL, &status),
511  std::free
512  };
513  return str << std::string((status==0) ? res.get() : info.name());
514 #else
515  return str << info.name();
516 #endif
517  }
518 
519 
521 } // namespace zypp
523 #endif // ZYPP_BASE_LOGTOOLS_H
DumpKeys< TMap > dumpKeys(const TMap &map_r)
Definition: LogTools.h:350
std::ostream & dumpOn(std::ostream &str, const PoolQueryIterator &obj)
Definition: PoolQuery.cc:1842
const TMap & map() const
Definition: LogTools.h:375
const Tp & _obj
Definition: LogTools.h:451
Dump(const Tp &obj_r)
Definition: LogTools.h:450
MapKey_const_iterator end() const
Definition: LogTools.h:336
std::ostream & dumpRange(std::ostream &str, TIterator begin, TIterator end, const std::string &intro="{", const std::string &pfx="\ ", const std::string &sep="\ ", const std::string &sfx="\, const std::string &extro="}")
Print range defined by iterators (multiline style).
Definition: LogTools.h:119
MapValue_const_iterator end() const
Definition: LogTools.h:381
String related utilities and Regular expression matching.
MapKVIteratorTraits< TMap >::Value_const_iterator make_map_value_begin(const TMap &map_r)
Convenience to create the value iterator from container::begin()
Definition: Iterator.h:236
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
Definition: SerialNumber.cc:52
std::map wrapper for stream output.
Definition: LogTools.h:265
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:37
MapKVIteratorTraits< TMap >::Key_const_iterator make_map_key_begin(const TMap &map_r)
Convenience to create the key iterator from container::begin()
Definition: Iterator.h:226
MapEntry(const TPair &pair_r)
Definition: LogTools.h:233
typename TMap::value_type PairType
Definition: LogTools.h:269
MapEntry< TPair > mapEntry(const TPair &pair_r)
Definition: LogTools.h:253
std::pair wrapper for std::map output.
Definition: LogTools.h:230
transform_iterator< Transformer, typename MapType::const_iterator > MapEntry_const_iterator
Definition: LogTools.h:278
DumpValues(const TMap &map_r)
Definition: LogTools.h:371
const TMap *const _map
Definition: LogTools.h:295
iomanip::RangeLine< TIterator > rangeLine(TIterator begin, TIterator end)
Iomanip printing dumpRangeLine style.
Definition: LogTools.h:185
const TPair *const _pair
Definition: LogTools.h:241
MapKVIteratorTraits< TMap >::Key_const_iterator make_map_key_end(const TMap &map_r)
Convenience to create the key iterator from container::end()
Definition: Iterator.h:231
std::map wrapper for stream output of keys.
Definition: LogTools.h:320
MapValue_const_iterator begin() const
Definition: LogTools.h:378
transform_iterator< GetPairFirst< typename MapType::value_type >, typename MapType::const_iterator > Key_const_iterator
The key iterator type.
Definition: Iterator.h:217
DumpMap< TMap > dumpMap(const TMap &map_r)
Definition: LogTools.h:305
MapEntryType operator()(const PairType &pair_r) const
Definition: LogTools.h:274
std::ostream & hexdumpOn(std::ostream &outs, const unsigned char *ptr, size_t size)
hexdump data on stream
Definition: LogTools.h:471
MapKey_const_iterator begin() const
Definition: LogTools.h:333
bool _first
Definition: LogTools.h:55
MapEntry_const_iterator end() const
Definition: LogTools.h:291
MapKVIteratorTraits< TMap >::Value_const_iterator make_map_value_end(const TMap &map_r)
Convenience to create the value iterator from container::end()
Definition: Iterator.h:241
Helper to produce not-NL-terminated multi line output.
Definition: LogTools.h:51
typename MapKVIteratorTraits< TMap >::Key_const_iterator MapKey_const_iterator
Definition: LogTools.h:323
DumpValues< TMap > dumpValues(const TMap &map_r)
Definition: LogTools.h:395
transform_iterator< GetPairSecond< typename MapType::value_type >, typename MapType::const_iterator > Value_const_iterator
The value iterator type.
Definition: Iterator.h:221
MLSep(char sep_r)
Definition: LogTools.h:54
DumpKeys(const TMap &map_r)
Definition: LogTools.h:326
const TMap & map() const
Definition: LogTools.h:285
const TPair & pair() const
Definition: LogTools.h:237
const TMap & map() const
Definition: LogTools.h:330
const TMap *const _map
Definition: LogTools.h:340
std::ostream & dumpRangeLine(std::ostream &str, TIterator begin, TIterator end)
Print range defined by iterators (single line style).
Definition: LogTools.h:142
RangeLine(TIterator begin, TIterator end)
Definition: LogTools.h:161
std::map wrapper for stream output of values.
Definition: LogTools.h:365
Easy-to use interface to the ZYPP dependency resolver.
Definition: Application.cc:19
DumpMap(const TMap &map_r)
Definition: LogTools.h:281
detail::Dump< Tp > dump(const Tp &obj_r)
Definition: LogTools.h:460
char _sep
Definition: LogTools.h:56
MapEntry_const_iterator begin() const
Definition: LogTools.h:288
typename MapKVIteratorTraits< TMap >::Value_const_iterator MapValue_const_iterator
Definition: LogTools.h:368