MessageSvc Class Reference

#include <src/MessageSvc/MessageSvc.h>

Inheritance diagram for MessageSvc:

Collaboration diagram for MessageSvc:

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 >	ThresholdMap
Public Types inherited from extends< BASE, Interfaces >
typedef extends	base_class
	Typedef to this class. More...
typedef extend_interfaces< Interfaces...>	extend_interfaces_base
	Typedef to the base of this class. More...
typedef extends	base_class
	Typedef to this class. More...
typedef extend_interfaces< Interfaces...>	extend_interfaces_base
	Typedef to the base of this class. More...
Public Types inherited from extend_interfaces< Interfaces...>
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...

Public Member Functions
	MessageSvc (const std::string &name, ISvcLocator *svcloc)
	~MessageSvc () override=default
StatusCode	reinitialize () override
	Reinitialize Service. More...
StatusCode	initialize () override
	Initialize Service. More...
StatusCode	finalize () override
	Finalize Service. More...
void	reportMessage (const Message &message) override
void	reportMessage (const Message &msg, int outputLevel) override
void	reportMessage (const StatusCode &code, const std::string &source="") override
void	reportMessage (const char *source, int type, const char *message) override
void	reportMessage (const std::string &source, int type, const std::string &message) override
void	insertMessage (const StatusCode &code, const 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, const 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
void	setDefaultStream (std::ostream *stream) override
int	outputLevel () const override
int	outputLevel (const std::string &source) const override
void	setOutputLevel (int new_level) override
void	setOutputLevel (const std::string &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, const std::string &src) override
Public Member Functions inherited from extends< BASE, Interfaces >
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
Public Member Functions inherited from extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. More...
	~extend_interfaces () override=default
	Virtual destructor. More...

Private Types
typedef std::map< std::string, MSG::Color >	ColorMap

Private Member Functions
std::string	colTrans (std::string, int)
void	initColors (Property &prop)
void	setupColors (Property &prop)
void	setupLimits (Property &prop)
void	setupThreshold (Property &prop)
void	setupInactCount (Property &prop)
void	setupLogStreams ()
void	tee (const std::string &sourceName, const std::string &logFileName, const std::set< std::string > &declaredOutFileNames)

Private Attributes
std::ostream *	m_defaultStream
	Pointer to the output stream. More...
Message	m_defaultMessage
	Default Message. More...
StreamMap	m_streamMap
	Stream map. More...
MessageMap	m_messageMap
	Message map. More...
ThresholdMap	m_thresholdMap
	Output level threshold map. More...
std::string	m_defaultFormat
	Default format for the messages. More...
std::string	m_defaultTimeFormat
	Default format for timestamps in the messages. More...
StringArrayProperty	m_thresholdProp [MSG::NUM_LEVELS]
	Properties controlling. More...
BooleanProperty	m_color
BooleanProperty	m_stats
UnsignedIntegerProperty	m_statLevel
StringArrayProperty	m_logColors [MSG::NUM_LEVELS]
IntegerProperty	m_msgLimit [MSG::NUM_LEVELS]
std::string	m_logColorCodes [MSG::NUM_LEVELS]
std::map< std::string, MsgAry >	m_sourceMap
std::map< std::string, MsgAry >	m_inactiveMap
BooleanProperty	m_suppress
BooleanProperty	m_inactCount
ColorMap	m_colMap
std::array< int, MSG::NUM_LEVELS >	m_msgCount
std::map< std::string, std::string >	m_loggedStreamsName
std::map< std::string, std::shared_ptr< std::ostream > >	m_loggedStreams
std::recursive_mutex	m_reportMutex
	Mutex to synchronize multiple threads printing. More...
std::recursive_mutex	m_messageMapMutex
	Mutex to synchronize multiple access to m_messageMap. More...
std::recursive_mutex	m_thresholdMapMutex
	Mutex to synchronize multiple access to m_thresholdMap (. More...

Detailed Description

Definition at line 30 of file MessageSvc.h.

Member Typedef Documentation

typedef std::map<std::string, MSG::Color> MessageSvc::ColorMap

private

Definition at line 157 of file MessageSvc.h.

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

Definition at line 34 of file MessageSvc.h.

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

Definition at line 32 of file MessageSvc.h.

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

Definition at line 33 of file MessageSvc.h.

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

Definition at line 35 of file MessageSvc.h.

Constructor & Destructor Documentation

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

Definition at line 59 of file MessageSvc.cpp.

  : base_class( name, svcloc ) {
  m_defaultStream = &std::cout;
  declareProperty( "Format",      m_defaultFormat = Message::getDefaultFormat() );
  declareProperty( "timeFormat",  m_defaultTimeFormat = Message::getDefaultTimeFormat() );
  declareProperty( "showStats",   m_stats = false );
  declareProperty( "statLevel",   m_statLevel = 0 );

  // Special properties to control output level of individual sources
  declareProperty( "setVerbose",  m_thresholdProp[MSG::VERBOSE] );
  declareProperty( "setDebug",    m_thresholdProp[MSG::DEBUG] );
  declareProperty( "setInfo",     m_thresholdProp[MSG::INFO] );
  declareProperty( "setWarning",  m_thresholdProp[MSG::WARNING] );
  declareProperty( "setError",    m_thresholdProp[MSG::ERROR] );
  declareProperty( "setFatal",    m_thresholdProp[MSG::FATAL] );
  declareProperty( "setAlways",   m_thresholdProp[MSG::ALWAYS] );

  declareProperty( "useColors",        m_color=false)->declareUpdateHandler(&MessageSvc::initColors, this);

  declareProperty( "fatalColorCode",   m_logColors[MSG::FATAL] );
  declareProperty( "errorColorCode",   m_logColors[MSG::ERROR] );
  declareProperty( "warningColorCode", m_logColors[MSG::WARNING] );
  declareProperty( "infoColorCode",    m_logColors[MSG::INFO] );
  declareProperty( "debugColorCode",   m_logColors[MSG::DEBUG] );
  declareProperty( "verboseColorCode", m_logColors[MSG::VERBOSE] );
  declareProperty( "alwaysColorCode",  m_logColors[MSG::ALWAYS] );

  const int defaultLimit = 500;
  declareProperty( "fatalLimit",    m_msgLimit[MSG::FATAL]   = defaultLimit );
  declareProperty( "errorLimit",    m_msgLimit[MSG::ERROR]   = defaultLimit );
  declareProperty( "warningLimit",  m_msgLimit[MSG::WARNING] = defaultLimit );
  declareProperty( "infoLimit",     m_msgLimit[MSG::INFO]    = defaultLimit );
  declareProperty( "debugLimit",    m_msgLimit[MSG::DEBUG]   = defaultLimit );
  declareProperty( "verboseLimit",  m_msgLimit[MSG::VERBOSE] = defaultLimit );
  declareProperty( "alwaysLimit",   m_msgLimit[MSG::ALWAYS]  = 0 );

  declareProperty( "defaultLimit",  m_msgLimit[MSG::NIL]     = defaultLimit );

  declareProperty( "enableSuppression", m_suppress = false );
  declareProperty( "countInactive", m_inactCount = false )->declareUpdateHandler( &MessageSvc::setupInactCount, this );
#ifndef NDEBUG
  // initialize the MsgStream static flag.
  MsgStream::enableCountInactive(m_inactCount);
#endif

  declareProperty( "loggedStreams",
                   m_loggedStreamsName,
                   "MessageStream sources we want to dump into a logfile" );

  for (int ic=0; ic<MSG::NUM_LEVELS; ++ic) {
    m_logColors[ic].declareUpdateHandler(&MessageSvc::setupColors, this);
    m_msgLimit[ic].declareUpdateHandler(&MessageSvc::setupLimits, this);
    m_thresholdProp[ic].declareUpdateHandler(&MessageSvc::setupThreshold, this);
  }

  std::fill( std::begin(m_msgCount),std::end(m_msgCount), 0 );
}

MessageSvc::~MessageSvc ( )

overridedefault

Member Function Documentation

std::string MessageSvc::colTrans ( std::string  col, int  offset  )

private

Definition at line 436 of file MessageSvc.cpp.

                                                        {
  auto itr = m_colMap.find(col);
  int icol = offset + ( (itr != m_colMap.end()) ? itr->second : 8 );
  return std::to_string( icol );
}

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

inline

Definition at line 92 of file MessageSvc.h.

                                    {
    return m_defaultStream;
  }

void MessageSvc::eraseMessage ( )

override

Definition at line 653 of file MessageSvc.cpp.

{
  std::unique_lock<std::recursive_mutex> lock(m_messageMapMutex);
  m_messageMap.clear();
}

void MessageSvc::eraseMessage ( const StatusCode &  code )

override

Definition at line 666 of file MessageSvc.cpp.

{
  std::unique_lock<std::recursive_mutex> lock(m_messageMapMutex);
  m_messageMap.erase( key );
}

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

override

Definition at line 679 of file MessageSvc.cpp.

{
  std::unique_lock<std::recursive_mutex> lock(m_messageMapMutex);

  erase_if( m_messageMap, m_messageMap.equal_range(key),
            [&](MessageMap::const_reference j) { return j.second==msg; } ) ;
}

void MessageSvc::eraseStream ( )

override

Definition at line 587 of file MessageSvc.cpp.

{
  m_streamMap.clear();
}

void MessageSvc::eraseStream ( int  message_type )

override

Definition at line 599 of file MessageSvc.cpp.

{
  m_streamMap.erase( message_type );
}

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

override

Definition at line 611 of file MessageSvc.cpp.

                                                            {
  if ( stream ) {
    erase_if( m_streamMap, m_streamMap.equal_range(key),
              [&](StreamMap::const_reference j) 
              { return j.second.second == stream; } );
  }
}

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

override

Definition at line 626 of file MessageSvc.cpp.

                                                    {
  if ( stream ) {
    erase_if( m_streamMap, [&](StreamMap::const_reference j) 
              { return j.second.second == stream; } );
  }
}

StatusCode MessageSvc::finalize ( )

override

Finalize Service.

Definition at line 323 of file MessageSvc.cpp.

                                {

  m_suppress = false;

  {
    std::ostringstream os;

    if (m_stats) {
      os << "Summarizing all message counts" << endl;
    } else {
      os << "Listing sources of suppressed message: " << endl;
    }

    os << "=====================================================" << endl;
    os << " Message Source              |   Level |    Count" << endl;
    os << "-----------------------------+---------+-------------" << endl;


    bool found(false);

    for (auto itr=m_sourceMap.begin(); itr!=m_sourceMap.end(); ++itr) {
      for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
        if ( (itr->second.msg[ic] >= m_msgLimit[ic] && m_msgLimit[ic] != 0 ) ||
            (m_stats && itr->second.msg[ic] > 0 && ic >= m_statLevel.value()) ) {
          os << " ";
          os.width(28);
          os.setf(ios_base::left,ios_base::adjustfield);
          os << itr->first;
          os << "|";

          os.width(8);
          os.setf(ios_base::right,ios_base::adjustfield);
          os << levelNames[ic];
          os << " |";

          os.width(9);
          os << itr->second.msg[ic];
          os << endl;

          found = true;
        }
      }
    }
    os << "=====================================================" << endl;
    if (found || m_stats) cout << os.str();
  }

#ifndef NDEBUG
  if (m_inactCount.value()) {

    std::ostringstream os;
    os << "Listing sources of Unprotected and Unseen messages\n";

    bool found(false);

    unsigned int ml(0);
    for (const auto& itr : m_inactiveMap) {
      for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
        if (itr.second.msg[ic] != 0 && itr.first.length() > ml) {
          ml = itr.first.length(); 
        }
      }
    }

    for (unsigned int i=0; i<ml+25; ++i) os << "=";

    os << std::endl << " ";
    os.width(ml+2);
    os.setf(ios_base::left,ios_base::adjustfield);
    os << "Message Source";
    os.width(1);
    os << "|   Level |    Count" << endl;

    for (unsigned int i=0; i<ml+3; ++i) os << "-";
    os << "+---------+-----------" << endl;


    for (auto itr=m_inactiveMap.begin(); itr!=m_inactiveMap.end(); ++itr) {
      for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
    if (itr->second.msg[ic] != 0) {
      os << " ";
      os.width(ml+2);
      os.setf(ios_base::left,ios_base::adjustfield);
      os << itr->first;

      os << "|";

      os.width(8);
      os.setf(ios_base::right,ios_base::adjustfield);
      os << levelNames[ic];

      os << " |";

      os.width(9);
      os << itr->second.msg[ic];

      os << endl;

      found = true;
    }
      }
    }
    for (unsigned int i=0; i<ml+25; ++i) os << "=";
    os << endl;

    if (found) cout << os.str();
  }
