Message Class Reference

The Message class. More...

#include <GaudiKernel/Message.h>

Collaboration diagram for Message:

Public Member Functions
	Message ()=default
	Default constructor.
	Message (const char *src, int type, const char *msg)
	Constructor.
	Message (std::string src, int type, std::string msg)
	Constructor.
	~Message ()=default
	Default destructor.
const std::string &	getMessage () const
	Get the message string.
void	setMessage (std::string msg)
	Set the message string.
int	getType () const
	Get the message type.
void	setType (int msg_type)
	Set the message type.
const std::string &	getSource () const
	Get the message source.
void	setSource (std::string_view src)
	Set the message source.

Private Attributes
Event identifiers
EventContext::ContextID_t	m_ecSlot { EventContext::INVALID_CONTEXT_ID }
	Event slot.
EventContext::ContextEvt_t	m_ecEvt { EventContext::INVALID_CONTEXT_EVT }
	Event number.
EventIDBase	m_ecEvtId
	Full event ID.
pthread_t	m_ecThrd {}
	Thread ID.

Static Private Attributes
Formatting characters
static const char	FORMAT_PREFIX = '%'
	The character used to prefix formatting commands.
static const char	JUSTIFY_LEFT = 'L'
	The character used to indicate start of left text justification.
static const char	JUSTIFY_RIGHT = 'R'
	The character used to indicate start of right text justification.
static const char	MESSAGE = 'M'
	The character used to indicate that the message should be printed.
static const char	TYPE = 'T'
	The character used to indicate that the message type should be printed.
static const char	TIME = 't'
	The character used to indicate that the message timestamp should be printed.
static const char	UTIME = 'u'
	The character used to indicate that the message timestamp should be printed in UTC time.
static const char	SOURCE = 'S'
	The character used to indicate that the message source should be printed.
static const char	COMP = 'C'
	The character used to indicate that the message source should be printed, focus on the component.
static const char	SLOT = 's'
	The character used to indicate that the slot number should be printed.
static const char	EVTNUM = 'e'
	The character used to indicate that the event number should be printed.
static const char	THREAD = 'X'
	The character used to indicate that the thread ID should be printed.
static const char	EVENTID = 'E'
	The character used to indicate that the full event ID should be printed.
static const char	FILL = 'F'
	The character used to indicate that the previous character is used to pad fields if the text is not long enough.
static const char	WIDTH = 'W'
	The character used to indicate that the previous decimal characters should be taken as the field width.
static constexpr const char *	DEFAULT_FORMAT = "% F%18W%S%7W%R%T %0W%M"
	The default message format.
static constexpr const char *	DEFAULT_TIME_FORMAT = "%Y-%m-%d %H:%M:%S,%f"
	The default time format (accepts strftime formatters plus %f for milliseconds).

Event identifiers of message
std::string	m_message
	The message text.
std::string	m_source { "UNKNOWN" }
	The message source.
int	m_type { 0 }
	The message type/level.
std::string	m_format { DEFAULT_FORMAT }
	The format string.
std::string	m_time_format { DEFAULT_TIME_FORMAT }
	Time format string.
std::string	m_formatted_msg
	Formatted message.
char	m_fill { ' ' }
	Current fill character.
int	m_width { 0 }
	Current field width.
bool	m_left { true }
	The message alignment.
EventContext::ContextID_t	getEventSlot () const
EventContext::ContextEvt_t	getEventNumber () const
const EventIDBase &	getEventID () const
const std::string &	getFormat () const
	Get the format string.
void	setFormat (std::string msg) const
	Set the format string.
const std::string &	getTimeFormat () const
	Get the time format string.
void	setTimeFormat (std::string timeFormat) const
	Set the time format string.
static const std::string	getDefaultFormat ()
	Get the default format string.
static const std::string	getDefaultTimeFormat ()
	Get the default time format string.
bool	operator< (const Message &lhs, const Message &rhs)
	Needed to build maps.
std::ostream &	operator<< (std::ostream &stream, const Message &msg)
	Insert the message into a stream.
bool	operator== (const Message &a, const Message &b)
	Insert the message into a stream.
void	invalidFormat () const
	Called when an invalid format string is encountered.
