| # Gaudi Framework, version v25r0 |

Home |  | Generated: Mon Feb 17 2014

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
MsgStream.h
Go to the documentation of this file.
1 #ifndef GAUDIKERNEL_MSGSTREAM_H
2 #define GAUDIKERNEL_MSGSTREAM_H
3
4 // Include files
5 #include "GaudiKernel/IMessageSvc.h"
6 #include "GaudiKernel/SerializeSTL.h"
7 // Standard C++ classes
8 #include <cstdio>
9 #include <string>
10 #include <iomanip>
11 #include <vector>
12 #include <sstream>
13
24 class MsgStream {
25 private:
29 typedef std::ios_base::fmtflags FLAG_TYPE;
30 typedef std::ios_base::iostate STATE_TYPE;
31 protected:
33 IMessageSvc* m_service;
35 std::string m_buffer;
37 std::string m_source;
39 std::ostringstream m_stream;
41 bool m_active;
43 MSG::Level m_level;
45 MSG::Level m_currLevel;
47 bool m_useColors;
50 IInactiveMessageCounter* m_inactCounter;
52 static bool m_countInactive;
53
54 public:
56 GAUDI_API MsgStream(IMessageSvc* svc, int buffer_length=128);
58 GAUDI_API MsgStream(IMessageSvc* svc, const std::string& source, int buffer_length=128);
60 MsgStream(const MsgStream& msg)
61 : m_service(msg.m_service),
62 m_active(msg.m_active),
63 m_level(msg.m_level),
64 m_useColors(msg.m_useColors),
65 m_inactCounter(msg.m_inactCounter)
66 {
67 try { // ignore exception if we cannot copy the string
68 m_source = msg.m_source;
69 }
70 catch (...) {}
71 }
73 GAUDI_API virtual ~MsgStream();
75 MsgStream& report(int lvl) {
76 lvl = (lvl >= MSG::NUM_LEVELS) ?
77 MSG::ALWAYS : (lvl<MSG::NIL) ? MSG::NIL : lvl;
78 if ((m_currLevel=MSG::Level(lvl)) >= level()) {
79 activate();
80 } else {
81 deactivate();
82 #ifndef NDEBUG
83 if (MsgStream::countInactive() && m_inactCounter) {
84 m_inactCounter->incrInactiveCount(MSG::Level(lvl),m_source);
85 }
86 #endif
87 }
88 return *this;
89 }
91 virtual GAUDI_API MsgStream& doOutput();
93 const std::string& buffer() const {
94 return m_buffer;
95 }
97 std::ostringstream& stream() {
98 return m_stream;
99 }
101 void setMsgSvc( IMessageSvc* svc ) {
102 m_service = svc;
103 }
105 void setLevel(int level) {
106 level = (level >= MSG::NUM_LEVELS) ?
107 MSG::ALWAYS : (level<MSG::NIL) ? MSG::NIL : level;
108 m_level = MSG::Level(level);
109 }
111 MSG::Level level() {
112 return m_level;
113 }
115 MSG::Level currentLevel() {
116 return m_currLevel;
117 }
119 void activate() {
120 m_active = true;
121 }
123 void deactivate() {
124 m_active = false;
125 }
127 bool isActive() const {
128 return m_active;
129 }
130 // oMsgStream flush emulation
131 MsgStream& flush() {
132 if ( isActive() ) m_stream.flush();
133 return *this;
134 }
135 // oMsgStream write emulation
136 MsgStream& write(const char* buff,int len) {
137 if ( isActive() ) m_stream.write(buff, len);
138 return *this;
139 }
141 MsgStream& operator<<(MsgStream& (*_f)(MsgStream&)) {
142 if ( isActive() ) _f(*this);
143 return *this;
144 }
146 MsgStream& operator<<(std::ostream& (*_f)(std::ostream&)) {
147 if ( isActive() ) _f(m_stream);
148 return *this;
149 }
151 MsgStream& operator<<(std::ios& (*_f)(std::ios&)) {
152 if ( isActive() ) _f(m_stream);
153 return *this;
154 }
156 MsgStream& operator<< (MSG::Level level) {
157 return report(level);
158 }
159 MsgStream& operator<<(longlong arg) {
160 try {
161 // this may throw, and we cannot afford it if the stream is used in a catch block
162 if(isActive()) {
163 m_stream << arg;
164 }
165 } catch (...) {}
166 return *this;
167 }
168
170 MsgStream& operator<<(std::ios_base& (*_f)(std::ios_base&)) {
171 if ( isActive() ) _f(m_stream);
172 return *this;
173 }
174
176 long flags() const {
177 return isActive() ? m_stream.flags() : 0;
178 }
179 long flags(FLAG_TYPE v) {
180 return isActive() ? m_stream.flags(v) : 0;
181 }
182 long setf(FLAG_TYPE v) {
183 return isActive() ? m_stream.setf(v) : 0;
184 }
185 int width() const {
186 return isActive() ? m_stream.width() : 0;
187 }
188 int width(int v) {
189 return isActive() ? m_stream.width(v) : 0;
190 }
191 char fill() const {
192 return isActive() ? m_stream.fill() : (char)-1;
193 }
194 char fill(char v) {
195 return isActive() ? m_stream.fill(v) : (char)-1;
196 }
197 int precision() const {
198 return isActive() ? m_stream.precision(): 0;
199 }
200 int precision(int v) {
201 return isActive() ? m_stream.precision(v): 0;
202 }
203 int rdstate() const {
204 return isActive() ? m_stream.rdstate () : std::ios_base::failbit;
205 }
206 int good() const {
207 return isActive() ? m_stream.good () : 0;
208 }
209 int eof() const {
210 return isActive() ? m_stream.eof () : 0;
211 }
212 int bad() const {
213 return isActive() ? m_stream.bad() : 0;
214 }
215 long setf(FLAG_TYPE _f, FLAG_TYPE _m) {
216 return isActive() ? m_stream.setf(_f, _m) : 0;
217 }
218 void unsetf(FLAG_TYPE _l) {
219 if ( isActive() ) m_stream.unsetf(_l);
220 }
221 void clear(STATE_TYPE _i = std::ios_base::failbit) {
222 if ( isActive() ) m_stream.clear(_i);
223 }
224
226 GAUDI_API void setColor(MSG::Color col);
228 GAUDI_API void setColor(MSG::Color fg, MSG::Color bg);
229
231 GAUDI_API void resetColor();
232
235 static GAUDI_API bool enableCountInactive(bool value = true);
236
238 static GAUDI_API bool countInactive();
239
240 };
241
243 inline MsgStream& endmsg(MsgStream& s) {
244 return s.doOutput();
245 }
246 #if defined(GAUDI_V20_COMPAT) && !defined(G21_NO_ENDREQ)
247
248 #define endreq endmsg
249 #endif
250
252 GAUDI_API std::string format(const char*, ... );
253
254 #ifdef _WIN32
255 template<class _E> inline
256 MsgStream& operator<<( MsgStream& s, const std::_Fillobj<_E>& obj) {
257 #if _MSC_VER > 1300
258 if ( s.isActive() ) s.stream().fill(obj._Fill);
259 #else
260 if ( s.isActive() ) s.stream().fill(obj._Ch);
261 #endif
262 return s;
263 }
264 template<class _Tm> inline
265 MsgStream& operator << (MsgStream& s, const std::_Smanip<_Tm>& manip) {
266 #if _MSC_VER > 1300
267 if ( s.isActive() ) (*manip._Pfun)(s.stream(), manip._Manarg);
268 #else
269 if ( s.isActive() ) (*manip._Pf)(s.stream(), manip._Manarg);
270 #endif
271 return s;
272 }
273 #elif defined (__GNUC__)
274 inline MsgStream& operator << (MsgStream& s,
275 const std::_Setiosflags &manip) {
276 try {
277 // this may throw, and we cannot afford it if the stream is used in a catch block
278 if ( s.isActive() ) s.stream() << manip;
279 } catch(...) {}
280 return s;
281 }
282 inline MsgStream& operator << (MsgStream& s,
283 const std::_Resetiosflags &manip) {
284 try {
285 // this may throw, and we cannot afford it if the stream is used in a catch block
286 if ( s.isActive() ) s.stream() << manip;
287 } catch (...) {}
288 return s;
289 }
290 inline MsgStream& operator << (MsgStream& s,
291 const std::_Setbase &manip) {
292 try {
293 // this may throw, and we cannot afford it if the stream is used in a catch block
294 if ( s.isActive() ) s.stream() << manip;
295 } catch (...) {}
296 return s;
297 }
298 inline MsgStream& operator << (MsgStream& s,
299 const std::_Setprecision &manip) {
300 try {
301 // this may throw, and we cannot afford it if the stream is used in a catch block
302 if ( s.isActive() ) s.stream() << manip;
303 } catch (...) {}
304 return s;
305 }
306 inline MsgStream& operator << (MsgStream& s,
307 const std::_Setw &manip) {
308 try {
309 // this may throw, and we cannot afford it if the stream is used in a catch block
310 if ( s.isActive() ) s.stream() << manip;
311 } catch (...) {}
312 return s;
313 }
314
315 namespace MSG {
316 inline
317 MsgStream& dec(MsgStream& log) {
318 log.setf(std::ios_base::dec, std::ios_base::basefield);
319 return log;
320 }
321 inline
322 MsgStream& hex(MsgStream& log) {
323 log.setf(std::ios_base::hex, std::ios_base::basefield);
324 return log;
325 }
326 }
327
328 #else // GCC, version << 3
329
330 template<class _Tm> inline
331 MsgStream& operator << (MsgStream& s, const std::smanip<_Tm>& manip) {
332 try {
333 // this may throw, and we cannot afford it if the stream is used in a catch block
334 if ( s.isActive() ) s.stream() << manip;
335 } catch (...) {}
336 return s;
337 }
338 #endif // WIN32 or (__GNUC__)
339
342 inline MsgStream& operator<< (MsgStream& s, const char *arg){
343 try {
344 // this may throw, and we cannot afford it if the stream is used in a catch block
345 if ( s.isActive() ) s.stream() << arg;
346 } catch (...) {}
347 return s;
348 }
349
351 template <typename T>
352 MsgStream& operator<< (MsgStream& lhs, const T& arg) {
353 using namespace GaudiUtils;
354 if(lhs.isActive())
355 try {
356 // this may throw, and we cannot afford it if the stream is used in a catch block
357 lhs.stream() << arg;
358 }
359 catch (...) {}
360 return lhs;
361 }
362
363 #ifdef __GNUC__
364
365 template<typename T>
366 MsgStream& operator << (MsgStream& lhs, const std::_Setfill<T> &manip) {
367 if ( lhs.isActive() )
368 try {
369 // this may throw, and we cannot afford it if the stream is used in a catch block
370 lhs.stream() << manip;
371 } catch(...) {}
372 return lhs;
373 }
374 #endif
375
376 #endif // GAUDIKERNEL_MSGSTREAM_H
377