MsgStream.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_MSGSTREAM_H
#define GAUDIKERNEL_MSGSTREAM_H

// Include files
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/SerializeSTL.h"
// Standard C++ classes
#include <cstdio>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>

class MsgStream
{
private:
  typedef std::ios_base::fmtflags FLAG_TYPE;
  typedef std::ios_base::iostate  STATE_TYPE;

protected:
  IMessageSvc* m_service;
  std::string m_buffer;
  std::string m_source;
  std::ostringstream m_stream;
  bool m_active = false;
  MSG::Level m_level;
  MSG::Level m_currLevel;
  bool m_useColors;
  IInactiveMessageCounter* m_inactCounter = nullptr;
  static bool m_countInactive;

public:
  GAUDI_API MsgStream( IMessageSvc* svc, int buffer_length = 128 );
  GAUDI_API MsgStream( IMessageSvc* svc, std::string source, int buffer_length = 128 );
  MsgStream( const MsgStream& msg )
      : m_service( msg.m_service )
      , m_active( msg.m_active )
      , m_level( msg.m_level )
      , m_currLevel( msg.m_currLevel )
      , m_useColors( msg.m_useColors )
      , m_inactCounter( msg.m_inactCounter )
  {
    try { // ignore exception if we cannot copy the string
      m_source = msg.m_source;
    } catch ( ... ) {
    }
  }
  GAUDI_API virtual ~MsgStream() = default;
  MsgStream& report( int lvl )
  {
    lvl = ( lvl >= MSG::NUM_LEVELS ) ? MSG::ALWAYS : ( lvl < MSG::NIL ) ? MSG::NIL : lvl;
    if ( ( m_currLevel = MSG::Level( lvl ) ) >= level() ) {
      activate();
    } else {
      deactivate();
#ifndef NDEBUG
      if ( MsgStream::countInactive() && m_inactCounter ) {
        m_inactCounter->incrInactiveCount( MSG::Level( lvl ), m_source );
      }
#endif
    }
    return *this;
  }
  virtual GAUDI_API MsgStream& doOutput();
  const std::string& buffer() const { return m_buffer; }
  std::ostringstream& stream() { return m_stream; }
  void setMsgSvc( IMessageSvc* svc ) { m_service = svc; }
  void setLevel( int level )
  {
    level   = ( level >= MSG::NUM_LEVELS ) ? MSG::ALWAYS : ( level < MSG::NIL ) ? MSG::NIL : level;
    m_level = MSG::Level( level );
  }
  MSG::Level level() const { return m_level; }
  MSG::Level currentLevel() const { return m_currLevel; }
  void activate() { m_active = true; }
  void deactivate() { m_active = false; }
  bool isActive() const { return m_active; }
  // oMsgStream flush emulation
  MsgStream& flush()
  {
    if ( isActive() ) m_stream.flush();
    return *this;
  }
  // oMsgStream write emulation
  MsgStream& write( const char* buff, int len )
  {
    if ( isActive() ) m_stream.write( buff, len );
    return *this;
  }
  MsgStream& operator<<( MsgStream& ( *_f )(MsgStream&))
  {
    if ( isActive() ) _f( *this );
    return *this;
  }
  MsgStream& operator<<( std::ostream& ( *_f )(std::ostream&))
  {
    if ( isActive() ) _f( m_stream );
    return *this;
  }
  MsgStream& operator<<( std::ios& ( *_f )(std::ios&))
  {
    if ( isActive() ) _f( m_stream );
    return *this;
  }
  MsgStream& operator<<( MSG::Level level ) { return report( level ); }
  MsgStream& operator<<( longlong arg )
  {
    try {
      // this may throw, and we cannot afford it if the stream is used in a catch block
      if ( isActive() ) {
        m_stream << arg;
      }
    } catch ( ... ) {
    }
    return *this;
  }

  MsgStream& operator<<( std::ios_base& ( *_f )(std::ios_base&))
  {
    if ( isActive() ) _f( m_stream );
    return *this;
  }

  long flags() const { return isActive() ? m_stream.flags() : 0; }
  long flags( FLAG_TYPE v ) { return isActive() ? m_stream.flags( v ) : 0; }
  long setf( FLAG_TYPE v ) { return isActive() ? m_stream.setf( v ) : 0; }
  int                  width() const { return isActive() ? m_stream.width() : 0; }
  int width( int v ) { return isActive() ? m_stream.width( v ) : 0; }
  char           fill() const { return isActive() ? m_stream.fill() : (char)-1; }
  char fill( char v ) { return isActive() ? m_stream.fill( v ) : (char)-1; }
  int             precision() const { return isActive() ? m_stream.precision() : 0; }
  int precision( int v ) { return isActive() ? m_stream.precision( v ) : 0; }
  int                rdstate() const { return isActive() ? m_stream.rdstate() : std::ios_base::failbit; }
  int                good() const { return isActive() ? m_stream.good() : 0; }
  int                eof() const { return isActive() ? m_stream.eof() : 0; }
  int                bad() const { return isActive() ? m_stream.bad() : 0; }
  long setf( FLAG_TYPE _f, FLAG_TYPE _m ) { return isActive() ? m_stream.setf( _f, _m ) : 0; }
  void unsetf( FLAG_TYPE _l )
  {
    if ( isActive() ) m_stream.unsetf( _l );
  }
  void clear( STATE_TYPE _i = std::ios_base::failbit )
  {
    if ( isActive() ) m_stream.clear( _i );
  }