#endif

  return StatusCode::SUCCESS;
}

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

override

Definition at line 716 of file MessageSvc.cpp.

                                                      {
// ---------------------------------------------------------------------------
  return (logLevel < MSG::NUM_LEVELS) ? m_logColorCodes[logLevel] : "" ;
}

void MessageSvc::incrInactiveCount ( MSG::Level  level, const std::string &  src  )

override

Definition at line 730 of file MessageSvc.cpp.

                                                                     {

  ++(m_inactiveMap[source].msg[level]);

}

void MessageSvc::initColors ( Property &  prop )

private

Definition at line 167 of file MessageSvc.cpp.

                                       {

  if (m_color) {
     static const std::array<std::pair<MSG::Level,std::vector<std::string>>,3> tbl{
                          { { MSG::FATAL, { { "[94;101;1m" } } },
                            { MSG::ERROR, { { "[97;101;1m" } } },
                            { MSG::WARNING, { { "[93;1m" } } } } };

     for (const auto& p : tbl ) {
        auto &lC = m_logColors[p.first];
        if (lC.value().empty()) {
            lC.set(p.second);
        } else {
            MessageSvc::setupColors( lC );
        }
    }

  } else {

    // reset all color codes;
    for (int ic=0; ic<MSG::NUM_LEVELS; ++ic) {
      m_logColors[ic].set( { } );
    }

  }

}

