msghandler.hxx

Go to the documentation of this file.

/************************************************************
 * msghandler.hpp
 *
 *  Created on: Dec 3, 2014
 *      Author: Leonidas Georgopoulos
 *
 *  Copyright (C) 2014 Leonidas Georgopoulos
 *  Distributed under the Boost Software License, Version 1.0.
 *  (See accompanying file LICENSE_1_0.txt or
 *  copy at http://www.boost.org/LICENSE_1_0.txt)
 *
 ************************************************************/
#ifndef LUTILS_MSGHANDLER_HPP_
#define LUTILS_MSGHANDLER_HPP_
 
#include <algorithm>
 
#define LUTILS_MESSAGE_LEVEL_ZERO "lutils_nolevel"
 
namespace lutils
{
namespace program
{
 
template<typename UI, typename M, typename T, typename B>
inline msghandler<UI, M, T, B>::~msghandler()
{
    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;
}
 
template<typename UI, typename M, typename T, typename B>
inline msghandler<UI, M, T, B>::msghandler()
        : m_handler(nullptr),
            m_running(false),
            m_have_messages(false)
{
    this->on();
}
 
template<typename UI, typename M, typename T, typename B>
inline void msghandler<UI, M, T, B>::setlevel(t_str const & level, t_levels levels)
{
    t_lock l(m_loock);
    m_level = level;
    m_levels = levels;
}
 
template<typename UI, typename M, typename T, typename B>
inline void msghandler<UI, M, T, B>::set(t_str const & logfile)
{
    reopen(logfile);
}
 
template<typename UI, typename M, typename T, typename B>
inline void msghandler<UI, M, T, B>::on()
{
    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);
        }
    }
}
 
template<typename UI, typename M, typename T, typename B>
inline void msghandler<UI, M, T, B>::handle()
{
    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;
 
        }
    }
}
 
template<typename UI, typename M, typename T, typename B>
inline void msghandler<UI, M, T, B>::message(t_str const & in)
{
    message(LUTILS_MESSAGE_LEVEL_ZERO, in);
}
 
template<typename UI, typename M, typename T, typename B>
inline void msghandler<UI, M, T, B>::message(t_str const & level, t_str const & in)
{
    {
        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);
}
 
template<typename UI, typename M, typename T, typename B>
template<typename TR >
inline  typename TR::default_post_ret_type msghandler<UI, M, T, B>::post(
        t_str const & m, t_str const & l)
{
    std::cerr << "[" << l << "]:"<< m << std::endl;
}
 
template<typename UI, typename M, typename T, typename B>
template<typename TR >
inline  typename TR::post_ret_type msghandler<UI, M, T, B>::post(
        t_str const & m, t_str const & l)
{
    TR::post(m,l);
}
 
template<typename UI, typename M, typename T, typename B>
inline bool msghandler<UI, M, T, B>::levelcheck(t_str const & level) const
{
    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;
}
 
template<typename UI, typename M, typename T, typename B>
inline void msghandler<UI, M, T, B>::file(t_str const & m)
{
    *(m_file) << std::endl << m << std::endl;
}
 
template<typename UI, typename M, typename T, typename B>
inline void msghandler<UI, M, T, B>::reopen(t_str const & logfile)
{
    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);
    }
}
 
template<typename UI, typename M, typename T, typename B>
inline msghandler<UI, M, T, B> & msghandler<UI, M, T, B>::ref()
{
    static msghandler<UI> This;
    return This;
}
 
} /* namespace program */
} /* namespace lutils */
 
 
// Facility macro to inform at compile time msg handler that this class provides a post function
#define HAS_POST typedef void post_ret_type;
#define DEFAULT_POST typedef void default_post_ret_type;
 
#endif /* LUTILS_MSGHANDLER_HPP_ */