lutils::program::msghandler< UI, M, T, B > Class Template Reference

#include <msghandler.hpp>

Public Types
typedef UI::t_str	t_str
typedef std::vector< t_str >	t_levels

Public Member Functions
void	set (t_str const &logfile)
void	setlevel (t_str const &level, t_levels levels)
void	message (t_str const &messagein)
void	message (t_str const &msglevel, t_str const &messagein)

Static Public Member Functions
static msghandler &	ref ()

Private Types
typedef B	t_bool
typedef T	t_thread
typedef M	t_mut
typedef std::lock_guard< t_mut >	t_lock
typedef std::shared_ptr< t_str >	t_str_ptr
typedef std::ofstream	t_file
typedef std::unique_ptr< t_file >	t_file_ptr
template<typename E>
using	t_container = std::queue<E>
typedef t_container< std::pair< t_str, t_str > >	t_messages

Private Member Functions
void	on ()
void	handle ()
template<typename TR = UI>
TR::default_post_ret_type	post (t_str const &m, t_str const &l)
template<typename TR = UI>
TR::post_ret_type	post (t_str const &m, t_str const &l)
void	file (t_str const &)
bool	levelcheck (t_str const &level) const
void	reopen (t_str const &)
	~msghandler ()
	msghandler ()
	msghandler (msghandler const &)=delete
msghandler &	operator= (msghandler const &)=delete

Private Attributes
t_messages	m_messages
t_levels	m_levels
t_str	m_level
std::condition_variable	m_condition
std::mutex	m_cond_lock
t_str_ptr	m_logfile
t_file_ptr	m_file
t_thread *	m_handler
t_bool	m_running
t_bool	m_have_messages
t_mut	m_loock

Detailed Description

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>
class lutils::program::msghandler< UI, M, T, B >

Class providing message handling capabilities to multiple sources

Definition at line 40 of file msghandler.hpp.

Member Typedef Documentation

t_bool

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef B lutils::program::msghandler< UI, M, T, B >::t_bool

private

Definition at line 87 of file msghandler.hpp.

t_container

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

template<typename E>

using lutils::program::msghandler< UI, M, T, B >::t_container = std::queue<E>

private

Definition at line 98 of file msghandler.hpp.

t_file

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef std::ofstream lutils::program::msghandler< UI, M, T, B >::t_file

private

Definition at line 94 of file msghandler.hpp.

t_file_ptr

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef std::unique_ptr<t_file> lutils::program::msghandler< UI, M, T, B >::t_file_ptr

private

Definition at line 95 of file msghandler.hpp.

t_levels

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef std::vector<t_str> lutils::program::msghandler< UI, M, T, B >::t_levels

Definition at line 44 of file msghandler.hpp.

t_lock

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef std::lock_guard<t_mut> lutils::program::msghandler< UI, M, T, B >::t_lock

private

Definition at line 91 of file msghandler.hpp.

t_messages

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef t_container<std::pair<t_str, t_str> > lutils::program::msghandler< UI, M, T, B >::t_messages

private

Definition at line 99 of file msghandler.hpp.

t_mut

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef M lutils::program::msghandler< UI, M, T, B >::t_mut

private

Definition at line 90 of file msghandler.hpp.

t_str

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef UI::t_str lutils::program::msghandler< UI, M, T, B >::t_str

Definition at line 43 of file msghandler.hpp.

t_str_ptr

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef std::shared_ptr<t_str> lutils::program::msghandler< UI, M, T, B >::t_str_ptr

private

Definition at line 92 of file msghandler.hpp.

t_thread

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

typedef T lutils::program::msghandler< UI, M, T, B >::t_thread

private

Definition at line 89 of file msghandler.hpp.

Constructor & Destructor Documentation

~msghandler()

template<typename UI, typename M, typename T, typename B>

lutils::program::msghandler< UI, M, T, B >::~msghandler ( )

inlineprivate

Destruction waits to write all messages to file

Definition at line 32 of file msghandler.hxx.

{
  m_running = false;
  CONDITION_STD_SET(m_condition, m_cond_lock, m_have_messages, true);
  if (m_handler != nullptr) {
    m_handler->join();
  }
  delete m_handler;
}

msghandler() [1/2]

template<typename UI, typename M, typename T, typename B>

lutils::program::msghandler< UI, M, T, B >::msghandler ( )

inlineprivate

Constructs the object