StatusCode MessageSvc::initialize ( )

override

Initialize Service.

Definition at line 121 of file MessageSvc.cpp.

                                  {
  StatusCode sc;
  sc = Service::initialize();
  if( sc.isFailure() ) return sc;
  // Release pointer to myself done in Service base class
  //if( m_msgsvc.isValid() ) {
  //  m_msgsvc = 0;
  //}
  // Set my own properties
  sc = setProperties();
  if (sc.isFailure()) return sc;

#ifdef _WIN32
  m_color = false;
#endif

  //NOTE: m_colMap is used _before_ it is filled here,
  //      i.e. while it is still empty.
  //      Moving this initialization 'up' by eg. just 
  //      having a 'static const' colMap does not leave
  //      the results invariant...
  m_colMap["black"]  = MSG::BLACK;
  m_colMap["red"]    = MSG::RED;
  m_colMap["green"]  = MSG::GREEN;
  m_colMap["yellow"] = MSG::YELLOW;
  m_colMap["blue"]   = MSG::BLUE;
  m_colMap["purple"] = MSG::PURPLE;
  m_colMap["cyan"]   = MSG::CYAN;
  m_colMap["white"]  = MSG::WHITE;

  // make sure the map of logged stream names is initialized
  setupLogStreams();

  return StatusCode::SUCCESS;
}

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