void	makeFormattedMsg (const std::string &format) const
	Format the message.
void	decodeFormat (const std::string &format) const
	Decode format.
void	sizeField (const std::string &text, bool middle=false) const
	Truncate or pad the output string to the field width. If middle is true, cut the central part, otherwise the end.
void	setWidth (const std::string &formatArg) const
	Set the width of a stream.

Detailed Description

The Message class.

This class is used to contain messages which can then be formatted and sent to a message service

Author

Iain Last

Definition at line 25 of file Message.h.

Constructor & Destructor Documentation

Message() [1/3]

Message::Message ( )

default

Default constructor.

Message() [2/3]

Message::Message	(	const char *	src,
		int	type,
		const char *	msg )

Constructor.

Definition at line 39 of file Message.cpp.

    : Message( std::string( src ), type, std::string( msg ) ) {}

Message() [3/3]

Message::Message	(	std::string	src,
		int	type,
		std::string	msg )

Constructor.

Definition at line 48 of file Message.cpp.

    : m_message( std::move( msg ) ), m_source( std::move( src ) ), m_type( type ) {
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  m_ecSlot                = ctx.slot();
  m_ecEvt                 = ctx.evt();
  m_ecEvtId               = ctx.eventID();
  m_ecThrd                = pthread_self();
}

~Message()

Message::~Message ( )

default

Default destructor.

Member Function Documentation

decodeFormat()

void Message::decodeFormat ( const std::string & format ) const

private

Decode format.

Definition at line 159 of file Message.cpp.

                                                          {
  if ( !format.empty() ) {
    const char        FORMAT_TYPE  = format[format.length() - 1];
    const std::string FORMAT_PARAM = format.substr( 0, format.length() - 1 );
 
    // Now test the format.
    std::string level;
    switch ( FORMAT_TYPE ) {
    case FILL:
      if ( FORMAT_PARAM.length() == 1 ) {
        m_fill = FORMAT_PARAM[0];
      } else
        invalidFormat();
      break;
 
    case TIME: {
      sizeField( formattedTime( m_time_format ) );
    } break;
 
    case UTIME: {
      sizeField( formattedTime( m_time_format, true ) );
    } break;
 
    case THREAD: {
      std::ostringstream ost;
      //    ost << "0x" << std::hex << pthread_self();
      ost << "0x" << std::hex << m_ecThrd;
      const std::string& thrStr( ost.str() );
      sizeField( thrStr );
    } break;
 
    case SLOT: {
      std::ostringstream ost;
      if ( m_ecSlot != EventContext::INVALID_CONTEXT_ID ) { ost << m_ecSlot; }
      sizeField( ost.str() );
    } break;
 
    case EVTNUM: {
      std::ostringstream ost;
      if ( m_ecEvt != EventContext::INVALID_CONTEXT_EVT ) { ost << m_ecEvt; }
      sizeField( ost.str() );
    } break;
 
    case EVENTID: {
      std::ostringstream ost;
      if ( m_ecEvtId.isValid() ) { ost << m_ecEvtId; }
      sizeField( ost.str() );
    } break;
 
    case MESSAGE:
      sizeField( m_message );
      break;
 
    case SOURCE:
      sizeField( m_source );
      break;
 
    case COMP:
      sizeField( m_source, true );
      break;
 
    case TYPE:
      switch ( m_type ) {
#define SET( x )                                                                                                       \
  case x:                                                                                                              \
    level = #x;                                                                                                        \
    break
        SET( NIL );
        SET( VERBOSE );
        SET( DEBUG );
        SET( INFO );
        SET( WARNING );
        SET( ERROR );
        SET( FATAL );
      case ALWAYS:
        level = "SUCCESS";
        break;
      default:
        level = "UNKNOWN";
        break;
#undef SET
      }
      sizeField( level );
      break;
 
    case FORMAT_PREFIX:
      m_formatted_msg += FORMAT_PREFIX;
      break;
    case JUSTIFY_RIGHT:
      m_left = false;
      break;
    case JUSTIFY_LEFT:
      m_left = true;
      break;
    case WIDTH:
      setWidth( FORMAT_PARAM );
      break;
    default:
      invalidFormat();
      break;
    }
  } else
    invalidFormat();
}