Definition at line 46 of file msghandler.hxx.

  : m_handler(nullptr)
  , m_running(false)
  , m_have_messages(false)
{
  this->on();
}

msghandler() [2/2]

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

lutils::program::msghandler< UI, M, T, B >::msghandler ( msghandler< UI, M, T, B > const & )

privatedelete

Member Function Documentation

file()

template<typename UI, typename M, typename T, typename B>

void lutils::program::msghandler< UI, M, T, B >::file ( t_str const & m )

inlineprivate

Send message to file

Parameters

the	filename to write to

Default write to file function

This should not be specialized

Parameters

m

Definition at line 211 of file msghandler.hxx.

{
  *(m_file) << std::endl << m << std::endl;
}

handle()

template<typename UI, typename M, typename T, typename B>

void lutils::program::msghandler< UI, M, T, B >::handle ( )

inlineprivate

Handles incoming messages

Checks the queue and redirects messages either to a defined output or to a file if a file has been set

Definition at line 103 of file msghandler.hxx.

{
  typename t_messages::value_type m;
 
  while (m_running == true) {
    CONDITION_BOOL_WAIT_TRYFUN(m_condition, m_cond_lock, m_have_messages, [&m_running]() { m_running = false; });
    {
      t_lock l(m_loock);
      while (!m_messages.empty()) {
        m = m_messages.front();
        m_messages.pop();
        if (levelcheck(m.first)) {
          if (m_logfile == nullptr) {
            post(m.second, m.first);
          } else {
            file(m.second);
          }
        }
      }
 
      m_have_messages = false;
    }
  }
}

levelcheck()

template<typename UI, typename M, typename T, typename B>

bool lutils::program::msghandler< UI, M, T, B >::levelcheck ( t_str const & level ) const

inlineprivate

Checks the level of a message and return true if the level of the message is appropriate to be displayed

Parameters

level

of a message

Returns

true or false

Definition at line 187 of file msghandler.hxx.

{
  if (m_levels.empty()) {
    return true;
  }
 
  typename t_levels::const_iterator minlevel = std::find(m_levels.begin(), m_levels.end(), m_level);
  typename t_levels::const_iterator reqlevel = std::find(m_levels.begin(), m_levels.end(), level);
 
  if (reqlevel == m_levels.end() || reqlevel < minlevel) {
    return false;
  }
  return true;
}

message() [1/2]

template<typename UI, typename M, typename T, typename B>

void lutils::program::msghandler< UI, M, T, B >::message ( t_str const & in )

inline

Add a message to the queue to be served

Parameters

a	string as a message

Adds the message in the internal container which will be picked up later

Parameters

messagein

is the message to be displayed

Definition at line 135 of file msghandler.hxx.

{
  message(LUTILS_MESSAGE_LEVEL_ZERO, in);
}

message() [2/2]

template<typename UI, typename M, typename T, typename B>

void lutils::program::msghandler< UI, M, T, B >::message ( t_str const & msglevel, t_str const & messagein )

inline

Add a message to the queue to be served

Parameters

messagein	is the message content to be displayed
msglevel	is a tag representing the level of the message

Definition at line 142 of file msghandler.hxx.

{
  {
    t_lock l(m_loock);
    m_messages.push(std::make_pair(level, in));
  }
  CONDITION_STD_SET(m_condition, m_cond_lock, m_have_messages, true);
}

on()

template<typename UI, typename M, typename T, typename B>

void lutils::program::msghandler< UI, M, T, B >::on ( )

inlineprivate

Sets the object in ready to process state

Properly starts the message handler

Definition at line 86 of file msghandler.hxx.

{
  if (m_handler == nullptr) {
    t_lock l(m_loock);
    if (m_handler == nullptr) {
      m_running = true;
      m_handler = new t_thread(&msghandler<UI>::handle, this);
    }
  }
}

operator=()

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

msghandler & lutils::program::msghandler< UI, M, T, B >::operator= ( msghandler< UI, M, T, B > const & )

privatedelete

post() [1/2]

template<typename UI, typename M, typename T, typename B>

template<typename TR>

TR::post_ret_type lutils::program::msghandler< UI, M, T, B >::post ( t_str const & m, t_str const & l )

inlineprivate

Post action for users classes that define post_ret_type. These have to also define the post function

Parameters

m	the message to display

Definition at line 173 of file msghandler.hxx.

{
  TR::post(m, l);
}

post() [2/2]

template<typename UI, typename M, typename T, typename B>

template<typename TR>