override

Definition at line 640 of file MessageSvc.cpp.

{
  std::unique_lock<std::recursive_mutex> lock(m_messageMapMutex);
  m_messageMap.emplace( key, msg );
}

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

override

Definition at line 573 of file MessageSvc.cpp.

{
  m_streamMap.emplace( key, NamedStream(name,stream) );
}

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

override

Definition at line 722 of file MessageSvc.cpp.

                                                    {

  return m_msgCount[level];

}

int MessageSvc::outputLevel ( ) const

override

Definition at line 688 of file MessageSvc.cpp.

                                    {
// ---------------------------------------------------------------------------
  return m_outputLevel;
}

int MessageSvc::outputLevel ( const std::string &  source ) const

override

Definition at line 694 of file MessageSvc.cpp.

                                                             {
// ---------------------------------------------------------------------------
  std::unique_lock<std::recursive_mutex> lock(m_thresholdMapMutex);
  auto it = m_thresholdMap.find( source );
  return ( it != m_thresholdMap.end() ) ?  it->second : m_outputLevel.value();
}

StatusCode MessageSvc::reinitialize ( )

override

Reinitialize Service.

Definition at line 160 of file MessageSvc.cpp.

                                    {
  m_state = Gaudi::StateMachine::OFFLINE;
  return initialize();
}

void MessageSvc::reportMessage ( const Message &  message )

override

Definition at line 510 of file MessageSvc.cpp.

                                                      {
  reportMessage(msg, outputLevel(msg.getSource()));
}

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

override

