The Gaudi Framework  master (2e52acd2)
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
MessageSvc Class Reference

#include </builds/gaudi/Gaudi/GaudiCoreSvc/src/MessageSvc/MessageSvc.h>

Inheritance diagram for MessageSvc:
Inheritance graph
[legend]
Collaboration diagram for MessageSvc:
Collaboration graph
[legend]

Classes

struct  MsgAry
 Private helper class to keep the count of messages of a type (MSG::LEVEL). More...
 

Public Types

typedef std::pair< std::string, std::ostream * > NamedStream
 
typedef std::multimap< int, NamedStream > StreamMap
 
typedef std::multimap< StatusCode, Message > MessageMap
 
typedef std::map< std::string, int, std::less<> > ThresholdMap
 
- Public Types inherited from extends< Service, IMessageSvc, IInactiveMessageCounter >
using base_class
 Typedef to this class.
 
using extend_interfaces_base
 Typedef to the base of this class.
 
- Public Types inherited from Service
using Factory = Gaudi::PluginService::Factory<IService*( const std::string&, ISvcLocator* )>
 
- Public Types inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
using PropertyHolderImpl
 Typedef used to refer to this class from derived classes, as in.
 
- Public Types inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
using base_class
 
- Public Types inherited from extend_interfaces< Interfaces... >
using ext_iids
 take union of the ext_iids of all Interfaces...
 

Public Member Functions

 MessageSvc (const std::string &name, ISvcLocator *svcloc)
 
StatusCode reinitialize () override
 
StatusCode initialize () override
 
StatusCode finalize () override
 
void reportMessage (const Message &message) override
 
void reportMessage (const Message &msg, int outputLevel) override
 
void reportMessage (const StatusCode &code, std::string_view source="") override
 
void reportMessage (std::string source, int type, std::string message) override
 
void insertMessage (const StatusCode &code, Message message) override
 
void eraseMessage () override
 
void eraseMessage (const StatusCode &code) override
 
void eraseMessage (const StatusCode &code, const Message &message) override
 
void insertStream (int message_type, std::string name, std::ostream *stream) override
 
void eraseStream () override
 
void eraseStream (int message_type) override
 
void eraseStream (int message_type, std::ostream *stream) override
 
void eraseStream (std::ostream *stream) override
 
std::ostream * defaultStream () const override
 
void setDefaultStream (std::ostream *stream) override
 
int outputLevel () const override
 
int outputLevel (std::string_view source) const override
 
void setOutputLevel (int new_level) override
 
void setOutputLevel (std::string_view source, int new_level) override
 
bool useColor () const override
 
std::string getLogColor (int logLevel) const override
 
int messageCount (MSG::Level logLevel) const override
 
void incrInactiveCount (MSG::Level level, std::string_view src) override
 
StatusCode setPropertyRepr (const std::string &n, const std::string &r) override
 
- Public Member Functions inherited from extends< Service, IMessageSvc, IInactiveMessageCounter >
void const * i_cast (const InterfaceID &tid) const override
 Implementation of IInterface::i_cast.
 
StatusCode queryInterface (const InterfaceID &ti, void **pp) override
 Implementation of IInterface::queryInterface.
 
std::vector< std::string > getInterfaceNames () const override
 Implementation of IInterface::getInterfaceNames.
 
- Public Member Functions inherited from Service
const std::string & name () const override
 Retrieve name of the service.
 
StatusCode configure () override
 
StatusCode initialize () override
 
StatusCode start () override
 
StatusCode stop () override
 
StatusCode finalize () override
 
StatusCode terminate () override
 
Gaudi::StateMachine::State FSMState () const override
 
Gaudi::StateMachine::State targetFSMState () const override
 
StatusCode reinitialize () override
 
StatusCode restart () override
 
StatusCode sysInitialize () override
 Initialize Service.
 
StatusCode sysStart () override
 Initialize Service.
 
StatusCode sysStop () override
 Initialize Service.
 
StatusCode sysFinalize () override
 Finalize Service.
 
StatusCode sysReinitialize () override
 Re-initialize the Service.
 
StatusCode sysRestart () override
 Re-initialize the Service.
 
 Service (std::string name, ISvcLocator *svcloc)
 Standard Constructor.
 
SmartIF< ISvcLocator > & serviceLocator () const override
 Retrieve pointer to service locator.
 
template<typename IFace = IService>
SmartIF< IFace > service (const std::string &name, bool createIf=true) const
 
template<class T>
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, ToolHandle< T > &hndl, const std::string &doc="none")
 
template<class T>
StatusCode declareTool (ToolHandle< T > &handle, bool createIf=true)
 
template<class T>
StatusCode declareTool (ToolHandle< T > &handle, const std::string &toolTypeAndName, bool createIf=true)
 Declare used tool.
 
template<class T>
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, ToolHandleArray< T > &hndlArr, const std::string &doc="none")
 
template<class T>
void addToolsArray (ToolHandleArray< T > &hndlArr)
 
const std::vector< IAlgTool * > & tools () const
 
SmartIF< IAuditorSvc > & auditorSvc () const
 The standard auditor service.May not be invoked before sysInitialize() has been invoked.
 
- Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
StatusCode setProperty (const Gaudi::Details::PropertyBase &p)
 Set the property from a property.
 
StatusCode setProperty (const std::string &name, const char *v)
 Special case for string literals.
 
StatusCode setProperty (const std::string &name, const std::string &v)
 Special case for std::string.
 
StatusCode setProperty (const std::string &name, const TYPE &value)
 set the property form the value
 
 PropertyHolder ()=default
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Details::PropertyBase &prop)
 Declare a property.
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, TYPE &value, const std::string &doc="none")
 Helper to wrap a regular data member and use it as a regular property.
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
 Declare a PropertyBase instance setting name and documentation.
 
Gaudi::Details::PropertyBase * declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
 Declare a remote property.
 
StatusCode setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
 set the property from another property with a different name
 
StatusCode setProperty (const std::string &s) override
 set the property from the formatted string
 
StatusCode setProperty (const Gaudi::Details::PropertyBase &p)
 Set the property from a property.
 
StatusCode setProperty (const std::string &name, const char *v)
 Special case for string literals.
 
StatusCode setProperty (const std::string &name, const std::string &v)
 Special case for std::string.
 
StatusCode setProperty (const std::string &name, const TYPE &value)
 set the property form the value
 
StatusCode setPropertyRepr (const std::string &n, const std::string &r) override
 set the property from name and value string representation
 
StatusCode getProperty (Gaudi::Details::PropertyBase *p) const override
 get the property
 
const Gaudi::Details::PropertyBase & getProperty (std::string_view name) const override
 get the property by name
 
