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 <boost/thread/tss.hpp>

#include <memory>
#include <utility>

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

namespace implementation_detail
{
  template <typename>
  struct void_t {
    using type = void;
  };
  template <typename T>
  using is_valid_t = typename void_t<T>::type;

  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_msgSvc() const    = 0;
  virtual void create_msgStream() const = 0;

  inline SmartIF<IMessageSvc>& msgSvc() const
  {
    if ( UNLIKELY( !m_msgsvc ) ) create_msgSvc();
    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 ); }

  inline MSG::Level msgLevel() const
  {
    if ( UNLIKELY( ( !m_msgStream.get() ) ) ) create_msgStream();
    if ( UNLIKELY( ( !m_level.get() ) ) ) {
      return MSG::NIL;
    }
    return *m_level;
  }

  inline MSG::Level outputLevel() const __attribute__( ( deprecated ) ) { return msgLevel(); }

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

private:
  template <typename Base>
  friend class CommonMessaging;

  mutable boost::thread_specific_ptr<MsgStream> m_msgStream;

  //  mutable MSG::Level m_level = MSG::NIL;
  mutable boost::thread_specific_ptr<MSG::Level> m_level;

  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;

private:
  // out-of-line 'cold' functions -- put here so as to not blow up the inline 'hot' functions
  void create_msgSvc() const override final
  {
    // Get default implementation of the message service.
    m_msgsvc = this->serviceLocator();
  }
  void create_msgStream() const override final
  {
    auto& ms = msgSvc();
    m_msgStream.reset( new MsgStream( ms, this->name() ) );
    m_level.reset( new MSG::Level( m_msgStream.get() ? m_msgStream->level() : MSG::NIL ) );
  }

protected:
  void updateMsgStreamOutputLevel( int level )
  {
    if ( !m_msgStream.get() ) {
      create_msgStream();
    }
    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_ */