libzypp 17.32.2
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>
25#include <zypp-core/base/Iterator.h>
26#include <zypp-core/Globals.h>
27
28#ifdef __GNUG__
29#include <cstdlib>
30#include <memory>
31#include <cxxabi.h>
32#endif
33
35namespace 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;
270 using MapEntryType = MapEntry<PairType>;
271
272 struct Transformer
273 {
274 MapEntryType operator()( const PairType & pair_r ) const
275 { return mapEntry( pair_r ); }
276 };
277
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>
365 class DumpValues
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
An iterator over elements which are the result of applying some functional transformation to the elem...
const TMap & map() const
Definition LogTools.h:330
MapKey_const_iterator end() const
Definition LogTools.h:336
typename MapKVIteratorTraits< TMap >::Key_const_iterator MapKey_const_iterator
Definition LogTools.h:323
DumpKeys(const TMap &map_r)
Definition LogTools.h:326
MapKey_const_iterator begin() const
Definition LogTools.h:333
transform_iterator< Transformer, typename MapType::const_iterator > MapEntry_const_iterator
Definition LogTools.h:278
MapEntry_const_iterator begin() const
Definition LogTools.h:288
MapEntry< PairType > MapEntryType
Definition LogTools.h:270
typename TMap::value_type PairType
Definition LogTools.h:269
MapEntry_const_iterator end() const
Definition LogTools.h:291
const TMap & map() const
Definition LogTools.h:285
DumpMap(const TMap &map_r)
Definition LogTools.h:281
const TMap & map() const
Definition LogTools.h:375
DumpValues(const TMap &map_r)
Definition LogTools.h:371
typename MapKVIteratorTraits< TMap >::Value_const_iterator MapValue_const_iterator
Definition LogTools.h:368
MapValue_const_iterator end() const
Definition LogTools.h:381
MapValue_const_iterator begin() const
Definition LogTools.h:378
MapEntry(const TPair &pair_r)
Definition LogTools.h:233
const TPair & pair() const
Definition LogTools.h:237
const TPair *const _pair
Definition LogTools.h:241
String related utilities and Regular expression matching.
std::ostream & operator<<(std::ostream &str, const SolutionActionList &actionlist)
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition String.cc:37
Easy-to use interface to the ZYPP dependency resolver.
std::ostream & dumpRangeLine(std::ostream &str, TIterator begin, TIterator end)
Print range defined by iterators (single line style).
Definition LogTools.h:142
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
std::ostream & dumpRange(std::ostream &str, TIterator begin, TIterator end, const std::string &intro="{", const std::string &pfx="\n ", const std::string &sep="\n ", const std::string &sfx="\n", const std::string &extro="}")
Print range defined by iterators (multiline style).
Definition LogTools.h:119
iomanip::RangeLine< TIterator > rangeLine(TIterator begin, TIterator end)
Iomanip printing dumpRangeLine style.
Definition LogTools.h:185
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 & dumpOn(std::ostream &str, const Capability &obj)
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
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
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
std::ostream & hexdumpOn(std::ostream &outs, const unsigned char *ptr, size_t size)
hexdump data on stream
Definition LogTools.h:471
detail::Dump< Tp > dump(const Tp &obj_r)
Definition LogTools.h:460
bool _first
Definition LogTools.h:55
char _sep
Definition LogTools.h:56
transform_iterator< GetPairFirst< typename MapType::value_type >, typename MapType::const_iterator > Key_const_iterator
The key iterator type.
Definition Iterator.h:217
transform_iterator< GetPairSecond< typename MapType::value_type >, typename MapType::const_iterator > Value_const_iterator
The value iterator type.
Definition Iterator.h:221
MapEntryType operator()(const PairType &pair_r) const
Definition LogTools.h:274
const Tp & _obj
Definition LogTools.h:451
Dump(const Tp &obj_r)
Definition LogTools.h:450
RangeLine(TIterator begin, TIterator end)
Definition LogTools.h:161