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<<( long long 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;
  }
} // namespace MSG

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