CommonMessaging.h

Go to the documentation of this file.

/*
 * CommonMessaging.h
 *
 *  Created on: Feb 20, 2009
 *      Author: Marco Clemencic
 */

#ifndef COMMONMESSAGING_H_
#define COMMONMESSAGING_H_
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/IService.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/detected.h"
#include <boost/thread/tss.hpp>

#include <memory>
#include <utility>

#define generate_( method, ret, args )                                                                                 \
                                                                                                                       \
  template <typename T>                                                                                                \
  using _has_##method = decltype( std::declval<const T&>().method args );                                              \
                                                                                                                       \
  template <typename T>                                                                                                \
  using has_##method = Gaudi::cpp17::is_detected<_has_##method, T>;                                                    \
                                                                                                                       \
  template <typename Base>                                                                                             \
  struct add_##method : public Base {                                                                                  \
    using Base::Base;                                                                                                  \
    virtual ~add_##method()       = default;                                                                           \
    virtual ret method args const = 0;                                                                                 \
  };

namespace implementation_detail {
  generate_( name, const std::string&, () )

      generate_( serviceLocator, SmartIF<ISvcLocator>&, () )
}
#undef generate_

template <typename Base>
using add_name = typename std::conditional<implementation_detail::has_name<Base>::value, Base,
                                           implementation_detail::add_name<Base>>::type;
template <typename Base>
using add_serviceLocator = typename std::conditional<implementation_detail::has_serviceLocator<Base>::value, Base,
                                                     implementation_detail::add_serviceLocator<Base>>::type;

template <typename Base>
class CommonMessaging;

class CommonMessagingBase {
public:
  virtual ~CommonMessagingBase() = default;
  virtual void create_msgStream() const = 0;

  inline const SmartIF<IMessageSvc>& msgSvc() const { return m_msgsvc; }

  inline MsgStream& msgStream() const {
    if ( UNLIKELY( ( !m_msgStream.get() ) ) ) create_msgStream();
    return *m_msgStream;
  }

  inline MsgStream& msgStream( const MSG::Level level ) const { return msgStream() << level; }

  inline MsgStream& always() const { return msgStream( MSG::ALWAYS ); }

  inline MsgStream& fatal() const { return msgStream( MSG::FATAL ); }

  inline MsgStream& err() const { return msgStream( MSG::ERROR ); }

  inline MsgStream& error() const { return msgStream( MSG::ERROR ); }

  inline MsgStream& warning() const { return msgStream( MSG::WARNING ); }

  inline MsgStream& info() const { return msgStream( MSG::INFO ); }

  inline MsgStream& debug() const { return msgStream( MSG::DEBUG ); }

  inline MsgStream& verbose() const { return msgStream( MSG::VERBOSE ); }

  inline MsgStream& msg() const { return msgStream( MSG::INFO ); }

private:
  template <typename Base>
  friend class CommonMessaging;

  mutable bool       m_commonMessagingReady = false;
  mutable MSG::Level m_level                = MSG::NIL;

  mutable boost::thread_specific_ptr<MsgStream> m_msgStream;

  mutable SmartIF<IMessageSvc> m_msgsvc;
};

template <typename BASE>
class GAUDI_API CommonMessaging : public add_serviceLocator<add_name<BASE>>, public CommonMessagingBase {
public:
  using base_class = CommonMessaging;

  using add_serviceLocator<add_name<BASE>>::add_serviceLocator;

  inline MSG::Level msgLevel() const {
    if ( LIKELY( m_commonMessagingReady ) ) return m_level;
    return setUpMessaging();
  }

  [[deprecated( "please use msgLevel() instead of outputLevel()" )]] inline MSG::Level outputLevel() const {
    return msgLevel();
  }

  inline bool msgLevel( MSG::Level lvl ) const { return UNLIKELY( msgLevel() <= lvl ); }

private:
  // out-of-line 'cold' functions -- put here so as to not blow up the inline 'hot' functions
  void create_msgStream() const override final { m_msgStream.reset( new MsgStream( msgSvc(), this->name() ) ); }

  void initMessaging() const {
    if ( !m_msgsvc ) {
      // Get default implementation of the message service.
      m_msgsvc = this->serviceLocator();
    }
    create_msgStream();
    m_level = MSG::Level( m_msgStream.get() ? m_msgStream->level() : MSG::NIL );
    // if we could not get a MessageSvc, we should try again the initial set up
    m_commonMessagingReady = m_msgsvc;
  }

protected:
  MSG::Level setUpMessaging() const {
    if ( UNLIKELY( !m_commonMessagingReady ) ) { initMessaging(); }
    return m_level;
  }
  MSG::Level resetMessaging() {
    m_commonMessagingReady = false;
    return setUpMessaging();
  }
  void updateMsgStreamOutputLevel( int level ) {
    setUpMessaging();
    if ( level != MSG::NIL && level != m_level ) {
      if ( msgSvc() ) msgSvc()->setOutputLevel( this->name(), level );
      if ( m_msgStream.get() ) m_msgStream->setLevel( level );
      if ( UNLIKELY( MSG::Level( level ) <= MSG::DEBUG ) )
        debug() << "Property update for OutputLevel : new value = " << level << endmsg;
      m_level = MSG::Level( level );
    }
  }
};

#endif /* COMMONMESSAGING_H_ */