1 /*---------------------------------------------------------------------\
3 | |__ / \ / / . \ . \ |
8 \---------------------------------------------------------------------*/
9 /** \file zypp/base/LogTools.h
12 #ifndef ZYPP_BASE_LOGTOOLS_H
13 #define ZYPP_BASE_LOGTOOLS_H
21 #include "zypp/base/Logger.h"
22 #include "zypp/base/Iterator.h"
24 ///////////////////////////////////////////////////////////////////
26 { /////////////////////////////////////////////////////////////////
28 /** Print range defined by iterators.
30 * intro [ pfx ITEM [ { sep ITEM }+ ] sfx ] extro
32 * The defaults print the range enclosed in \c {}, one item per
33 * line indented by 2 spaces.
39 * {} // on empty rande
41 * A comma separated list enclosed in \c () would be
43 * dumpRange( stream, begin, end, "(", "", ", ", "", ")" );
46 template<class _Iterator>
47 std::ostream & dumpRange( std::ostream & str,
48 _Iterator begin, _Iterator end,
49 const std::string & intro = "{",
50 const std::string & pfx = "\n ",
51 const std::string & sep = "\n ",
52 const std::string & sfx = "\n",
53 const std::string & extro = "}" )
59 for ( ++begin; begin != end; ++begin )
66 template<class _Iterator>
67 std::ostream & dumpRangeLine( std::ostream & str,
68 _Iterator begin, _Iterator end )
69 { return dumpRange( str, begin, end, "(", "", ", ", "", ")" ); }
72 std::ostream & operator<<( std::ostream & str, const std::vector<_Tp> & obj )
73 { return dumpRange( str, obj.begin(), obj.end() ); }
76 std::ostream & operator<<( std::ostream & str, const std::set<_Tp> & obj )
77 { return dumpRange( str, obj.begin(), obj.end() ); }
80 std::ostream & operator<<( std::ostream & str, const std::list<_Tp> & obj )
81 { return dumpRange( str, obj.begin(), obj.end() ); }
83 ///////////////////////////////////////////////////////////////////
84 namespace _logtoolsdetail
85 { /////////////////////////////////////////////////////////////////
87 ///////////////////////////////////////////////////////////////////
89 ///////////////////////////////////////////////////////////////////
91 /** std::pair wrapper for std::map output.
92 * Just because we want a special output format for std::pair
99 MapEntry( const _Pair & pair_r )
103 const _Pair & pair() const
107 const _Pair *const _pair;
110 /** \relates MapEntry Stream output. */
111 template<class _Pair>
112 std::ostream & operator<<( std::ostream & str, const MapEntry<_Pair> & obj )
114 return str << '[' << obj.pair().first << "] = " << obj.pair().second;
117 /** \relates MapEntry Convenience function to create MapEntry from std::pair. */
118 template<class _Pair>
119 MapEntry<_Pair> mapEntry( const _Pair & pair_r )
120 { return MapEntry<_Pair>( pair_r ); }
122 ///////////////////////////////////////////////////////////////////
124 ///////////////////////////////////////////////////////////////////
126 /** std::map wrapper for stream output.
127 * Provides the transform_iterator used to write std::pair formated as
134 typedef _Map MapType;
135 typedef typename _Map::value_type PairType;
136 typedef MapEntry<PairType> MapEntryType;
138 struct Transformer : public std::unary_function<PairType, MapEntryType>
140 MapEntryType operator()( const PairType & pair_r ) const
141 { return mapEntry( pair_r ); }
144 typedef transform_iterator<Transformer, typename MapType::const_iterator>
145 MapEntry_const_iterator;
148 DumpMap( const _Map & map_r )
152 const _Map & map() const
155 MapEntry_const_iterator map_begin() const
156 { return make_transform_iterator( map().begin(), Transformer() ); }
158 MapEntry_const_iterator map_end() const
159 { return make_transform_iterator( map().end(), Transformer() );}
162 const _Map *const _map;
165 /** \relates DumpMap Stream output. */
167 std::ostream & operator<<( std::ostream & str, const DumpMap<_Map> & obj )
168 { return dumpRange( str, obj.map_begin(), obj.map_end() ); }
170 /** \relates DumpMap Convenience function to create DumpMap from std::map. */
172 DumpMap<_Map> dumpMap( const _Map & map_r )
173 { return DumpMap<_Map>( map_r ); }
175 ///////////////////////////////////////////////////////////////////
177 ///////////////////////////////////////////////////////////////////
179 /** std::map wrapper for stream output of keys.
180 * Uses MapKVIterator iterate and write the key values.
182 * std::map<...> mymap;
183 * std::cout << dumpKeys(mymap) << std::endl;
190 DumpKeys( const _Map & map_r )
194 const _Map & map() const
198 const _Map *const _map;
201 /** \relates DumpKeys Stream output. */
203 std::ostream & operator<<( std::ostream & str, const DumpKeys<_Map> & obj )
204 { return dumpRange( str, make_map_key_begin(obj.map()), make_map_key_end(obj.map()) ); }
206 /** \relates DumpKeys Convenience function to create DumpKeys from std::map. */
208 DumpKeys<_Map> dumpKeys( const _Map & map_r )
209 { return DumpKeys<_Map>( map_r ); }
211 ///////////////////////////////////////////////////////////////////
213 ///////////////////////////////////////////////////////////////////
215 /** std::map wrapper for stream output of values.
216 * Uses MapKVIterator iterate and write the values.
218 * std::map<...> mymap;
219 * std::cout << dumpValues(mymap) << std::endl;
226 DumpValues( const _Map & map_r )
230 const _Map & map() const
234 const _Map *const _map;
237 /** \relates DumpValues Stream output. */
239 std::ostream & operator<<( std::ostream & str, const DumpValues<_Map> & obj )
240 { return dumpRange( str, make_map_value_begin(obj.map()), make_map_value_end(obj.map()) ); }
242 /** \relates DumpValues Convenience function to create DumpValues from std::map. */
244 DumpValues<_Map> dumpValues( const _Map & map_r )
245 { return DumpValues<_Map>( map_r ); }
247 /////////////////////////////////////////////////////////////////
248 } // namespace _logtoolsdetail
249 ///////////////////////////////////////////////////////////////////
252 using _logtoolsdetail::mapEntry; // std::pair as '[key] = value'
253 using _logtoolsdetail::dumpMap; // dumpRange '[key] = value'
254 using _logtoolsdetail::dumpKeys; // dumpRange keys
255 using _logtoolsdetail::dumpValues; // dumpRange values
257 template<class _Key, class _Tp>
258 std::ostream & operator<<( std::ostream & str, const std::map<_Key, _Tp> & obj )
259 { return str << dumpMap( obj ); }
261 /** Print stream status bits.
262 * Prints the values of a streams \c good, \c eof, \c failed and \c bad bit.
266 * [_eF_] - eof and fail bit set
267 * [__FB] - fail and bad bit set
270 inline std::ostream & operator<<( std::ostream & str, const std::basic_ios<char> & obj )
272 std::string ret( "[" );
273 ret += ( obj.good() ? 'g' : '_' );
274 ret += ( obj.eof() ? 'e' : '_' );
275 ret += ( obj.fail() ? 'F' : '_' );
276 ret += ( obj.bad() ? 'B' : '_' );
281 /////////////////////////////////////////////////////////////////
283 ///////////////////////////////////////////////////////////////////
284 #endif // ZYPP_BASE_LOGTOOLS_H