StatusCode getProperty (std::string_view n, std::string &v) const override
 convert the property to the string
 
const std::vector< Gaudi::Details::PropertyBase * > & getProperties () const override
 get all properties
 
bool hasProperty (std::string_view name) const override
 Return true if we have a property with the given name.
 
Gaudi::Details::PropertyBase * property (std::string_view name) const
 \fixme property and bindPropertiesTo should be protected
 
void bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)
 
 PropertyHolder (const PropertyHolder &)=delete
 
PropertyHolder & operator= (const PropertyHolder &)=delete
 
- Public Member Functions inherited from CommonMessagingBase
virtual ~CommonMessagingBase ()=default
 Virtual destructor.
 
const SmartIF< IMessageSvc > & msgSvc () const
 The standard message service.
 
MsgStream & msgStream () const
 Return an uninitialized MsgStream.
 
MsgStream & msgStream (const MSG::Level level) const
 Predefined configurable message stream for the efficient printouts.
 
MsgStream & always () const
 shortcut for the method msgStream(MSG::ALWAYS)
 
MsgStream & fatal () const
 shortcut for the method msgStream(MSG::FATAL)
 
MsgStream & err () const
 shortcut for the method msgStream(MSG::ERROR)
 
MsgStream & error () const
 shortcut for the method msgStream(MSG::ERROR)
 
MsgStream & warning () const
 shortcut for the method msgStream(MSG::WARNING)
 
MsgStream & info () const
 shortcut for the method msgStream(MSG::INFO)
 
MsgStream & debug () const
 shortcut for the method msgStream(MSG::DEBUG)
 
MsgStream & verbose () const
 shortcut for the method msgStream(MSG::VERBOSE)
 
MsgStream & msg () const
 shortcut for the method msgStream(MSG::INFO)
 
MSG::Level msgLevel () const
 get the cached level (originally extracted from the embedded MsgStream)
 
bool msgLevel (MSG::Level lvl) const
 get the output level from the embedded MsgStream
 

Protected Member Functions

virtual void i_reportMessage (const Message &msg, int outputLevel)
 Internal implementation of reportMessage(const Message&,int) without lock.
 
virtual void i_reportMessage (const StatusCode &code, std::string_view source)
 Internal implementation of reportMessage(const StatusCode&,const std::string&) without lock.
 
virtual void i_onSuppressChanged (bool v)
 
virtual void i_onDefaultFormatChanged (const std::string &v)
 
- Protected Member Functions inherited from Service
std::vector< IAlgTool * > & tools ()
 
 ~Service () override
 
int outputLevel () const
 get the Service's output level
 
- Protected Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level setUpMessaging () const override final
 Set up local caches.
 
MSG::Level resetMessaging ()
 Reinitialize internal states.
 
void updateMsgStreamOutputLevel (int level)
 Update the output level of the cached MsgStream.
 

Protected Attributes

bool m_suppress { false }
 
std::string m_defaultFormat { Message::getDefaultFormat() }
 
- Protected Attributes inherited from Service
Gaudi::StateMachine::State m_state = Gaudi::StateMachine::OFFLINE
 Service state.
 
Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::OFFLINE
 Service state.
 
Gaudi::Property< int > m_outputLevel { this, "OutputLevel", MSG::NIL, "output level" }
 flag indicating whether ToolHandle tools have been added to m_tools
 
Gaudi::Property< bool > m_auditorInitialize { this, "AuditInitialize", false, "trigger auditor on initialize()" }
 
Gaudi::Property< bool > m_auditorStart { this, "AuditStart", false, "trigger auditor on start()" }
 
Gaudi::Property< bool > m_auditorStop { this, "AuditStop", false, "trigger auditor on stop()" }
 
Gaudi::Property< bool > m_auditorFinalize { this, "AuditFinalize", false, "trigger auditor on finalize()" }
 
Gaudi::Property< bool > m_auditorReinitialize { this, "AuditReinitialize", false, "trigger auditor on reinitialize()" }
 
Gaudi::Property< bool > m_auditorRestart { this, "AuditRestart", false, "trigger auditor on restart()" }
 
Gaudi::Property< bool > m_autoRetrieveTools
 
Gaudi::Property< bool > m_checkToolDeps
 
SmartIF< IAuditorSvc > m_pAuditorSvc
 Auditor Service.
 

Private Member Functions

void setupColors (Gaudi::Details::PropertyBase &prop)
 
void setupLimits (Gaudi::Details::PropertyBase &prop)
 
void setupThreshold (Gaudi::Details::PropertyBase &prop)
 
void setupInactCount (Gaudi::Details::PropertyBase &prop)
 
void setupLogStreams ()
 

Private Attributes

std::recursive_mutex m_reportMutex
 Mutex to synchronize multiple threads printing.
 
Gaudi::Property< std::string > m_defaultFormatProp
 
Gaudi::Property< std::string > m_defaultTimeFormat { this, "timeFormat", Message::getDefaultTimeFormat(), "" }
 
Gaudi::Property< bool > m_stats { this, "showStats", false, "" }
 
Gaudi::Property< unsigned int > m_statLevel { this, "statLevel", 0, "" }
 
std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS > m_thresholdProp
 
Gaudi::Property< bool > m_color { this, "useColors", false, "" }
 
std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS > m_logColors
 
std::array< Gaudi::Property< int >, MSG::NUM_LEVELS > m_msgLimit
 
Gaudi::Property< bool > m_suppressProp
 
Gaudi::Property< bool > m_inactCount { this, "countInactive", false, &MessageSvc::setupInactCount, "" }
 
Gaudi::Property< std::vector< std::string > > m_tracedInactiveSources
 
Gaudi::Property< std::map< std::string, std::string, std::less<> > > m_loggedStreamsName
 
std::ostream * m_defaultStream = &std::cout
 Pointer to the output stream.
 
Message m_defaultMessage
 Default Message.
 
StreamMap m_streamMap
 Stream map.
 
MessageMap m_messageMap
 Message map.
 
ThresholdMap m_thresholdMap
 Output level threshold map.
 
std::string m_logColorCodes [MSG::NUM_LEVELS]
 
std::map< std::string, MsgAry, std::less<> > m_sourceMap
 
std::map< std::string, MsgAry, std::less<> > m_inactiveMap
 
std::array< int, MSG::NUM_LEVELS > m_msgCount
 
std::map< std::string, std::shared_ptr< std::ostream >, std::less<> > m_loggedStreams
 
std::recursive_mutex m_messageMapMutex
 Mutex to synchronize multiple access to m_messageMap.
 