getDefaultFormat()

static const std::string Message::getDefaultFormat ( )

inlinestatic

Get the default format string.

Definition at line 68 of file Message.h.

{ return DEFAULT_FORMAT; }

getDefaultTimeFormat()

static const std::string Message::getDefaultTimeFormat ( )

inlinestatic

Get the default time format string.

Definition at line 77 of file Message.h.

{ return DEFAULT_TIME_FORMAT; }

getEventID()

const EventIDBase & Message::getEventID ( ) const

inline

Definition at line 61 of file Message.h.

{ return m_ecEvtId; }

getEventNumber()

EventContext::ContextEvt_t Message::getEventNumber ( ) const

inline

Definition at line 60 of file Message.h.

{ return m_ecEvt; }

getEventSlot()

EventContext::ContextID_t Message::getEventSlot ( ) const

inline

Definition at line 59 of file Message.h.

{ return m_ecSlot; }

getFormat()

const std::string & Message::getFormat ( ) const

inline

Get the format string.

Definition at line 65 of file Message.h.

{ return m_format; }

getMessage()

const std::string & Message::getMessage ( ) const

inline

Get the message string.

Definition at line 40 of file Message.h.

{ return m_message; }

getSource()

const std::string & Message::getSource ( ) const

inline

Get the message source.

Definition at line 52 of file Message.h.

{ return m_source; }

getTimeFormat()

const std::string & Message::getTimeFormat ( ) const

inline

Get the time format string.

Definition at line 74 of file Message.h.

{ return m_time_format; }

getType()

int Message::getType ( ) const

inline

Get the message type.

Definition at line 46 of file Message.h.

{ return m_type; }

invalidFormat()

void Message::invalidFormat ( ) const

private

Called when an invalid format string is encountered.

Definition at line 271 of file Message.cpp.

{ makeFormattedMsg( DEFAULT_FORMAT ); }

makeFormattedMsg()

void Message::makeFormattedMsg ( const std::string & format ) const

private

Format the message.

Definition at line 122 of file Message.cpp.

                                                              {
  m_formatted_msg.clear();
  auto i = format.begin();
  while ( i != format.end() ) {
 
    // Output format string until format statement found.
    while ( i != format.end() && *i != FORMAT_PREFIX ) m_formatted_msg += *i++;
 
    // Test for end of format string.
    if ( i == format.end() ) break;
    i++;
 
    // Find type of formatting.
    std::string this_format;
    while ( i != format.end() && *i != FORMAT_PREFIX && *i != MESSAGE && *i != TYPE && *i != SOURCE && *i != COMP &&
            *i != FILL && *i != WIDTH && *i != TIME && *i != UTIME && *i != SLOT && *i != EVTNUM && *i != THREAD &&
            *i != EVENTID && *i != JUSTIFY_LEFT && *i != JUSTIFY_RIGHT ) {
      this_format += *i++;
    }
 
    // Reached end of string with improper format.
    if ( i == format.end() ) {
      invalidFormat();
      break;
    }
 
    this_format += *i++;
    decodeFormat( this_format );
  }
}

setFormat()

void Message::setFormat

(

std::string

msg

)

const

Set the format string.

Definition at line 97 of file Message.cpp.

                                                {
  if ( !format.empty() ) {
    m_format = std::move( format );
  } else {
    m_format = DEFAULT_FORMAT;
  }
}

setMessage()

void Message::setMessage ( std::string msg )

inline

Set the message string.

Definition at line 43 of file Message.h.

{ m_message = std::move( msg ); }

setSource()

void Message::setSource ( std::string_view src )

inline

Set the message source.

Definition at line 55 of file Message.h.

{ m_source = src; }

setTimeFormat()

void Message::setTimeFormat

(

std::string

timeFormat

)

const

Set the time format string.

Definition at line 112 of file Message.cpp.

                                                        {
  m_time_format = ( timeFormat.empty() ? DEFAULT_TIME_FORMAT : std::move( timeFormat ) );
}

setType()

void Message::setType ( int msg_type )

inline

Set the message type.