TR::default_post_ret_type lutils::program::msghandler< UI, M, T, B >::post ( t_str const & m, t_str const & l )

inlineprivate

Sends message to standard output or the provided UI::post method

Parameters

m	is the message to send

Default post action for users classes that define default_post_ret_type

Parameters

m	the message to display

Definition at line 159 of file msghandler.hxx.

{
  std::cerr << "[" << l << "]:" << m << std::endl;
}

ref()

template<typename UI, typename M, typename T, typename B>

msghandler< UI, M, T, B > & lutils::program::msghandler< UI, M, T, B >::ref ( )

inlinestatic

Creates or retrieves the msghandler

Returns

a reference to a singleton msghandler

Creates the message handler

Returns

a reference to the created singleton

Definition at line 247 of file msghandler.hxx.

{
  static msghandler<UI> This;
  return This;
}

reopen()

template<typename UI, typename M, typename T, typename B>

void lutils::program::msghandler< UI, M, T, B >::reopen ( t_str const & logfile )

inlineprivate

Opens a designated file

Parameters

the	filename to open

Closes the current logfile and opens a new one

Parameters

logfile

Definition at line 223 of file msghandler.hxx.

{
  t_lock l(m_loock);
 
  m_logfile = t_str_ptr(new t_str(logfile));
 
  if (m_file != nullptr) {
    while (m_file->is_open()) {
      m_file->close();
    }
  }
  m_file = t_file_ptr(new std::ofstream);
 
  while (!m_file->is_open()) {
    m_file->open(logfile);
  }
}

set()

template<typename UI, typename M, typename T, typename B>

void lutils::program::msghandler< UI, M, T, B >::set ( t_str const & logfile )

inline

Sets the logfile. All remaining messages will be appended to that file

Parameters

logfile

Returns

a reference to a singleton msghandler

Properly sets the logfile

Parameters

logfile

to write to

Definition at line 76 of file msghandler.hxx.

{
  reopen(logfile);
}

setlevel()

template<typename UI, typename M, typename T, typename B>

void lutils::program::msghandler< UI, M, T, B >::setlevel ( t_str const & level, t_levels levels )

inline

Sets the minimum level of messages that the message handler will consider for handling. The rest will be discarded

Parameters

level	is a string that defines the minimum level
levels	is a vector of strings in order of imporance

Sets the minimum level of messages that the message handler will consider for handling. The rest will be discarded

Parameters

level	is a string that defines the minimum level
levels	is a vector of strings in order of importance (least important -> most )

Definition at line 63 of file msghandler.hxx.

{
  t_lock l(m_loock);
  m_level = level;
  m_levels = levels;
}

Member Data Documentation

m_cond_lock

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

std::mutex lutils::program::msghandler< UI, M, T, B >::m_cond_lock

private

Definition at line 106 of file msghandler.hpp.

m_condition

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

std::condition_variable lutils::program::msghandler< UI, M, T, B >::m_condition

private

Definition at line 105 of file msghandler.hpp.

m_file

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

t_file_ptr lutils::program::msghandler< UI, M, T, B >::m_file

private

Definition at line 109 of file msghandler.hpp.

m_handler

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

t_thread* lutils::program::msghandler< UI, M, T, B >::m_handler

private

Definition at line 111 of file msghandler.hpp.

m_have_messages

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

t_bool lutils::program::msghandler< UI, M, T, B >::m_have_messages

private

Definition at line 114 of file msghandler.hpp.

m_level

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

t_str lutils::program::msghandler< UI, M, T, B >::m_level

private

Definition at line 103 of file msghandler.hpp.

m_levels

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

t_levels lutils::program::msghandler< UI, M, T, B >::m_levels

private

Definition at line 102 of file msghandler.hpp.

m_logfile

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

t_str_ptr lutils::program::msghandler< UI, M, T, B >::m_logfile

private

Definition at line 108 of file msghandler.hpp.

m_loock

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

t_mut lutils::program::msghandler< UI, M, T, B >::m_loock

private

Definition at line 116 of file msghandler.hpp.

m_messages

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

t_messages lutils::program::msghandler< UI, M, T, B >::m_messages

private

Definition at line 101 of file msghandler.hpp.

m_running

template<typename UI, typename M = std::mutex, typename T = std::thread, typename B = bool>

t_bool lutils::program::msghandler< UI, M, T, B >::m_running

private

Definition at line 113 of file msghandler.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/msghandler.hpp
• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/detail/msghandler.hxx