logs.hpp

Go to the documentation of this file.

 
#ifndef LOGICALACCESS_LOGS_HPP
#define LOGICALACCESS_LOGS_HPP
 
#undef EXCEPTION
#define EXCEPTION(type, ...)                                                             \
    type(/*__FUNCTION__ "," __FILE__ "," __LINE__ " : "*/ __VA_ARGS__)
 
#define EXCEPTION_ASSERT(condition, type, msg)                                           \
    if (!(condition))                                                                    \
    {                                                                                    \
        throw EXCEPTION(type, msg);                                                      \
    }
 
#include <logicalaccess/plugins/llacommon/lla_common_api.hpp>
#include <logicalaccess/lla_fwd.hpp>
#include <fstream>
#include <map>
#include <sstream>
#include <vector>
#include <array>
#include <cstdint>
 
namespace logicalaccess
{
enum LogLevel
{
    NONE = 0,
    TRACE,
    INFOS,
    WARNINGS,
    NOTICES,
    ERRORS,
    EMERGENSYS,
    CRITICALS,
    ALERTS,
    DEBUGS,
    COMS,
    PLUGINS,
    PLUGINS_ERROR
};
 
LLA_COMMON_API std::ostream &operator<<(std::ostream &ss, const ByteVector &bytebuff);
 
LLA_COMMON_API std::ostream &operator<<(std::ostream &ss,
                                        const std::vector<bool> &bytebuff);
 
template <long unsigned int Size>
std::ostream &operator<<(std::ostream &ss, const std::array<uint8_t, Size> &bytearray)
{
    ss << ByteVector(bytearray.begin(), bytearray.end());
    return ss;
}
 
class LLA_COMMON_API LogContext
{
  public:
    explicit LogContext(const std::string &);
    ~LogContext();
};
 
class LLA_COMMON_API Logs
{
  public:
    Logs(const char *file, const char *func, int line, enum LogLevel level);
 
    ~Logs();
 
    template <class T>
    Logs &operator<<(const T &arg)
    {
        _stream << arg;
        return (*this);
    }
 
    static std::ofstream logfile;
 
    static bool logToStderr;
 
  private:
    static std::string pretty_context_infos();
 
    enum LogLevel d_level;
    std::stringstream _stream;
    static std::map<LogLevel, std::string> logLevelMsg;
};
 
struct LLA_COMMON_API LogDisabler
{
    LogDisabler();
    ~LogDisabler();
 
  private:
    bool old_;
};
 
#ifdef SWIG
// Swig seems to be lost wrt variadic template function trace_print_helper()
// and believe there are multiple definition. Possibly, it does not properly 
// understand SFINAE.
// Therefore we disable the warning.
#pragma SWIG nowarn=302
#endif
 
LLA_COMMON_API std::ostream &operator<<(std::ostream &ss, const ByteVector &bytebuff);
 
LLA_COMMON_API std::ostream &operator<<(std::ostream &ss,
                                        const std::vector<bool> &bytebuff);
 
LLA_COMMON_API std::ostream &operator<<(std::ostream &ss,
                                        const std::vector<bool> &bytebuff);
 
#define LOG(x) logicalaccess::Logs(__FILE__, __FUNCTION__, __LINE__, x)
 
LLA_COMMON_API void trace_print_helper(std::stringstream &ss, const char *param_names,
                                       int idx);
 
LLA_COMMON_API std::string get_nth_param_name(const char *param_names, int idx);
 
template <typename Current, typename... T>
typename std::enable_if<!std::is_same<
    unsigned char, typename std::remove_reference<Current>::type>::value>::type
trace_print_helper(std::stringstream &ss, const char *param_names, int idx, Current &&c,
                   T &&... args);
 
template <typename Current, typename... T>
typename std::enable_if<std::is_same<
    unsigned char, typename std::remove_reference<Current>::type>::value>::type
trace_print_helper(std::stringstream &ss, const char *param_names, int idx, Current &&c,
                   T &&... args);
 
 
template <typename Current, typename... T>
typename std::enable_if<std::is_same<
    unsigned char, typename std::remove_reference<Current>::type>::value>::type
trace_print_helper(std::stringstream &ss, const char *param_names, int idx, Current &&c,
                   T &&... args)
{
    ss << " [" << get_nth_param_name(param_names, idx) << " --> " << +c << "]";
    trace_print_helper(ss, param_names, idx + 1, args...);
}
 
template <typename Current, typename... T>
typename std::enable_if<!std::is_same<
    unsigned char, typename std::remove_reference<Current>::type>::value>::type
trace_print_helper(std::stringstream &ss, const char *param_names, int idx, Current &&c,
                   T &&... args)
{
    using namespace logicalaccess; // to access some custom ostream overload for vector.
    ss << " [" << get_nth_param_name(param_names, idx) << " --> " << c << "]";
    trace_print_helper(ss, param_names, idx + 1, args...);
}
 
template <typename... T>
void trace_print(std::stringstream &ss, const char *param_names, T &&... params)
{
    trace_print_helper(ss, param_names, 0, params...);
}
 
#define TRACE(...)                                                                       \
    std::stringstream trace_stringstream;                                                \
    trace_print(trace_stringstream, #__VA_ARGS__, ##__VA_ARGS__);                        \
    LOG(TRACE) << trace_stringstream.str();
 
LLA_COMMON_API void trace_print_helper(std::stringstream &ss, const char *param_names,
                                       int idx);
 
LLA_COMMON_API std::string get_nth_param_name(const char *param_names, int idx);
 
#define LLA_LOG_CTX(param)                                                               \
    LogContext lla_log_ctx([&](void) {                                                   \
        std::stringstream logger_macro_ss__;                                             \
        logger_macro_ss__ << param;                                                      \
        return logger_macro_ss__.str();                                                  \
    }())
 
#define THROW_EXCEPTION_WITH_LOG(type, msg, ...)                                         \
    {                                                                                    \
        LOG(logicalaccess::LogLevel::ERRORS) << msg;                                     \
        throw EXCEPTION(type, msg, ##__VA_ARGS__);                                       \
    }
 
#define EXCEPTION_ASSERT_WITH_LOG(condition, type, msg, ...)                             \
    if (!(condition))                                                                    \
    {                                                                                    \
        THROW_EXCEPTION_WITH_LOG(type, msg, ##__VA_ARGS__);                              \
    }
}
 
#endif