Definition at line 49 of file Message.h.

{ m_type = msg_type; }

setWidth()

void Message::setWidth ( const std::string & formatArg ) const

private

Set the width of a stream.

Definition at line 290 of file Message.cpp.

                                                         {
  // Convert string to int, if string contains digits only...
  if ( all_digits( formatArg ) )
    m_width = std::stoi( formatArg );
  else
    invalidFormat();
}

sizeField()

void Message::sizeField ( const std::string & text, bool middle = false ) const

private

Truncate or pad the output string to the field width. If middle is true, cut the central part, otherwise the end.

Definition at line 305 of file Message.cpp.

                                                                  {
  std::string newText;
  if ( m_width == 0 || m_width == static_cast<int>( text.length() ) ) {
    newText = text;
  } else {
    const size_t width = static_cast<size_t>( m_width );
    // Truncate the text if it is too long.
    if ( width < text.length() ) {
      if ( middle && width > 4 ) { // truncate text in the middle
        size_t iTrunc;
        // If the text is a component-name-chain, try showing the last component
        const size_t iDot = text.rfind( '.' );
        if ( iDot != std::string::npos && width > text.length() - iDot + 3 ) {
          iTrunc = iDot + 1;
        } else {
          // No dot or text after dot too long
          iTrunc = text.length() - width / 2;
        }
        const size_t taillength  = text.length() - iTrunc;
        const size_t frontlength = width - taillength - 3;
        newText.reserve( width );
        newText.append( text, 0, frontlength );
        newText.append( 3, '.' );
        newText.append( text, iTrunc );
      }      // else if middle
      else { // truncate text at the end
        newText = text.substr( 0, m_width );
        for ( int i = 0, j = newText.length() - 1; i < 3 && j >= 0; ++i, --j ) newText[j] = '.';
      }
    }
    // Pad the text.
    else {
      newText = std::string( m_width, m_fill );
      if ( m_left )
        newText.replace( newText.begin(), newText.begin() + text.length(), text.begin(), text.end() );
      else
        newText.replace( newText.end() - text.length(), newText.end(), text.begin(), text.end() );
    }
  }
 
  m_formatted_msg += newText;
}

Friends And Related Symbol Documentation

operator<

bool operator< ( const Message & lhs, const Message & rhs )

friend

Needed to build maps.

Definition at line 76 of file Message.cpp.

                                                         {
  return lhs.m_type < rhs.m_type || lhs.m_source < rhs.m_source || lhs.m_message < rhs.m_message;
}

operator<<

std::ostream & operator<< ( std::ostream & stream, const Message & msg )

friend

Insert the message into a stream.

Definition at line 64 of file Message.cpp.

                                                                 {
  msg.makeFormattedMsg( msg.m_format );
  stream << msg.m_formatted_msg;
  return stream;
}

operator==

bool operator== ( const Message & a, const Message & b )

friend

Insert the message into a stream.

Definition at line 86 of file Message.cpp.

                                                      {
  return a.m_source == b.m_source && a.m_type == b.m_type && a.m_message == b.m_message;
}

Member Data Documentation

COMP

const char Message::COMP = 'C'

staticprivate

The character used to indicate that the message source should be printed, focus on the component.

Definition at line 152 of file Message.h.

DEFAULT_FORMAT

const char* Message::DEFAULT_FORMAT = "% F%18W%S%7W%R%T %0W%M"

staticconstexprprivate

The default message format.

Definition at line 174 of file Message.h.

DEFAULT_TIME_FORMAT

const char* Message::DEFAULT_TIME_FORMAT = "%Y-%m-%d %H:%M:%S,%f"

staticconstexprprivate

The default time format (accepts strftime formatters plus %f for milliseconds).

Definition at line 177 of file Message.h.

EVENTID

const char Message::EVENTID = 'E'

staticprivate

The character used to indicate that the full event ID should be printed.

Definition at line 164 of file Message.h.

EVTNUM

const char Message::EVTNUM = 'e'

staticprivate

The character used to indicate that the event number should be printed.

Definition at line 158 of file Message.h.

FILL

const char Message::FILL = 'F'

staticprivate