Definition at line 449 of file MessageSvc.cpp.

                                                                       {
  std::unique_lock<std::recursive_mutex> lock(m_reportMutex);

  int key = msg.getType();

  ++m_msgCount[key];

  const Message *cmsg = &msg;

  // processing logged streams
  if ( !m_loggedStreams.empty() ) {
    auto iLog = m_loggedStreams.find( msg.getSource() );
    if ( m_loggedStreams.end() != iLog ) {
      (*iLog->second) << *cmsg << std::endl;
    }
  }

  if ( m_suppress.value() || m_stats.value() ) {

    // Increase the counter of 'key' type of messages for the source and
    // get the new value.
    const int nmsg = ++(m_sourceMap[msg.getSource()].msg[key]);

    if (m_suppress.value() && m_msgLimit[key] != 0 ) {
      if (nmsg > m_msgLimit[key]) return;
      if (nmsg == m_msgLimit[key]) {
        std::string txt = levelNames[key] + " message limit ("
            + std::to_string( m_msgLimit[key].value() )
            + ") reached for " + msg.getSource() + ". Suppressing further output.";
        cmsg = new Message(msg.getSource(), MSG::WARNING, std::move(txt));
        cmsg->setFormat(msg.getFormat());
      }
    }
  }

  auto range = m_streamMap.equal_range( key );
  if ( range.first != m_streamMap.end() ) {
    std::for_each( range.first,range.second, [&](StreamMap::const_reference sm) {
      *sm.second.second << *cmsg << std::endl;
    });
  } else if ( key >= outputLevel )   {
    msg.setFormat(m_defaultFormat);
    msg.setTimeFormat(m_defaultTimeFormat);
    if (!m_color) {
      (*m_defaultStream) << *cmsg << std::endl << std::flush;
    } else {
      (*m_defaultStream) <<  m_logColorCodes[key] << *cmsg << "\033[m"
                         << std::endl << std::flush;
    }
  }

  if (cmsg != &msg) { delete cmsg; }

}

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

override

Definition at line 545 of file MessageSvc.cpp.

{
  std::unique_lock<std::recursive_mutex> lock(m_messageMapMutex);

  auto report = [&](Message mesg) {
    mesg.setSource( source );
    Message stat_code( source,  mesg.getType(), "Status Code " + std::to_string( key.getCode() ) );
    reportMessage( std::move(stat_code) );
    reportMessage( std::move(mesg) );
  };

  auto range = m_messageMap.equal_range( key );
  if ( range.first != m_messageMap.end() ) {
    std::for_each( range.first, range.second, 
                   [&](MessageMap::const_reference sm) { report(sm.second); } );
  } else {
    report(m_defaultMessage);
  }
}

void MessageSvc::reportMessage ( const char *  source, int  type, const char *  message  )

override

Definition at line 520 of file MessageSvc.cpp.

                                                     {
  reportMessage( Message{ source, type, message } );
}

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

override

Definition at line 532 of file MessageSvc.cpp.

                                                          {
  reportMessage( Message{source, type, message} );
}

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

inlineoverride

Definition at line 97 of file MessageSvc.h.

                                                       {
    std::unique_lock<std::recursive_mutex> lock(m_reportMutex);
    m_defaultStream = stream;
  }

void MessageSvc::setOutputLevel ( int  new_level )

override

Definition at line 702 of file MessageSvc.cpp.

                                                {
// ---------------------------------------------------------------------------
  m_outputLevel = new_level;
}

void MessageSvc::setOutputLevel ( const std::string &  source, int  new_level  )

override

Definition at line 708 of file MessageSvc.cpp.

                                                                     {
// ---------------------------------------------------------------------------
  std::unique_lock<std::recursive_mutex> lock(m_thresholdMapMutex);

  m_thresholdMap[source] = level;
}

void MessageSvc::setupColors ( Property &  prop )

private

