Logger.h

Go to the documentation of this file.

 
#ifndef LLU_ERRORLOG_LOGGER_H
#define LLU_ERRORLOG_LOGGER_H
 
#include <initializer_list>
#include <mutex>
#include <string>
#include <utility>
 
#include "LLU/LibraryData.h"
#include "LLU/WSTP/WSStream.hpp"
 
// Configuration macros to set desired level of logging at build time:
 
#ifdef LLU_LOG_DEBUG
#define LLU_LOG_LEVEL_DEBUG
#define LLU_LOG_WARNING
#define LLU_LOG_DEBUG // workaround for a Doxygen bug
#endif
 
#ifdef LLU_LOG_WARNING
#define LLU_LOG_LEVEL_WARNING
#define LLU_LOG_ERROR
#endif
 
#ifdef LLU_LOG_ERROR
#define LLU_LOG_LEVEL_ERROR
#endif
 
// Convenience macros to use in the code:
 
#ifdef LLU_LOG_LEVEL_DEBUG
 
#define LLU_DEBUG(...) LLU::Logger::log<LLU::Logger::Level::Debug>(__LINE__, __FILE__, __func__, __VA_ARGS__)
#else
#define LLU_DEBUG(...) ((void)0)
#endif
 
#ifdef LLU_LOG_LEVEL_WARNING
 
#define LLU_WARNING(...) LLU::Logger::log<LLU::Logger::Level::Warning>(__LINE__, __FILE__, __func__, __VA_ARGS__)
#else
#define LLU_WARNING(...) ((void)0)
#endif
 
#ifdef LLU_LOG_LEVEL_ERROR
 
#define LLU_ERROR(...) LLU::Logger::log<LLU::Logger::Level::Error>(__LINE__, __FILE__, __func__, __VA_ARGS__)
#else
#define LLU_ERROR(...) ((void)0)
#endif
 
namespace LLU {
 
    class Logger {
    public:
        enum class Level { Debug, Warning, Error };
 
        template<Level L, typename... T>
        static void log(WolframLibraryData libData, int line, const std::string& fileName, const std::string& function, T&&... args);
 
        template<Level L, typename... T>
        static void log(int line, const std::string& fileName, const std::string& function, T&&... args);
 
        static std::string to_string(Level l);
 
        static void setContext(std::string context) {
            logSymbolContext = std::move(context);
        }
 
        static std::string getSymbol() {
            return logSymbolContext + topLevelLogCallback;
        }
 
    private:
        static constexpr const char* topLevelLogCallback = "Logger`LogHandler";
        static std::mutex mlinkGuard;
        static std::string logSymbolContext;
    };
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    static WSStream<EIn, EOut>& operator<<(WSStream<EIn, EOut>& ms, Logger::Level l) {
        return ms << Logger::to_string(l);
    }
 
    template<Logger::Level L, typename... T>
    void Logger::log(WolframLibraryData libData, int line, const std::string& fileName, const std::string& function, T&&... args) {
        if (!libData) {
            return;
        }
        std::lock_guard<std::mutex> lock(mlinkGuard);
 
        WSStream<WS::Encoding::UTF8> mls {libData->getWSLINK(libData)};
        mls << WS::Function("EvaluatePacket", 1);
        mls << WS::Function(getSymbol(), 4 + sizeof...(T));
        mls << L << line << fileName << function;
        Unused((mls << ... << args));
        libData->processWSLINK(mls.get());
        auto pkt = WSNextPacket(mls.get());
        if (pkt == RETURNPKT) {
            mls << WS::NewPacket;
        }
    }
 
    template<Logger::Level L, typename... T>
    void Logger::log(int line, const std::string& fileName, const std::string& function, T&&... args) {
        log<L>(LibraryData::API(), line, fileName, function, std::forward<T>(args)...);
    }
 
}  // namespace LLU
#endif    // LLU_ERRORLOG_LOGGER_H