std::recursive_mutex m_thresholdMapMutex
 Mutex to synchronize multiple access to m_thresholdMap (.
 

Detailed Description

Definition at line 36 of file MessageSvc.h.

Member Typedef Documentation

◆ MessageMap

typedef std::multimap<StatusCode, Message> MessageSvc::MessageMap

Definition at line 40 of file MessageSvc.h.

◆ NamedStream

typedef std::pair<std::string, std::ostream*> MessageSvc::NamedStream

Definition at line 38 of file MessageSvc.h.

◆ StreamMap

typedef std::multimap<int, NamedStream> MessageSvc::StreamMap

Definition at line 39 of file MessageSvc.h.

◆ ThresholdMap

typedef std::map<std::string, int, std::less<> > MessageSvc::ThresholdMap

Definition at line 41 of file MessageSvc.h.

Constructor & Destructor Documentation

◆ MessageSvc()

MessageSvc::MessageSvc ( const std::string & name,
ISvcLocator * svcloc )

Definition at line 65 of file MessageSvc.cpp.

65 : base_class( name, svcloc ) {
66
67 m_outputLevel.declareUpdateHandler( [svcloc]( Gaudi::Details::PropertyBase& ) {
68 SmartIF<IAppMgrUI> app = svcloc;
69 if ( app ) app->outputLevelUpdate();
70 } );
71
72#ifndef NDEBUG
73 // initialize the MsgStream static flag.
74 MsgStream::enableCountInactive( m_inactCount );
75#endif
76
77 for ( int ic = 0; ic < MSG::NUM_LEVELS; ++ic ) {
78 m_logColors[ic].declareUpdateHandler( &MessageSvc::setupColors, this );
79 m_msgLimit[ic].declareUpdateHandler( &MessageSvc::setupLimits, this );
80 m_thresholdProp[ic].declareUpdateHandler( &MessageSvc::setupThreshold, this );
81 }
82
83 m_logColors[MSG::FATAL].set( { "blue", "red" } );
84 m_logColors[MSG::ERROR].set( { "white", "red" } );
85 m_logColors[MSG::WARNING].set( { "yellow" } );
86
87 std::fill( std::begin( m_msgCount ), std::end( m_msgCount ), 0 );
88}
MessageSvc::m_inactCount
Gaudi::Property< bool > m_inactCount
Definition MessageSvc.h:184
MessageSvc::m_msgLimit
std::array< Gaudi::Property< int >, MSG::NUM_LEVELS > m_msgLimit
Definition MessageSvc.h:173
MessageSvc::setupThreshold
void setupThreshold(Gaudi::Details::PropertyBase &prop)
Definition MessageSvc.cpp:161
MessageSvc::m_msgCount
std::array< int, MSG::NUM_LEVELS > m_msgCount
Definition MessageSvc.h:213
MessageSvc::m_logColors
std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS > m_logColors
Definition MessageSvc.h:164
MessageSvc::m_thresholdProp
std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS > m_thresholdProp
Definition MessageSvc.h:153
MessageSvc::setupLimits
void setupLimits(Gaudi::Details::PropertyBase &prop)
Definition MessageSvc.cpp:142
MessageSvc::setupColors
void setupColors(Gaudi::Details::PropertyBase &prop)
Definition MessageSvc.cpp:108
MsgStream::enableCountInactive
static GAUDI_API bool enableCountInactive(bool value=true)
Enable/disable the count of inactive messages.
Definition MsgStream.cpp:21
Service::m_outputLevel
Gaudi::Property< int > m_outputLevel
flag indicating whether ToolHandle tools have been added to m_tools
Definition Service.h:184
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition Service.cpp:333
MSG::NUM_LEVELS
@ NUM_LEVELS
Definition IMessageSvc.h:22
MSG::WARNING
@ WARNING
Definition IMessageSvc.h:22
MSG::FATAL
@ FATAL
Definition IMessageSvc.h:22
MSG::ERROR
@ ERROR
Definition IMessageSvc.h:22
Read.app
app
Definition Read.py:36

Member Function Documentation

◆ defaultStream()

std::ostream * MessageSvc::defaultStream ( ) const
inlineoverride

Definition at line 93 of file MessageSvc.h.

93{ return m_defaultStream; }
MessageSvc::m_defaultStream
std::ostream * m_defaultStream
Pointer to the output stream.
Definition MessageSvc.h:195

◆ eraseMessage() [1/3]

void MessageSvc::eraseMessage ( )
override

Definition at line 417 of file MessageSvc.cpp.

417 {
418 auto lock = std::scoped_lock{ m_messageMapMutex };
419 m_messageMap.clear();
420}
MessageSvc::m_messageMapMutex
std::recursive_mutex m_messageMapMutex
Mutex to synchronize multiple access to m_messageMap.
Definition MessageSvc.h:225
MessageSvc::m_messageMap
MessageMap m_messageMap
Message map.
Definition MessageSvc.h:198

◆ eraseMessage() [2/3]

void MessageSvc::eraseMessage ( const StatusCode & code)
override

Definition at line 422 of file MessageSvc.cpp.

422 {
423 auto lock = std::scoped_lock{ m_messageMapMutex };
424 m_messageMap.erase( key );
425}

◆ eraseMessage() [3/3]

void MessageSvc::eraseMessage ( const StatusCode & code,
const Message & message )
override

Definition at line 427 of file MessageSvc.cpp.

427 {
428 auto lock = std::scoped_lock{ m_messageMapMutex };
429
430 erase_if( m_messageMap, m_messageMap.equal_range( key ),
431 [&]( MessageMap::const_reference j ) { return j.second == msg; } );
432}

◆ eraseStream() [1/4]

void MessageSvc::eraseStream ( )
override

Definition at line 395 of file MessageSvc.cpp.

395{ m_streamMap.clear(); }
MessageSvc::m_streamMap
StreamMap m_streamMap
Stream map.
Definition MessageSvc.h:197

◆ eraseStream() [2/4]

void MessageSvc::eraseStream ( int message_type)
override

Definition at line 397 of file MessageSvc.cpp.

397{ m_streamMap.erase( message_type ); }

◆ eraseStream() [3/4]

void MessageSvc::eraseStream ( int message_type,
std::ostream * stream )
override

Definition at line 399 of file MessageSvc.cpp.

399 {
400 if ( stream ) {
401 erase_if( m_streamMap, m_streamMap.equal_range( key ),
402 [&]( StreamMap::const_reference j ) { return j.second.second == stream; } );
403 }
404}

◆ eraseStream() [4/4]

void MessageSvc::eraseStream ( std::ostream * stream)
override

Definition at line 406 of file MessageSvc.cpp.

406 {
407 if ( stream ) {
408 erase_if( m_streamMap, [&]( StreamMap::const_reference j ) { return j.second.second == stream; } );
409 }
410}
Write.stream
stream
Definition Write.py:32

◆ finalize()

StatusCode MessageSvc::finalize ( )
override

Definition at line 199 of file MessageSvc.cpp.

199 {
200 m_suppress = false;
201
202 {
203 std::ostringstream os;
204
205 if ( m_stats ) {
206 os << "Summarizing all message counts" << std::endl;
207 } else {
208 os << "Listing sources of suppressed message: " << std::endl;
209 }
210
211 os << "=====================================================" << std::endl;
212 os << " Message Source | Level | Count" << std::endl;
213 os << "-----------------------------+---------+-------------" << std::endl;
214
215 bool found( false );
216
217 for ( auto itr = m_sourceMap.begin(); itr != m_sourceMap.end(); ++itr ) {
218 for ( unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic ) {
219 if ( ( itr->second.msg[ic] >= m_msgLimit[ic] && m_msgLimit[ic] != 0 ) ||
220 ( m_stats && itr->second.msg[ic] > 0 && ic >= m_statLevel.value() ) ) {
221 os << " ";
222 os.width( 28 );
223 os.setf( std::ios_base::left, std::ios_base::adjustfield );
224 os << itr->first;
225 os << "|";
226
227 os.width( 8 );
228 os.setf( std::ios_base::right, std::ios_base::adjustfield );
229 os << levelNames[ic];
230 os << " |";
231
232 os.width( 9 );
233 os << itr->second.msg[ic];
234 os << std::endl;
235
236 found = true;
237 }
238 }
239 }
240 os << "=====================================================" << std::endl;
241 if ( found || m_stats ) std::cout << os.str() << std::flush;
242 }
243
244#ifndef NDEBUG
245 if ( m_inactCount.value() ) {
246
247 std::ostringstream os;
248 os << "Listing sources of Unprotected and Unseen messages\n";
249
250 bool found( false );
251
252 unsigned int ml( 0 );
253 for ( const auto& itr : m_inactiveMap ) {
254 for ( unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic ) {
255 if ( itr.second.msg[ic] != 0 && itr.first.length() > ml ) { ml = itr.first.length(); }
256 }
257 }
258
259 for ( unsigned int i = 0; i < ml + 25; ++i ) os << "=";
260
261 os << std::endl << " ";
262 os.width( ml + 2 );
263 os.setf( std::ios_base::left, std::ios_base::adjustfield );
264 os << "Message Source";
265 os.width( 1 );
266 os << "| Level | Count" << std::endl;
267
268 for ( unsigned int i = 0; i < ml + 3; ++i ) os << "-";
269 os << "+---------+-----------" << std::endl;
270
271 for ( auto itr = m_inactiveMap.begin(); itr != m_inactiveMap.end(); ++itr ) {
272 for ( unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic ) {
273 if ( itr->second.msg[ic] != 0 ) {
274 os << " ";
275 os.width( ml + 2 );
276 os.setf( std::ios_base::left, std::ios_base::adjustfield );
277 os << itr->first;
278
279 os << "|";
280
281 os.width( 8 );
282 os.setf( std::ios_base::right, std::ios_base::adjustfield );
283 os << levelNames[ic];
284
285 os << " |";
286
287 os.width( 9 );
288 os << itr->second.msg[ic];
289
290 os << std::endl;
291
292 found = true;
293 }
294 }
295 }
296 for ( unsigned int i = 0; i < ml + 25; ++i ) os << "=";
297 os << std::endl;
298
299 if ( found ) std::cout << os.str() << std::flush;
300 }
301#endif
302
303 return StatusCode::SUCCESS;
304}
MessageSvc::m_sourceMap
std::map< std::string, MsgAry, std::less<> > m_sourceMap
Definition MessageSvc.h:211
MessageSvc::m_inactiveMap
std::map< std::string, MsgAry, std::less<> > m_inactiveMap
Definition MessageSvc.h:211
MessageSvc::m_statLevel
Gaudi::Property< unsigned int > m_statLevel
Definition MessageSvc.h:151
MessageSvc::m_stats
Gaudi::Property< bool > m_stats
Definition MessageSvc.h:150
MessageSvc::m_suppress
bool m_suppress
Definition MessageSvc.h:137
StatusCode::SUCCESS
constexpr static const auto SUCCESS
Definition StatusCode.h:99

◆ getLogColor()

std::string MessageSvc::getLogColor ( int logLevel) const
override

Definition at line 456 of file MessageSvc.cpp.

456 {
457 return ( logLevel < MSG::NUM_LEVELS ) ? m_logColorCodes[logLevel] : "";
458}
MessageSvc::m_logColorCodes
std::string m_logColorCodes[MSG::NUM_LEVELS]
Definition MessageSvc.h:201

◆ i_onDefaultFormatChanged()

virtual void MessageSvc::i_onDefaultFormatChanged ( const std::string & v)
inlineprotectedvirtual

Reimplemented in InertMessageSvc.

Definition at line 140 of file MessageSvc.h.

140{ m_defaultFormat = v; }
MessageSvc::m_defaultFormat
std::string m_defaultFormat
Definition MessageSvc.h:138

◆ i_onSuppressChanged()

virtual void MessageSvc::i_onSuppressChanged ( bool v)
inlineprotectedvirtual

Reimplemented in InertMessageSvc.

Definition at line 139 of file MessageSvc.h.

139{ m_suppress = v; }

◆ i_reportMessage() [1/2]

void MessageSvc::i_reportMessage ( const Message & msg,
int outputLevel )
protectedvirtual

Internal implementation of reportMessage(const Message&,int) without lock.

Definition at line 311 of file MessageSvc.cpp.

311 {
312 int key = msg.getType();
313
314 ++m_msgCount[key];
315
316 const Message* cmsg = &msg;
317
318 // processing logged streams
319 if ( !m_loggedStreams.empty() ) {
320 auto iLog = m_loggedStreams.find( msg.getSource() );
321 if ( m_loggedStreams.end() != iLog ) { ( *iLog->second ) << *cmsg << std::endl; }
322 }
323
324 if ( m_suppress || m_stats.value() ) {
325
326 // Increase the counter of 'key' type of messages for the source and
327 // get the new value.
328 const int nmsg = ++( m_sourceMap[msg.getSource()].msg[key] );
329
330 if ( m_suppress && m_msgLimit[key] != 0 ) {
331 if ( nmsg > m_msgLimit[key] ) return;
332 if ( nmsg == m_msgLimit[key] ) {
333 std::string txt = levelNames[key] + " message limit (" + std::to_string( m_msgLimit[key].value() ) +
334 ") reached for " + msg.getSource() + ". Suppressing further output.";
335 cmsg = new Message( msg.getSource(), MSG::WARNING, std::move( txt ) );
336 cmsg->setFormat( msg.getFormat() );
337 }
338 }
339 }
340
341 auto range = m_streamMap.equal_range( key );
342 if ( range.first != m_streamMap.end() ) {
343 std::for_each( range.first, range.second,
344 [&]( StreamMap::const_reference sm ) { *sm.second.second << *cmsg << std::endl; } );
345 } else if ( key >= outputLevel ) {
346 msg.setFormat( m_defaultFormat );
347 msg.setTimeFormat( m_defaultTimeFormat );
348 if ( !m_color ) {
349 ( *m_defaultStream ) << *cmsg << std::endl << std::flush;
350 } else {
351 ( *m_defaultStream ) << m_logColorCodes[key] << *cmsg << "\033[m" << std::endl << std::flush;
352 }
353 }
354
355 if ( cmsg != &msg ) { delete cmsg; } // cppcheck-suppress autovarInvalidDeallocation; false positive
356}
CommonMessagingBase::msg
MsgStream & msg() const
shortcut for the method msgStream(MSG::INFO)
Definition CommonMessaging.h:124
Message::setFormat
void setFormat(std::string msg) const
Set the format string.
Definition Message.cpp:97
MessageSvc::m_color
Gaudi::Property< bool > m_color
Definition MessageSvc.h:162
MessageSvc::m_defaultTimeFormat
Gaudi::Property< std::string > m_defaultTimeFormat
Definition MessageSvc.h:149
MessageSvc::m_loggedStreams
std::map< std::string, std::shared_ptr< std::ostream >, std::less<> > m_loggedStreams
Definition MessageSvc.h:215
MessageSvc::outputLevel
int outputLevel() const override
Definition MessageSvc.cpp:434
Gaudi::Functional::details::zip::range
decltype(auto) range(Args &&... args)
Zips multiple containers together to form a single range.
Definition zip.h:67

◆ i_reportMessage() [2/2]

void MessageSvc::i_reportMessage ( const StatusCode & code,
std::string_view source )
protectedvirtual

Internal implementation of reportMessage(const StatusCode&,const std::string&) without lock.

Definition at line 374 of file MessageSvc.cpp.

374 {
375 int level = outputLevel( source );
376 auto report = [&]( Message mesg ) {
377 mesg.setSource( source );
378 Message stat_code( std::string{ source }, mesg.getType(), "Status Code " + std::to_string( code.getCode() ) );
379 i_reportMessage( std::move( stat_code ), level );
380 i_reportMessage( std::move( mesg ), level );
381 };
382
383 auto range = m_messageMap.equal_range( code );
384 if ( range.first != m_messageMap.end() ) {
385 std::for_each( range.first, range.second, [&]( MessageMap::const_reference sm ) { report( sm.second ); } );
386 } else {
387 report( m_defaultMessage );
388 }
389}
MessageSvc::m_defaultMessage
Message m_defaultMessage
Default Message.
Definition MessageSvc.h:196
MessageSvc::i_reportMessage
virtual void i_reportMessage(const Message &msg, int outputLevel)
Internal implementation of reportMessage(const Message&,int) without lock.
Definition MessageSvc.cpp:311
StatusCode::getCode
code_t getCode() const
Retrieve value.
Definition StatusCode.h:136

◆ incrInactiveCount()

void MessageSvc::incrInactiveCount ( MSG::Level level,
std::string_view src )
override

Definition at line 462 of file MessageSvc.cpp.

462 {
463 auto entry = m_inactiveMap.find( source );
464 if ( entry == m_inactiveMap.end() ) { entry = m_inactiveMap.emplace( source, MsgAry{} ).first; }
465 ++entry->second.msg[level];
466
467 if ( std::find( begin( m_tracedInactiveSources ), end( m_tracedInactiveSources ), source ) !=
468 end( m_tracedInactiveSources ) ) {
469 std::cout << "== inactive message detected from " << source << " ==\n";
470 std::string t;
471 System::backTrace( t, 25, 0 );
472 std::cout << t << std::endl;
473 }
474}
MessageSvc::m_tracedInactiveSources
Gaudi::Property< std::vector< std::string > > m_tracedInactiveSources
Definition MessageSvc.h:186
Gaudi::Utils::begin
AttribStringParser::Iterator begin(const AttribStringParser &parser)
Definition AttribStringParser.h:135
System::backTrace
GAUDI_API int backTrace(void **addresses, const int depth)
Definition System.cpp:372
bug_34121.t
t
Definition bug_34121.py:31
MessageSvc::MsgAry
Private helper class to keep the count of messages of a type (MSG::LEVEL).
Definition MessageSvc.h:204

◆ initialize()

StatusCode MessageSvc::initialize ( )
override

Definition at line 90 of file MessageSvc.cpp.

90 {
91 StatusCode sc = Service::initialize();
92 if ( sc.isFailure() ) return sc;
93
94 // make sure the map of logged stream names is initialized
95 setupLogStreams();
96
97 return StatusCode::SUCCESS;
98}
MessageSvc::setupLogStreams
void setupLogStreams()
Definition MessageSvc.cpp:476
Service::initialize
StatusCode initialize() override
Definition Service.cpp:118
StatusCode::isFailure
bool isFailure() const
Definition StatusCode.h:129

◆ insertMessage()

void MessageSvc::insertMessage ( const StatusCode & code,
Message message )
override

Definition at line 412 of file MessageSvc.cpp.

412 {
413 auto lock = std::scoped_lock{ m_messageMapMutex };
414 m_messageMap.emplace( key, std::move( msg ) );
415}

◆ insertStream()

void MessageSvc::insertStream ( int message_type,
std::string name,
std::ostream * stream )
override

Definition at line 391 of file MessageSvc.cpp.

391 {
392 m_streamMap.emplace( key, NamedStream( std::move( name ), stream ) );
393}
MessageSvc::NamedStream
std::pair< std::string, std::ostream * > NamedStream
Definition MessageSvc.h:38

◆ messageCount()

int MessageSvc::messageCount ( MSG::Level logLevel) const
override

Definition at line 460 of file MessageSvc.cpp.

460{ return m_msgCount[level]; }

◆ outputLevel() [1/2]

int MessageSvc::outputLevel ( ) const
override

Definition at line 434 of file MessageSvc.cpp.

434{ return m_outputLevel; }

◆ outputLevel() [2/2]

int MessageSvc::outputLevel ( std::string_view source) const
override

Definition at line 436 of file MessageSvc.cpp.

436 {
437 auto lock = std::scoped_lock{ m_thresholdMapMutex };
438 auto it = m_thresholdMap.find( source );
439 return it != m_thresholdMap.end() ? it->second : m_outputLevel.value();
440}
MessageSvc::m_thresholdMap
ThresholdMap m_thresholdMap
Output level threshold map.
Definition MessageSvc.h:199
MessageSvc::m_thresholdMapMutex
std::recursive_mutex m_thresholdMapMutex
Mutex to synchronize multiple access to m_thresholdMap (.
Definition MessageSvc.h:229

◆ reinitialize()

StatusCode MessageSvc::reinitialize ( )
override

Definition at line 100 of file MessageSvc.cpp.

100 {
101 m_state = Gaudi::StateMachine::OFFLINE;
102 StatusCode sc = initialize();
103 if ( sc.isSuccess() ) m_state = Gaudi::StateMachine::INITIALIZED;
104
105 return sc;
106}
MessageSvc::initialize
StatusCode initialize() override
Definition MessageSvc.cpp:90
Service::m_state
Gaudi::StateMachine::State m_state
Service state.
Definition Service.h:155
StatusCode::isSuccess
bool isSuccess() const
Definition StatusCode.h:314

◆ reportMessage() [1/4]

void MessageSvc::reportMessage ( const Message & message)
override

Definition at line 358 of file MessageSvc.cpp.

358{ reportMessage( msg, outputLevel( msg.getSource() ) ); }
MessageSvc::reportMessage
void reportMessage(const Message &message) override
Definition MessageSvc.cpp:358

◆ reportMessage() [2/4]

void MessageSvc::reportMessage ( const Message & msg,
int outputLevel )
override

Definition at line 306 of file MessageSvc.cpp.

306 {
307 auto lock = std::scoped_lock{ m_reportMutex };
308 i_reportMessage( msg, outputLevel );
309}
MessageSvc::m_reportMutex
std::recursive_mutex m_reportMutex
Mutex to synchronize multiple threads printing.
Definition MessageSvc.h:144

◆ reportMessage() [3/4]

void MessageSvc::reportMessage ( const StatusCode & code,
std::string_view source = "" )
override

Definition at line 369 of file MessageSvc.cpp.

369 {
370 auto lock = std::scoped_lock{ m_messageMapMutex };
371 i_reportMessage( code, source );
372}

◆ reportMessage() [4/4]

void MessageSvc::reportMessage ( std::string source,
int type,
std::string message )
override

Definition at line 365 of file MessageSvc.cpp.

365 {
366 reportMessage( Message{ std::move( source ), type, std::move( message ) } );
367}

◆ setDefaultStream()

void MessageSvc::setDefaultStream ( std::ostream * stream)
inlineoverride

Definition at line 96 of file MessageSvc.h.

96 {
97 auto lock = std::scoped_lock{ m_reportMutex };
98 m_defaultStream = stream;
99 }

◆ setOutputLevel() [1/2]

void MessageSvc::setOutputLevel ( int new_level)
override

Definition at line 442 of file MessageSvc.cpp.

442{ m_outputLevel = new_level; }

◆ setOutputLevel() [2/2]

void MessageSvc::setOutputLevel ( std::string_view source,
int new_level )
override

Definition at line 444 of file MessageSvc.cpp.

444 {
445 auto lock = std::scoped_lock{ m_thresholdMapMutex };
446
447 // only write if we really have to...
448 auto i = m_thresholdMap.find( source );
449 if ( i == m_thresholdMap.end() ) {
450 m_thresholdMap.emplace( source, level );
451 } else if ( i->second != level ) {
452 i->second = level;
453 }
454}

◆ setPropertyRepr()

StatusCode MessageSvc::setPropertyRepr ( const std::string & n,
const std::string & r )
override

Definition at line 360 of file MessageSvc.cpp.

360 {
361 auto lock = std::scoped_lock{ m_reportMutex };
362 return Service::setPropertyRepr( n, r );
363}
PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >::setPropertyRepr
StatusCode setPropertyRepr(const std::string &n, const std::string &r) override
Definition PropertyHolder.h:169

◆ setupColors()

void MessageSvc::setupColors ( Gaudi::Details::PropertyBase & prop)
private

Definition at line 108 of file MessageSvc.cpp.

108 {
109 const auto& pname = prop.name();
110 int level =
111 ( pname == "fatalColorCode" ? MSG::FATAL
112 : pname == "errorColorCode" ? MSG::ERROR
113 : pname == "warningColorCode" ? MSG::WARNING
114 : pname == "infoColorCode" ? MSG::INFO
115 : pname == "debugColorCode" ? MSG::DEBUG
116 : pname == "verboseColorCode" ? MSG::VERBOSE
117 : pname == "alwaysColorCode"
118 ? MSG::ALWAYS
119 : ( throw GaudiException( "ERROR: Unknown message color parameter: " + pname, name(), StatusCode::FAILURE ),
120 -1 ) );
121
122 auto& code = m_logColorCodes[level];
123
124 const auto& col_desc = m_logColors[level].value();
125
126 if ( col_desc.size() == 1 ) {
127 const std::string& desc = col_desc[0];
128 if ( desc.empty() ) {
129 code = "";
130 } else if ( desc[0] == '[' ) {
131 code = "\033" + desc;
132 } else {
133 code = "\033[" + colTrans( desc, 90 ) + ";1m";
134 }
135 } else if ( col_desc.size() == 2 ) {
136 code = "\033[" + colTrans( col_desc[0], 90 ) + ";" + colTrans( col_desc[1], 100 ) + ";1m";
137 } else { // empty desc: no color
138 code = "";
139 }
140}
Gaudi::Details::PropertyBase::name
const std::string name() const
property name
Definition PropertyBase.h:38
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition StatusCode.h:100
MSG::DEBUG
@ DEBUG
Definition IMessageSvc.h:22
MSG::ALWAYS
@ ALWAYS
Definition IMessageSvc.h:22
MSG::INFO
@ INFO
Definition IMessageSvc.h:22
MSG::VERBOSE
@ VERBOSE
Definition IMessageSvc.h:22

◆ setupInactCount()

void MessageSvc::setupInactCount ( Gaudi::Details::PropertyBase & prop)
private

Definition at line 191 of file MessageSvc.cpp.

191 {
192 if ( prop.name() == "countInactive" ) {
193 Gaudi::Property<bool>* p = dynamic_cast<Gaudi::Property<bool>*>( &prop );
194 if ( p ) MsgStream::enableCountInactive( p->value() );
195 }
196}
Gaudi::Property::value
const ValueType & value() const
Definition Property.h:251

◆ setupLimits()

void MessageSvc::setupLimits ( Gaudi::Details::PropertyBase & prop)
private

Definition at line 142 of file MessageSvc.cpp.

142 {
143 // Just report problems in the settings of the limits and unknown limit parameters
144 if ( prop.name() == "alwaysLimit" ) {
145 Gaudi::Property<int>* p = dynamic_cast<Gaudi::Property<int>*>( &prop );
146 if ( p && p->value() != 0 ) {
147 std::cout << "MessageSvc ERROR: cannot suppress ALWAYS messages" << std::endl;
148 p->setValue( 0 );
149 }
150 } else if ( prop.name() == "defaultLimit" ) {
151 for ( int i = MSG::VERBOSE; i < MSG::NUM_LEVELS; ++i ) {
152 if ( i != MSG::ALWAYS ) { m_msgLimit[i] = m_msgLimit[MSG::NIL].value(); }
153 }
154 } else if ( prop.name() != "fatalLimit" && prop.name() != "errorLimit" && prop.name() != "warningLimit" &&
155 prop.name() == "infoLimit" && prop.name() == "debugLimit" && prop.name() == "verboseLimit" ) {
156 std::cout << "MessageSvc ERROR: Unknown message limit parameter: " << prop.name() << std::endl;
157 return;
158 }
159}
Gaudi::Property::setValue
bool setValue(const ValueType &v)
Definition Property.h:253
MSG::NIL
@ NIL
Definition IMessageSvc.h:22

◆ setupLogStreams()

void MessageSvc::setupLogStreams ( )
private

Definition at line 476 of file MessageSvc.cpp.

476 {
477 // reset state
478 m_loggedStreams.clear();
479
480 // make the unique set of output filenames
481 std::set<std::string_view> outFileNames;
482 std::transform( m_loggedStreamsName.begin(), m_loggedStreamsName.end(),
483 std::inserter( outFileNames, outFileNames.end() ),
484 []( const auto& p ) -> std::string_view { return p.second; } );
485 // map each unique filename to an ofstream
486 std::map<std::string_view, std::shared_ptr<std::ofstream>> outStreams;
487 std::transform( outFileNames.begin(), outFileNames.end(), std::inserter( outStreams, outStreams.end() ),
488 []( std::string_view fname ) {
489 return std::pair{ fname, std::make_shared<std::ofstream>(
490 std::string{ fname }, std::ios_base::out | std::ios_base::trunc ) };
491 } );
492 // associate the stream to ofstream...
493 for ( auto& iProp : m_loggedStreamsName ) {
494 auto& stream = outStreams.at( iProp.second );
495 if ( stream->good() ) m_loggedStreams.emplace( iProp.first, stream );
496 }
497}
MessageSvc::m_loggedStreamsName
Gaudi::Property< std::map< std::string, std::string, std::less<> > > m_loggedStreamsName
Definition MessageSvc.h:192

◆ setupThreshold()

void MessageSvc::setupThreshold ( Gaudi::Details::PropertyBase & prop)
private

Definition at line 161 of file MessageSvc.cpp.

161 {
162
163 static const std::array<std::pair<const char*, MSG::Level>, 7> tbl{ { { "setFatal", MSG::FATAL },
164 { "setError", MSG::ERROR },
165 { "setWarning", MSG::WARNING },
166 { "setInfo", MSG::INFO },
167 { "setDebug", MSG::DEBUG },
168 { "setVerbose", MSG::VERBOSE },
169 { "setAlways", MSG::ALWAYS } } };
170
171 auto i = std::find_if( std::begin( tbl ), std::end( tbl ),
172 [&]( const std::pair<const char*, MSG::Level>& t ) { return prop.name() == t.first; } );
173 if ( i == std::end( tbl ) ) {
174 std::cerr << "MessageSvc ERROR: Unknown message threshold parameter: " << prop.name() << std::endl;
175 return;
176 }
177 int ic = i->second;
178
179 Gaudi::Property<std::vector<std::string>>* sap = dynamic_cast<Gaudi::Property<std::vector<std::string>>*>( &prop );
180 if ( !sap ) {
181 std::cerr << "could not dcast " << prop.name()
182 << " to a Gaudi::Property<std::vector<std::string>> (which it should be!)" << std::endl;
183 } else {
184 for ( auto& i : sap->value() ) setOutputLevel( i, ic );
185 }
186}
MessageSvc::setOutputLevel
void setOutputLevel(int new_level) override
Definition MessageSvc.cpp:442

◆ useColor()

bool MessageSvc::useColor ( ) const
inlineoverride

Definition at line 114 of file MessageSvc.h.

114{ return m_color; }

Member Data Documentation

◆ m_color

Gaudi::Property<bool> MessageSvc::m_color { this, "useColors", false, "" }
private

Definition at line 162 of file MessageSvc.h.

162{ this, "useColors", false, "" };

◆ m_defaultFormat

std::string MessageSvc::m_defaultFormat { Message::getDefaultFormat() }
protected

Definition at line 138 of file MessageSvc.h.

138{ Message::getDefaultFormat() };
Message::getDefaultFormat
static const std::string getDefaultFormat()
Get the default format string.
Definition Message.h:68

◆ m_defaultFormatProp

Gaudi::Property<std::string> MessageSvc::m_defaultFormatProp
private
Initial value:
{
this, "Format", Message::getDefaultFormat(),
[this]( auto& ) { i_onDefaultFormatChanged( m_defaultFormatProp.value() ); }, "" }
MessageSvc::m_defaultFormatProp
Gaudi::Property< std::string > m_defaultFormatProp
Definition MessageSvc.h:146
MessageSvc::i_onDefaultFormatChanged
virtual void i_onDefaultFormatChanged(const std::string &v)
Definition MessageSvc.h:140

Definition at line 146 of file MessageSvc.h.

146 {
147 this, "Format", Message::getDefaultFormat(),
148 [this]( auto& ) { i_onDefaultFormatChanged( m_defaultFormatProp.value() ); }, "" };

◆ m_defaultMessage

Message MessageSvc::m_defaultMessage
private

Default Message.

Definition at line 196 of file MessageSvc.h.

◆ m_defaultStream

std::ostream* MessageSvc::m_defaultStream = &std::cout
private

Pointer to the output stream.

Definition at line 195 of file MessageSvc.h.

◆ m_defaultTimeFormat

Gaudi::Property<std::string> MessageSvc::m_defaultTimeFormat { this, "timeFormat", Message::getDefaultTimeFormat(), "" }
private

Definition at line 149 of file MessageSvc.h.

149{ this, "timeFormat", Message::getDefaultTimeFormat(), "" };
Message::getDefaultTimeFormat
static const std::string getDefaultTimeFormat()
Get the default time format string.
Definition Message.h:77

◆ m_inactCount

Gaudi::Property<bool> MessageSvc::m_inactCount { this, "countInactive", false, &MessageSvc::setupInactCount, "" }
private

Definition at line 184 of file MessageSvc.h.

184{ this, "countInactive", false, &MessageSvc::setupInactCount, "" };
MessageSvc::setupInactCount
void setupInactCount(Gaudi::Details::PropertyBase &prop)
Definition MessageSvc.cpp:191

◆ m_inactiveMap

std::map<std::string, MsgAry, std::less<> > MessageSvc::m_inactiveMap
private

Definition at line 211 of file MessageSvc.h.

◆ m_logColorCodes

std::string MessageSvc::m_logColorCodes[MSG::NUM_LEVELS]
private

Definition at line 201 of file MessageSvc.h.

◆ m_logColors

std::array<Gaudi::Property<std::vector<std::string> >, MSG::NUM_LEVELS> MessageSvc::m_logColors
private
Initial value:
{ { { },
{ this, "verboseColorCode" },
{ this, "debugColorCode" },
{ this, "infoColorCode" },
{ this, "warningColorCode" },
{ this, "errorColorCode" },
{ this, "fatalColorCode" },
{ this, "alwaysColorCode" } } }

Definition at line 164 of file MessageSvc.h.

164 { { { /*ignored*/ },
165 { this, "verboseColorCode" },
166 { this, "debugColorCode" },
167 { this, "infoColorCode" },
168 { this, "warningColorCode" },
169 { this, "errorColorCode" },
170 { this, "fatalColorCode" },
171 { this, "alwaysColorCode" } } };

◆ m_loggedStreams

std::map<std::string, std::shared_ptr<std::ostream>, std::less<> > MessageSvc::m_loggedStreams
private

Definition at line 215 of file MessageSvc.h.

◆ m_loggedStreamsName

Gaudi::Property<std::map<std::string, std::string, std::less<> > > MessageSvc::m_loggedStreamsName
private
Initial value:
{
this, "loggedStreams", {}, "MessageStream sources we want to dump into a logfile" }

Definition at line 192 of file MessageSvc.h.

192 {
193 this, "loggedStreams", {}, "MessageStream sources we want to dump into a logfile" };

◆ m_messageMap

MessageMap MessageSvc::m_messageMap
private

Message map.

Definition at line 198 of file MessageSvc.h.

◆ m_messageMapMutex

std::recursive_mutex MessageSvc::m_messageMapMutex
mutableprivate

Mutex to synchronize multiple access to m_messageMap.

Definition at line 225 of file MessageSvc.h.

◆ m_msgCount

std::array<int, MSG::NUM_LEVELS> MessageSvc::m_msgCount
private

Definition at line 213 of file MessageSvc.h.

◆ m_msgLimit

std::array<Gaudi::Property<int>, MSG::NUM_LEVELS> MessageSvc::m_msgLimit
private
Initial value:
{ { { this, "defaultLimit", 500 },
{ this, "verboseLimit", 500 },
{ this, "debugLimit", 500 },
{ this, "infoLimit", 500 },
{ this, "warningLimit", 500 },
{ this, "errorLimit", 500 },
{ this, "fatalLimit", 500 },
{ this, "alwaysLimit", 0 } } }

Definition at line 173 of file MessageSvc.h.

173 { { { this, "defaultLimit", 500 },
174 { this, "verboseLimit", 500 },
175 { this, "debugLimit", 500 },
176 { this, "infoLimit", 500 },
177 { this, "warningLimit", 500 },
178 { this, "errorLimit", 500 },
179 { this, "fatalLimit", 500 },
180 { this, "alwaysLimit", 0 } } };

◆ m_reportMutex

std::recursive_mutex MessageSvc::m_reportMutex
mutableprivate

Mutex to synchronize multiple threads printing.

Definition at line 144 of file MessageSvc.h.

◆ m_sourceMap

std::map<std::string, MsgAry, std::less<> > MessageSvc::m_sourceMap
private

Definition at line 211 of file MessageSvc.h.

◆ m_statLevel

Gaudi::Property<unsigned int> MessageSvc::m_statLevel { this, "statLevel", 0, "" }
private

Definition at line 151 of file MessageSvc.h.

151{ this, "statLevel", 0, "" };

◆ m_stats

Gaudi::Property<bool> MessageSvc::m_stats { this, "showStats", false, "" }
private

Definition at line 150 of file MessageSvc.h.

150{ this, "showStats", false, "" };

◆ m_streamMap

StreamMap MessageSvc::m_streamMap
private

Stream map.

Definition at line 197 of file MessageSvc.h.

◆ m_suppress

bool MessageSvc::m_suppress { false }
protected

Definition at line 137 of file MessageSvc.h.

137{ false };

◆ m_suppressProp

Gaudi::Property<bool> MessageSvc::m_suppressProp
private
Initial value:
{ this, "enableSuppression", false,
[this]( auto& ) { i_onSuppressChanged( m_suppressProp.value() ); }, "" }
MessageSvc::m_suppressProp
Gaudi::Property< bool > m_suppressProp
Definition MessageSvc.h:182
MessageSvc::i_onSuppressChanged
virtual void i_onSuppressChanged(bool v)
Definition MessageSvc.h:139

Definition at line 182 of file MessageSvc.h.

182 { this, "enableSuppression", false,
183 [this]( auto& ) { i_onSuppressChanged( m_suppressProp.value() ); }, "" };

◆ m_thresholdMap

ThresholdMap MessageSvc::m_thresholdMap
private

Output level threshold map.

Definition at line 199 of file MessageSvc.h.

◆ m_thresholdMapMutex

std::recursive_mutex MessageSvc::m_thresholdMapMutex
mutableprivate

Mutex to synchronize multiple access to m_thresholdMap (.

See also
MsgStream::doOutput).

Definition at line 229 of file MessageSvc.h.

◆ m_thresholdProp

std::array<Gaudi::Property<std::vector<std::string> >, MSG::NUM_LEVELS> MessageSvc::m_thresholdProp
private
Initial value:
{ { { },
{ this, "setVerbose" },
{ this, "setDebug" },
{ this, "setInfo" },
{ this, "setWarning" },
{ this, "setError" },
{ this, "setFatal" },
{ this, "setAlways" } } }

Definition at line 153 of file MessageSvc.h.

153 { { { /*ignored*/ },
154 { this, "setVerbose" },
155 { this, "setDebug" },
156 { this, "setInfo" },
157 { this, "setWarning" },
158 { this, "setError" },
159 { this, "setFatal" },
160 { this, "setAlways" } } };

◆ m_tracedInactiveSources

Gaudi::Property<std::vector<std::string> > MessageSvc::m_tracedInactiveSources
private
Initial value:
{
this,
"tracedInactiveSources",
{},
"for each message source specified, print a stack trace for the unprotected and unseen messages" }

Definition at line 186 of file MessageSvc.h.

186 {
187 this,
188 "tracedInactiveSources",
189 {},
190 "for each message source specified, print a stack trace for the unprotected and unseen messages" };
The documentation for this class was generated from the following files: