imstkLoggerSynchronous.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include <stdexcept>
#include <string>
#include <memory>
#include <iostream>
#include <sstream>
#include <fstream>

#include "imstkSpinLock.h"

// Using g3log loglevels for compatibility
#include "g3log/loglevels.hpp"
#include <deque>
/*

Still some weirdness, as we are still building G3 Log, the defines are still active

#define DEBUG 0
#define INFO 1
#define WARNING 2
#define FATAL 3
*/
namespace imstk
{
#if defined(__func__)
#define IMSTK_CURRENT_FUNCTION __func__
#elif defined(__FUNCSIG__)
#define IMSTK_CURRENT_FUNCTION __FUNCSIG__
#elif defined(__PRETTY_FUNCTION__)
#define IMSTK_CURRENT_FUNCTION __PRETTY_FUNCTION__
#elif defined(__FUNCTION__)
#define IMSTK_CURRENT_FUNCTION __FUNCTION__
#else
#define IMSTK_CURRENT_FUNCTION "???"
#endif

#define IMSTK_MAKE_STRING(x)  #x

class AssertionFailure : public std::runtime_error
{
public:
    explicit AssertionFailure(const std::string& message) : std::runtime_error(message)
    {
    }
};

class LogOutput
{
public:
    LogOutput() = default;
    virtual ~LogOutput() = default;

    virtual bool writeMessage(const std::string& message) = 0;
};

class NullOutput : public LogOutput
{
public:
    virtual bool writeMessage(const std::string&) { return true; }
};

/*
class FileOutput : public LogOutput
{
public:

    explicit FileOutput(const std::string& filename);

    bool writeMessage(const std::string& message) override;

private:
    std::string m_filename;
    std::ofstream m_stream;
    boost::mutex m_mutex;
};
*/

class StreamOutput : public LogOutput
{
public:

    explicit StreamOutput(std::ostream& ostream); //NOLINT

    bool writeMessage(const std::string& message) override;

private:
    std::ostream& m_stream;
    ParallelUtils::SpinLock m_mutex;
};

class CacheOutput : public LogOutput
{
public:
    CacheOutput();
    bool writeMessage(const std::string& message) override;

    bool hasMessages() const;

    std::string popLastMessage();

private:
    std::ofstream m_outFile;
    std::shared_ptr<StreamOutput>   m_fileOutput;
    std::deque<std::string>         m_messages;
    ParallelUtils::SpinLock mutable m_mutex;
};

class LoggerSynchronous
{
public:
    LoggerSynchronous(std::shared_ptr<LogOutput> output) : m_threshold(DEBUG.value), m_name("imstk"), m_output(output) { }

    static std::shared_ptr<LoggerSynchronous> instance()
    {
        static std::shared_ptr<LoggerSynchronous> defaultLogger = std::make_shared<LoggerSynchronous>(
            std::make_shared<CacheOutput>());
        return defaultLogger;
    }

    ~LoggerSynchronous() = default;

    static void startLogger() {}

    bool writeMessage(const std::string& message)
    {
        return m_output->writeMessage(message);
    }

    int getThreshold() const
    {
        return m_threshold;
    }

    void setThreshold(int val)
    {
        m_threshold = val;
    }

    std::shared_ptr<LogOutput> getOutput() const
    {
        return m_output;
    }

    std::shared_ptr<CacheOutput> getCacheOutput() const
    {
        return std::dynamic_pointer_cast<CacheOutput>(m_output);
    }

    void setOutput(std::shared_ptr<LogOutput> val)
    {
        m_output = val;
    }

    std::string getName()
    {
        return m_name;
    }

private:
    int m_threshold;
    std::string m_name;
    std::shared_ptr<LogOutput> m_output;
};

class LogMessageBase
{
public:

    LogMessageBase(LoggerSynchronous* logger, int level);

    ~LogMessageBase() noexcept(false) {
        flush();
    };

    template<typename T>
    LogMessageBase& operator <<(T&& input)
    {
        m_stream << input;
        return *this;
    }

    // A specialization for output manipulators (functions that apply to the stream).
    // Otherwise overloaded manipulators like std::endl and std::endl don't work, since the compiler can't know
    // what overloaded variant to apply.
    LogMessageBase& operator <<(std::ios_base& (*manipulator)(std::ios_base&))
    {
        m_stream << *manipulator;
        return *this;
    }

    // A specialization for output manipulators (functions that apply to the stream).
    // Otherwise overloaded manipulators like std::hex and std::endl don't work, since the compiler can't know
    // what overloaded variant to apply.
    LogMessageBase& operator <<(std::ostream& (*manipulator)(std::ostream&))
    {
        m_stream << *manipulator;
        return *this;
    }

protected:
    std::string getMessage()
    {
        return m_stream.str();
    }

    void flush()
    {
        m_logger->writeMessage(m_stream.str());
    }

private:
    std::ostringstream m_stream;
    LoggerSynchronous* m_logger;
};

class AssertMessage : public LogMessageBase
{
public:
    typedef void (* DeathCallback)(const std::string& message);

    explicit AssertMessage(LoggerSynchronous* logger) : LogMessageBase(logger, FATAL.value)
    {
    }

    explicit AssertMessage(const std::unique_ptr<LoggerSynchronous>& logger) : LogMessageBase(logger.get(), FATAL.value)
    {
    }

    explicit AssertMessage(const std::shared_ptr<LoggerSynchronous>& logger) : LogMessageBase(logger.get(), FATAL.value)
    {
    }

    ~AssertMessage() noexcept(false)
    {
        flush();
        m_killMeNow(getMessage());
    }

    static void setFailureCallback(DeathCallback callback);

    static DeathCallback getFailureCallback();

    static void setFailureBehaviorToThrow()
    {
        setFailureCallback(throwException);
    }

    static void setFailureBehaviorToDeath()
    {
        setFailureCallback(killApplication);
    }

private:
    static void throwException(const std::string& errorMessage);

    static void killApplication(const std::string& errorMessage);

    static DeathCallback m_killMeNow;
};
} // namespace imstk

#define LOG(level)                                                              \
    if (level.value < (::imstk::LoggerSynchronous::instance())->getThreshold()) \
    {                                                                           \
    }                                                                           \
    else                                                                        \
    /* important: no curly braces around this! */                               \
    ::imstk::LogMessageBase(::imstk::LoggerSynchronous::instance().get(), level.value)

#define LOG_IF(level, condition)                  \
    if (!(condition))                             \
    {                                             \
    }                                             \
    else                                          \
    /* important: no curly braces around this! */ \
    LOG(level)

#define CHECK(condition)                                                                                \
    if ((condition))                                                                                    \
    {                                                                                                   \
    }                                                                                                   \
    else                                                                                                \
    /* important: no curly braces around this! */                                                       \
    ::imstk::AssertMessage(::imstk::LoggerSynchronous::instance().get()) << "*** Assertion failed: " << \
        IMSTK_MAKE_STRING(condition) << " ***" << std::endl <<                                          \
        "    in " << IMSTK_CURRENT_FUNCTION << std::endl <<                                             \
        "    at " << __FILE__ << ":" << __LINE__ << std::endl