The character used to indicate that the previous character is used to pad fields if the text is not long enough.

Definition at line 167 of file Message.h.

FORMAT_PREFIX

const char Message::FORMAT_PREFIX = '%'

staticprivate

The character used to prefix formatting commands.

Definition at line 128 of file Message.h.

JUSTIFY_LEFT

const char Message::JUSTIFY_LEFT = 'L'

staticprivate

The character used to indicate start of left text justification.

Definition at line 131 of file Message.h.

JUSTIFY_RIGHT

const char Message::JUSTIFY_RIGHT = 'R'

staticprivate

The character used to indicate start of right text justification.

Definition at line 134 of file Message.h.

m_ecEvt

EventContext::ContextEvt_t Message::m_ecEvt { EventContext::INVALID_CONTEXT_EVT }

private

Event number.

Definition at line 120 of file Message.h.

{ EventContext::INVALID_CONTEXT_EVT }; 

m_ecEvtId

EventIDBase Message::m_ecEvtId

private

Full event ID.

Definition at line 121 of file Message.h.

m_ecSlot

EventContext::ContextID_t Message::m_ecSlot { EventContext::INVALID_CONTEXT_ID }

private

Event slot.

Definition at line 119 of file Message.h.

{ EventContext::INVALID_CONTEXT_ID }; 

m_ecThrd

pthread_t Message::m_ecThrd {}

private

Thread ID.

Definition at line 122 of file Message.h.

{};                                   

m_fill

char Message::m_fill { ' ' }

mutableprivate

Current fill character.

Definition at line 113 of file Message.h.

{ ' ' };                        

m_format

std::string Message::m_format { DEFAULT_FORMAT }

mutableprivate

The format string.

Definition at line 110 of file Message.h.

{ DEFAULT_FORMAT };           

m_formatted_msg

std::string Message::m_formatted_msg

mutableprivate

Formatted message.

Definition at line 112 of file Message.h.

m_left

bool Message::m_left { true }

mutableprivate

The message alignment.

Definition at line 115 of file Message.h.

{ true };                       

m_message

std::string Message::m_message

private

The message text.

Definition at line 107 of file Message.h.

m_source

std::string Message::m_source { "UNKNOWN" }

private

The message source.

Definition at line 108 of file Message.h.

{ "UNKNOWN" };                

m_time_format

std::string Message::m_time_format { DEFAULT_TIME_FORMAT }

mutableprivate

Time format string.

Definition at line 111 of file Message.h.

{ DEFAULT_TIME_FORMAT }; 

m_type

int Message::m_type { 0 }

private

The message type/level.

Definition at line 109 of file Message.h.

{ 0 };                          

m_width

int Message::m_width { 0 }

mutableprivate

Current field width.

Definition at line 114 of file Message.h.

{ 0 };                         

MESSAGE

const char Message::MESSAGE = 'M'

staticprivate

The character used to indicate that the message should be printed.

Definition at line 137 of file Message.h.

SLOT

const char Message::SLOT = 's'

staticprivate

The character used to indicate that the slot number should be printed.

Definition at line 155 of file Message.h.

SOURCE

const char Message::SOURCE = 'S'

staticprivate

The character used to indicate that the message source should be printed.

Definition at line 149 of file Message.h.

THREAD

const char Message::THREAD = 'X'

staticprivate

The character used to indicate that the thread ID should be printed.

Definition at line 161 of file Message.h.

TIME

const char Message::TIME = 't'

staticprivate

The character used to indicate that the message timestamp should be printed.

Definition at line 143 of file Message.h.

TYPE

const char Message::TYPE = 'T'

staticprivate

The character used to indicate that the message type should be printed.

Definition at line 140 of file Message.h.

UTIME

const char Message::UTIME = 'u'

staticprivate

The character used to indicate that the message timestamp should be printed in UTC time.

Definition at line 146 of file Message.h.

WIDTH

const char Message::WIDTH = 'W'

staticprivate

The character used to indicate that the previous decimal characters should be taken as the field width.

Definition at line 170 of file Message.h.

---

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

• GaudiKernel/include/GaudiKernel/Message.h
• GaudiKernel/src/Lib/Message.cpp