Definition at line 197 of file MessageSvc.cpp.

                                           {

  if (! m_color) return;

  static const std::array<std::pair<const char*,MSG::Level>,7> tbl { 
      { {"fatalColorCode",   MSG::FATAL   },
        {"errorColorCode",   MSG::ERROR   },
        {"warningColorCode", MSG::WARNING },
        {"infoColorCode",    MSG::INFO    },
        {"debugColorCode",   MSG::DEBUG   },
        {"verboseColorCode", MSG::VERBOSE },
        {"alwaysColorCode",  MSG::ALWAYS  } } };

  auto i = std::find_if( std::begin(tbl),std::end(tbl),
                         [&](const std::pair<const char*,MSG::Level>& t) {
                                return prop.name() == t.first;
  } );
  if (i==std::end(tbl)) {
    cout << "ERROR: Unknown message color parameter: " << prop.name()
         << endl;
    return;
  }
  int ic = i->second;

  string code;
  auto itr = m_logColors[ic].value().begin();

  if ( m_logColors[ic].value().size() == 1 ) {

    if (itr->empty()) {
      code = "";
    } else if (itr->compare(0,1,"[") == 0) {
      code = "\033" + *itr;
    } else {
      code = "\033[" + colTrans(*itr, 90) + ";1m";
    }

  } else if (m_logColors[ic].value().size() == 2) {
    auto itr2 = itr + 1;

    code =  "\033[" + colTrans(*itr, 90) + ";"
      + colTrans(*itr2, 100) + ";1m";

  }

  m_logColorCodes[ic] = code;

}

void MessageSvc::setupInactCount ( Property &  prop )

private

Definition at line 311 of file MessageSvc.cpp.

                                              {
  if (prop.name() == "countInactive") {
    BooleanProperty *p = dynamic_cast<BooleanProperty*>(&prop);
    if (p)
      MsgStream::enableCountInactive(p->value());
  }
}

void MessageSvc::setupLimits ( Property &  prop )

private

Definition at line 247 of file MessageSvc.cpp.

                                           {
  // Just report problems in the settings of the limits and unknown limit parameters
  if (prop.name() == "alwaysLimit") {
    IntegerProperty *p = dynamic_cast<IntegerProperty*>(&prop);
    if (p && p->value() != 0) {
      cout << "MessageSvc ERROR: cannot suppress ALWAYS messages" << endl;
      p->setValue(0);
    }
  } else if (prop.name() == "defaultLimit") {
    for (int i = MSG::VERBOSE; i< MSG::NUM_LEVELS; ++i) {
      if (i != MSG::ALWAYS) {
        m_msgLimit[i] = m_msgLimit[MSG::NIL].value();
      }
    }
  } else if (prop.name() != "fatalLimit" &&
             prop.name() != "errorLimit" &&
             prop.name() != "warningLimit" &&
             prop.name() == "infoLimit" &&
             prop.name() == "debugLimit" &&
             prop.name() == "verboseLimit") {
    cout << "MessageSvc ERROR: Unknown message limit parameter: "
         << prop.name() << endl;
    return;
  }
}

void MessageSvc::setupLogStreams ( )

private

Definition at line 737 of file MessageSvc.cpp.

{
  // reset state
  m_loggedStreams.clear();

  for ( auto& iProp : m_loggedStreamsName ) {

    std::set<std::string> outFileNames;
    for ( auto& jProp : m_loggedStreamsName ) {
      if ( jProp.first != iProp.first ) {
        outFileNames.insert( jProp.second );
      }
    }
    tee( iProp.first, iProp.second, outFileNames );

  }//> loop over property entries
}

void MessageSvc::setupThreshold ( Property &  prop )

private

Definition at line 274 of file MessageSvc.cpp.

                                              {

  static const std::array<std::pair<const char*,MSG::Level>,7> tbl{ 
      { { "setFatal",   MSG::FATAL   },
        { "setError",   MSG::ERROR   },
        { "setWarning", MSG::WARNING },
        { "setInfo",    MSG::INFO    },
        { "setDebug",   MSG::DEBUG   },
        { "setVerbose", MSG::VERBOSE },
        { "setAlways",  MSG::ALWAYS  } } };

  auto i = std::find_if( std::begin(tbl),std::end(tbl),
                         [&](const std::pair<const char*,MSG::Level>& t) {
                                return prop.name() == t.first;
  } );
  if (i==std::end(tbl)) {
    cerr << "MessageSvc ERROR: Unknown message threshold parameter: "
         << prop.name() << endl;
    return;
  }
  int ic = i->second;

  StringArrayProperty *sap = dynamic_cast<StringArrayProperty*>( &prop);
  if (!sap) {
    std::cerr << "could not dcast " << prop.name()
              << " to a StringArrayProperty (which it should be!)" << endl;
  } else {
    for ( auto& i : sap->value() ) setOutputLevel( i, ic );
  }

}