  GAUDI_API void setColor( MSG::Color col );
  GAUDI_API void setColor( MSG::Color fg, MSG::Color bg );

  GAUDI_API void resetColor();

  static GAUDI_API bool enableCountInactive( bool value = true );

  static GAUDI_API bool countInactive();
};

inline MsgStream& endmsg( MsgStream& s ) { return s.doOutput(); }

GAUDI_API std::string format( const char*, ... );

#ifdef _WIN32
template <class _E>
inline MsgStream& operator<<( MsgStream& s, const std::_Fillobj<_E>& obj )
{
#if _MSC_VER > 1300
  if ( s.isActive() ) s.stream().fill( obj._Fill );
#else
  if ( s.isActive() ) s.stream().fill( obj._Ch );
#endif
  return s;
}
template <class _Tm>
inline MsgStream& operator<<( MsgStream& s, const std::_Smanip<_Tm>& manip )
{
#if _MSC_VER > 1300
  if ( s.isActive() ) ( *manip._Pfun )( s.stream(), manip._Manarg );
#else
  if ( s.isActive() ) ( *manip._Pf )( s.stream(), manip._Manarg );
#endif
  return s;
}
#elif defined( __GNUC__ )
#ifndef __APPLE__
inline MsgStream& operator<<( MsgStream& s, const std::_Setiosflags& manip )
{
  try {
    // this may throw, and we cannot afford it if the stream is used in a catch block
    if ( s.isActive() ) s.stream() << manip;
  } catch ( ... ) {
  }
  return s;
}
inline MsgStream& operator<<( MsgStream& s, const std::_Resetiosflags& manip )
{
  try {
    // this may throw, and we cannot afford it if the stream is used in a catch block
    if ( s.isActive() ) s.stream() << manip;
  } catch ( ... ) {
  }
  return s;
}
inline MsgStream& operator<<( MsgStream& s, const std::_Setbase& manip )
{
  try {
    // this may throw, and we cannot afford it if the stream is used in a catch block
    if ( s.isActive() ) s.stream() << manip;
  } catch ( ... ) {
  }
  return s;
}
inline MsgStream& operator<<( MsgStream& s, const std::_Setprecision& manip )
{
  try {
    // this may throw, and we cannot afford it if the stream is used in a catch block
    if ( s.isActive() ) s.stream() << manip;
  } catch ( ... ) {
  }
  return s;
}
inline MsgStream& operator<<( MsgStream& s, const std::_Setw& manip )
{
  try {
    // this may throw, and we cannot afford it if the stream is used in a catch block
    if ( s.isActive() ) s.stream() << manip;
  } catch ( ... ) {
  }
  return s;
}
#endif // not __APPLE__
#else  // GCC, version << 3
template <class _Tm>
inline MsgStream& operator<<( MsgStream& s, const std::smanip<_Tm>& manip )
{
  try {
    // this may throw, and we cannot afford it if the stream is used in a catch block
    if ( s.isActive() ) s.stream() << manip;
  } catch ( ... ) {
  }
  return s;
}
#endif // WIN32 or (__GNUC__)

namespace MSG
{
  inline MsgStream& dec( MsgStream& log )
  {
    log << std::dec;
    return log;
  }
  inline MsgStream& hex( MsgStream& log )
  {
    log << std::hex;
    return log;
  }
}

inline MsgStream& operator<<( MsgStream& s, const char* arg )
{
  try {
    // this may throw, and we cannot afford it if the stream is used in a catch block
    if ( s.isActive() ) s.stream() << arg;
  } catch ( ... ) {
  }
  return s;
}

template <typename T>
MsgStream& operator<<( MsgStream& lhs, const T& arg )
{
  using namespace GaudiUtils;
  if ( lhs.isActive() ) try {
      // this may throw, and we cannot afford it if the stream is used in a catch block
      lhs.stream() << arg;
    } catch ( ... ) {
    }
  return lhs;
}

#if defined( __GNUC__ ) and not defined( __APPLE__ )
template <typename T>
MsgStream& operator<<( MsgStream& lhs, const std::_Setfill<T>& manip )
{
  if ( lhs.isActive() ) try {
      // this may throw, and we cannot afford it if the stream is used in a catch block
      lhs.stream() << manip;
    } catch ( ... ) {
    }
  return lhs;
}
#endif

#endif // GAUDIKERNEL_MSGSTREAM_H