Gaudi Framework, version v21r9
Home   Generated: 3 May 2010

Message Class Reference

The Message class. More...

#include <GaudiKernel/Message.h>

Collaboration diagram for Message:

Collaboration graph
[legend]

List of all members.

Public Member Functions

 Message ()
 Default constructor.
 Message (const char *src, int type, const char *msg)
 Constructor.
 Message (const std::string &src, int type, const std::string &msg)
 Constructor.
 ~Message ()
 Default destructor.
const std::string & getMessage () const
 Get the message string.
void setMessage (const 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 (const std::string &src)
 Set the message source.
const std::string & getFormat () const
 Get the format string.
void setFormat (const std::string &msg) const
 Set the format string.
const std::string & getTimeFormat () const
 Get the time format string.
void setTimeFormat (const std::string &timeFormat) const
 Set the time format string.
bool operator< (const Message &test)
 Needed to build maps.

Static Public Member Functions

static const std::string getDefaultFormat ()
 Get the default format string.
static const std::string getDefaultTimeFormat ()
 Get the default time format string.

Protected Member Functions

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) const
 Truncate or pad the output string to the field width as necessary.
void setWidth (const std::string &formatArg) const
 Set the width of a stream.

Protected Attributes

std::string m_message
 The message.
std::string m_source
 The source.
std::string m_format
 The format string.
std::string m_time_format
 Time format string.
int m_type
 The type.
std::string m_formatted_msg
 Formatted message.
char m_fill
 The current fill character.
int m_width
 The current field width.
bool m_left
 Justification.

Static Protected Attributes

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 FILL = 'F'
 The character used to indicate that the previous character is to be used for padding out 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 const char * DEFAULT_FORMAT = "% F%18W%S%7W%R%T %0W%M"
 The default message format.
static const char * DEFAULT_TIME_FORMAT = "%Y-%m-%d %H:%M:%S,%f"
 The default time format.

Friends

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.

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 15 of file Message.h.

Constructor & Destructor Documentation

Message::Message (  ) 

Default constructor.

Definition at line 44 of file Message.cpp.

00044                  :
00045   m_message( "" ), m_source( "UNKNOWN" ), m_format( DEFAULT_FORMAT ),
00046   m_time_format(DEFAULT_TIME_FORMAT), m_type( NIL ),
00047   m_fill( ' ' ), m_width( 0 ), m_left( true )
00048 {
00049 }

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

Constructor.

Definition at line 57 of file Message.cpp.

00057                                                               :
00058   m_message( msg ), m_source( src ), m_format( DEFAULT_FORMAT ),
00059   m_time_format(DEFAULT_TIME_FORMAT), m_type( type ),
00060   m_fill( ' ' ), m_width( 0 ), m_left( true )
00061 {
00062 }

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

Constructor.

Definition at line 70 of file Message.cpp.

00070                                                                         :
00071   m_message( msg ), m_source( src ), m_format( DEFAULT_FORMAT ),
00072   m_time_format(DEFAULT_TIME_FORMAT), m_type( type ),
00073   m_fill( ' ' ), m_width( 0 ), m_left( true )
00074 {
00075 }

Message::~Message (  )  [inline]

Default destructor.

Definition at line 27 of file Message.h.

00027 {}

Member Function Documentation

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

Get the message string.

Definition at line 83 of file Message.cpp.

00084 {
00085   return m_message;
00086 }

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

Set the message string.

Definition at line 94 of file Message.cpp.

00095 {
00096   m_message = msg;
00097 }

int Message::getType (  )  const

Get the message type.

Definition at line 105 of file Message.cpp.

00106 {
00107   return m_type;
00108 }

void Message::setType ( int  msg_type  ) 

Set the message type.

Definition at line 116 of file Message.cpp.

00117 {
00118   m_type = msg_type;
00119 }

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

Get the message source.

Definition at line 127 of file Message.cpp.

00128 {
00129   return m_source;
00130 }

void Message::setSource ( const std::string &  src  ) 

Set the message source.

Definition at line 138 of file Message.cpp.

00139 {
00140   m_source = src;
00141 }

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

Get the format string.

Definition at line 188 of file Message.cpp.

00189 {
00190   return m_format;
00191 }

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

Get the default format string.

Definition at line 199 of file Message.cpp.

00200 {
00201   return DEFAULT_FORMAT;
00202 }

void Message::setFormat ( const std::string &  msg  )  const

Set the format string.

Definition at line 212 of file Message.cpp.

00213 {
00214   if ( format.empty() )
00215     m_format = DEFAULT_FORMAT;
00216   else
00217     m_format = format;
00218 }

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

Get the time format string.

Definition at line 226 of file Message.cpp.

00227 {
00228   return m_time_format;
00229 }

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

Get the default time format string.

Definition at line 237 of file Message.cpp.

00238 {
00239   return DEFAULT_TIME_FORMAT ;
00240 }

void Message::setTimeFormat ( const std::string &  timeFormat  )  const

Set the time format string.

Definition at line 250 of file Message.cpp.

00251 {
00252   if ( timeFormat.empty() )
00253     m_time_format = DEFAULT_TIME_FORMAT;
00254   else
00255     m_time_format = timeFormat;
00256 }

bool Message::operator< ( const Message &  test  ) 

Needed to build maps.

Definition at line 162 of file Message.cpp.

00163 {
00164   return m_type   < b.m_type ||
00165          m_source < b.m_source ||
00166          m_message < b.m_message;
00167 }

void Message::invalidFormat (  )  const [protected]

Called when an invalid format string is encountered.

Definition at line 380 of file Message.cpp.

00381 {
00382   makeFormattedMsg( DEFAULT_FORMAT );
00383 }

void Message::makeFormattedMsg ( const std::string &  format  )  const [protected]

Format the message.

Definition at line 264 of file Message.cpp.

00265 {
00266   m_formatted_msg = "";
00267   std::string::const_iterator i = format.begin();
00268   while( i != format.end() ) {
00269 
00270     // Output format string until format statement found.
00271     while(  i != format.end() && *i != FORMAT_PREFIX )
00272       m_formatted_msg += *i++;
00273 
00274     // Test for end of format string.
00275     if ( i == format.end() ) break;
00276     i++;
00277 
00278     // Find type of formatting.
00279     std::string this_format = "";
00280     while( i != format.end() && *i != FORMAT_PREFIX &&
00281            *i != MESSAGE && *i != TYPE && *i != SOURCE &&
00282            *i != FILL && *i != WIDTH && *i != TIME && *i != UTIME &&
00283            *i != JUSTIFY_LEFT && *i != JUSTIFY_RIGHT ) {
00284       this_format += *i++;
00285     }
00286 
00287     // Reached end of string with improper format.
00288     if ( i == format.end() ) {
00289       invalidFormat();
00290       break;
00291     }
00292 
00293     this_format += *i++;
00294     decodeFormat( this_format );
00295   }
00296 }

void Message::decodeFormat ( const std::string &  format  )  const [protected]

Decode format.

Definition at line 304 of file Message.cpp.

00305 {
00306   if ( ! format.empty() ) {
00307     const char FORMAT_TYPE = format[ format.length() - 1 ];
00308     const std::string FORMAT_PARAM = format.substr( 0, format.length() - 1 );
00309 
00310     // Now test the format.
00311     std::string level;
00312     switch( FORMAT_TYPE ) {
00313     case FILL:
00314       if ( FORMAT_PARAM.length() == 1 ) {
00315         m_fill = FORMAT_PARAM[0];
00316       }
00317       else
00318         invalidFormat();
00319       break;
00320 
00321     case TIME:
00322       {
00323         const std::string& timeStr = formattedTime ( m_time_format ) ;
00324         sizeField( timeStr );
00325       }
00326       break;
00327 
00328     case UTIME:
00329       {
00330         const std::string& timeStr = formattedTime ( m_time_format, true ) ;
00331         sizeField( timeStr );
00332       }
00333       break;
00334 
00335     case MESSAGE:
00336       sizeField( m_message );
00337       break;
00338 
00339     case SOURCE:
00340       sizeField( m_source );
00341       break;
00342 
00343     case TYPE:
00344       switch ( m_type )    {
00345 #define SET(x)  case x:  level=#x;  break
00346         SET( NIL );
00347         SET( VERBOSE );
00348         SET( DEBUG );
00349         SET( INFO );
00350         SET( WARNING );
00351         SET( ERROR );
00352         SET( FATAL );
00353         case ALWAYS:       level="SUCCESS"; break;
00354         default:
00355               level = "UNKNOWN";
00356               break;
00357 #undef SET
00358       }
00359       sizeField( level );
00360       break;
00361 
00362     case FORMAT_PREFIX: m_formatted_msg += FORMAT_PREFIX; break;
00363     case JUSTIFY_RIGHT: m_left = false; break;
00364     case JUSTIFY_LEFT: m_left = true; break;
00365     case WIDTH: setWidth( FORMAT_PARAM ); break;
00366     default: invalidFormat(); break;
00367     }
00368   }
00369   else
00370     invalidFormat();
00371 }

void Message::sizeField ( const std::string &  text  )  const [protected]

Truncate or pad the output string to the field width as necessary.

Definition at line 423 of file Message.cpp.

00424 {
00425   std::string newText;
00426   if ( m_width == 0 || m_width == static_cast<int>( text.length() ) ) {
00427     newText = text;
00428   }
00429   else {
00430 
00431     // Truncate the text if it is too long.
00432     if ( m_width < static_cast<int>( text.length() ) ) {
00433       newText = text.substr( 0, m_width );
00434       for ( int i = 0, j = newText.length()-1; i < 3 && j >= 0; i++, j-- )
00435         newText[ j ] = '.';
00436     }
00437 
00438     // Pad the text.
00439     else {
00440       newText = std::string( m_width, m_fill );
00441       if ( m_left )
00442         newText.replace( newText.begin(), newText.begin() + text.length(),
00443                          text.begin(), text.end() );
00444       else
00445         newText.replace( newText.end() - text.length(), newText.end(),
00446                          text.begin(), text.end() );
00447     }
00448   }
00449 
00450   m_formatted_msg += newText;
00451 }

void Message::setWidth ( const std::string &  formatArg  )  const [protected]

Set the width of a stream.

Definition at line 392 of file Message.cpp.

00393 {
00394   // Check that the parameters are only digits.
00395   bool only_digits = true;
00396   for( std::string::const_iterator i = formatArg.begin();
00397        i != formatArg.end(); i++ ) {
00398 
00399     if ( ! isdigit( *i ) ) {
00400       only_digits = false;
00401       invalidFormat();
00402       break;
00403     }
00404   }
00405 
00406   // Convert string to int.
00407   if ( only_digits ) {
00408 #ifdef __GNUG__
00409     m_width = atoi( formatArg.c_str() );
00410 #else
00411     m_width = atoi( formatArg.data() );
00412 #endif
00413   }
00414 }

Friends And Related Function Documentation

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

Insert the message into a stream.

Definition at line 149 of file Message.cpp.

00150 {
00151   msg.makeFormattedMsg( msg.m_format );
00152   stream << msg.m_formatted_msg;
00153   return stream;
00154 }

bool operator== ( const Message &  a,
const Message &  b 
) [friend]

Insert the message into a stream.

Definition at line 175 of file Message.cpp.

00176 {
00177   return a.m_source == b.m_source &&
00178     a.m_type == b.m_type &&
00179     a.m_message == b.m_message;
00180 }

Member Data Documentation

std::string Message::m_message [protected]

The message.

Definition at line 91 of file Message.h.

std::string Message::m_source [protected]

The source.

Definition at line 94 of file Message.h.

std::string Message::m_format [mutable, protected]

The format string.

Definition at line 97 of file Message.h.

std::string Message::m_time_format [mutable, protected]

Time format string.

Definition at line 100 of file Message.h.

int Message::m_type [protected]

The type.

Definition at line 103 of file Message.h.

std::string Message::m_formatted_msg [mutable, protected]

Formatted message.

Definition at line 106 of file Message.h.

char Message::m_fill [mutable, protected]

The current fill character.

Definition at line 109 of file Message.h.

int Message::m_width [mutable, protected]

The current field width.

Definition at line 112 of file Message.h.

bool Message::m_left [mutable, protected]

Justification.

Definition at line 115 of file Message.h.

const char Message::FORMAT_PREFIX = '%' [static, protected]

The character used to prefix formatting commands.

Definition at line 118 of file Message.h.

const char Message::JUSTIFY_LEFT = 'L' [static, protected]

The character used to indicate start of left text justification.

Definition at line 121 of file Message.h.

const char Message::JUSTIFY_RIGHT = 'R' [static, protected]

The character used to indicate start of right text justification.

Definition at line 124 of file Message.h.

const char Message::MESSAGE = 'M' [static, protected]

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

Definition at line 127 of file Message.h.

const char Message::TYPE = 'T' [static, protected]

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

Definition at line 130 of file Message.h.

const char Message::TIME = 't' [static, protected]

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

Definition at line 133 of file Message.h.

const char Message::UTIME = 'u' [static, protected]

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

Definition at line 137 of file Message.h.

const char Message::SOURCE = 'S' [static, protected]

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

Definition at line 140 of file Message.h.

const char Message::FILL = 'F' [static, protected]

The character used to indicate that the previous character is to be used for padding out fields if the text is not long enough.

Definition at line 145 of file Message.h.

const char Message::WIDTH = 'W' [static, protected]

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

Definition at line 150 of file Message.h.

const char * Message::DEFAULT_FORMAT = "% F%18W%S%7W%R%T %0W%M" [static, protected]

The default message format.

Definition at line 153 of file Message.h.

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

The default time format.

Definition at line 156 of file Message.h.

The documentation for this class was generated from the following files:
Generated at Mon May 3 12:25:37 2010 for Gaudi Framework, version v21r9 by Doxygen version 1.5.6 written by Dimitri van Heesch, © 1997-2004