void MessageSvc::tee ( const std::string &  sourceName, const std::string &  logFileName, const std::set< std::string > &  declaredOutFileNames  )

private

Definition at line 756 of file MessageSvc.cpp.

{
  const std::ios_base::openmode openMode = std::ios_base::out |
                                           std::ios_base::trunc;

  auto iStream = m_loggedStreams.find( sourceName );
  if ( iStream != std::end(m_loggedStreams) ) {
    m_loggedStreams.erase( iStream );
  }

  // before creating a new ofstream, make sure there is no already existing
  // one with the same file name...
  for (auto&  iStream : m_loggedStreams ) {
    if ( outFileNames.find( outFileName ) != outFileNames.end() ) {
      m_loggedStreams[sourceName] = m_loggedStreams[iStream.first];
      return;
    }
  }

  auto out = std::make_shared<std::ofstream>( outFileName, openMode );
  if ( out->good() ) m_loggedStreams[sourceName] = std::move(out);

}

bool MessageSvc::useColor ( ) const

inlineoverride

Definition at line 115 of file MessageSvc.h.

{ return m_color; }

Member Data Documentation

ColorMap MessageSvc::m_colMap

private

Definition at line 158 of file MessageSvc.h.

BooleanProperty MessageSvc::m_color

private

Definition at line 137 of file MessageSvc.h.

std::string MessageSvc::m_defaultFormat

private

Default format for the messages.

Definition at line 134 of file MessageSvc.h.

Message MessageSvc::m_defaultMessage

private

Default Message.

Definition at line 130 of file MessageSvc.h.

std::ostream* MessageSvc::m_defaultStream

private

Pointer to the output stream.

Definition at line 129 of file MessageSvc.h.

std::string MessageSvc::m_defaultTimeFormat

private

Default format for timestamps in the messages.

Definition at line 135 of file MessageSvc.h.

BooleanProperty MessageSvc::m_inactCount

private

Definition at line 154 of file MessageSvc.h.

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

private

Definition at line 153 of file MessageSvc.h.

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

private

Definition at line 143 of file MessageSvc.h.

StringArrayProperty MessageSvc::m_logColors[MSG::NUM_LEVELS]

private

Definition at line 140 of file MessageSvc.h.

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

private

Definition at line 163 of file MessageSvc.h.

std::map<std::string, std::string> MessageSvc::m_loggedStreamsName

private

Definition at line 162 of file MessageSvc.h.

MessageMap MessageSvc::m_messageMap

private

Message map.

Definition at line 132 of file MessageSvc.h.

std::recursive_mutex MessageSvc::m_messageMapMutex

mutableprivate

Mutex to synchronize multiple access to m_messageMap.

Definition at line 180 of file MessageSvc.h.

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

private

Definition at line 160 of file MessageSvc.h.

IntegerProperty MessageSvc::m_msgLimit[MSG::NUM_LEVELS]

private

Definition at line 141 of file MessageSvc.h.

std::recursive_mutex MessageSvc::m_reportMutex

mutableprivate

Mutex to synchronize multiple threads printing.

Definition at line 177 of file MessageSvc.h.

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

private

Definition at line 153 of file MessageSvc.h.

UnsignedIntegerProperty MessageSvc::m_statLevel

private

Definition at line 139 of file MessageSvc.h.

BooleanProperty MessageSvc::m_stats

private

Definition at line 138 of file MessageSvc.h.

StreamMap MessageSvc::m_streamMap

private

Stream map.

Definition at line 131 of file MessageSvc.h.

BooleanProperty MessageSvc::m_suppress

private

Definition at line 154 of file MessageSvc.h.

ThresholdMap MessageSvc::m_thresholdMap

private

Output level threshold map.

Definition at line 133 of file MessageSvc.h.

std::recursive_mutex MessageSvc::m_thresholdMapMutex

mutableprivate

Mutex to synchronize multiple access to m_thresholdMap (.

See also

MsgStream::doOutput).

Definition at line 184 of file MessageSvc.h.

StringArrayProperty MessageSvc::m_thresholdProp[MSG::NUM_LEVELS]

private

Properties controlling.

Definition at line 136 of file MessageSvc.h.

---

The documentation for this class was generated from the following files:

• GaudiCoreSvc/src/MessageSvc/MessageSvc.h
• GaudiCoreSvc/src/MessageSvc/MessageSvc.cpp