Logging.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <functional>
#include <iostream>
#include <sstream>
#include <string>
 
#include "CVCoreLib.h"
 
// NVCC does not support deprecated attribute on Windows prior to v11.
#if defined(__CUDACC__) && defined(_MSC_VER) && __CUDACC_VER_MAJOR__ < 11
#ifndef FMT_DEPRECATED
#define FMT_DEPRECATED
#endif
#endif
 
#include <fmt/core.h>
#include <fmt/printf.h>
#include <fmt/ranges.h>
#if FMT_VERSION >= 100000
#include <fmt/std.h>
#endif
 
#define DEFAULT_IO_BUFFER_SIZE 1024
 
// Compiler-specific function macro.
// Ref: https://stackoverflow.com/a/4384825
#ifdef _WIN32
#define __FN__ __FUNCSIG__
#else
#define __FN__ __PRETTY_FUNCTION__
#endif
 
// Mimic "macro in namespace" by concatenating `utility::` and a macro.
// Ref: https://stackoverflow.com/a/11791202
//
// We avoid using (format, ...) since in this case __VA_ARGS__ can be
// empty, and the behavior of pruning trailing comma with ##__VA_ARGS__ is not
// officially standard.
// Ref: https://stackoverflow.com/a/28074198
//
// __PRETTY_FUNCTION__ has to be converted, otherwise a bug regarding [noreturn]
// will be triggered.
// Ref: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94742
 
// LogError throws now a runtime_error with the given error message. This
// should be used if there is no point in continuing the given algorithm at
// some point and the error is not returned in another way (e.g., via a
// bool/int as return value).
//
// Usage  : utility::LogError(format_string, arg0, arg1, ...);
// Example: utility::LogError("name: {}, age: {}", "dog", 5);
#define LogError(...)                                                        \
    Logger::LogError_(__FILE__, __LINE__, static_cast<const char *>(__FN__), \
                      __VA_ARGS__)
 
// LogWarning is used if an error occurs, but the error is also signaled
// via a return value (i.e., there is no need to throw an exception). This
// warning should further be used, if the algorithms encounters a state
// that does not break its continuation, but the output is likely not to be
// what the user expected.
//
// Usage  : utility::LogWarning(format_string, arg0, arg1, ...);
// Example: utility::LogWarning("name: {}, age: {}", "dog", 5);
#define LogWarning(...)                                                        \
    Logger::LogWarning_(__FILE__, __LINE__, static_cast<const char *>(__FN__), \
                        __VA_ARGS__)
 
// LogInfo is used to inform the user with expected output, e.g, pressed a
// key in the visualizer prints helping information.
//
// Usage  : utility::LogInfo(format_string, arg0, arg1, ...);
// Example: utility::LogInfo("name: {}, age: {}", "dog", 5);
#define LogInfo(...)                                                        \
    Logger::LogInfo_(__FILE__, __LINE__, static_cast<const char *>(__FN__), \
                     __VA_ARGS__)
 
// LogDebug is used to print debug/additional information on the state of
// the algorithm.
//
// Usage  : utility::LogDebug(format_string, arg0, arg1, ...);
// Example: utility::LogDebug("name: {}, age: {}", "dog", 5);
#define LogDebug(...)                                                        \
    Logger::LogDebug_(__FILE__, __LINE__, static_cast<const char *>(__FN__), \
                      __VA_ARGS__)
 
namespace cloudViewer {
namespace utility {
 
enum class CV_CORE_LIB_API VerbosityLevel {
    Error = 0,
    Warning = 1,
    Info = 2,
    Debug = 3,
};
 
enum class CV_CORE_LIB_API TextColor {
    Black = 0,
    Red = 1,
    Green = 2,
    Yellow = 3,
    Blue = 4,
    Magenta = 5,
    Cyan = 6,
    White = 7
};
 
class CV_CORE_LIB_API Logger {
public:
    struct CV_CORE_LIB_API Impl {
        // The current print function.
        std::function<void(const std::string &)> print_fcn_;
 
        // The default print function (that prints to console).
        static std::function<void(const std::string &)> console_print_fcn_;
 
        // Verbosity level.
        VerbosityLevel verbosity_level_;
 
        // Colorize and reset the color of a string, does not work on Windows,
        std::string ColorString(const std::string &text,
                                TextColor text_color,
                                int highlight_text) const {
            std::ostringstream msg;
#ifndef _WIN32
            msg << fmt::sprintf("%c[%d;%dm", 0x1B, highlight_text,
                                (int)text_color + 30);
#endif
            msg << text;
#ifndef _WIN32
            msg << fmt::sprintf("%c[0;m", 0x1B);
#endif
            return msg.str();
        }
    };
 
public:
    Logger(Logger const &) = delete;
    void operator=(Logger const &) = delete;
 
    static Logger &GetInstance();
 
    void SetPrintFunction(std::function<void(const std::string &)> print_fcn);
 
    void ResetPrintFunction();
 
    const std::function<void(const std::string &)> GetPrintFunction();
 
    void SetVerbosityLevel(VerbosityLevel verbosity_level);
 
    VerbosityLevel GetVerbosityLevel() const;
 
    template <typename... Args>
    static void LogError_ [[noreturn]] (const char *file,
                                        int line,
                                        const char *function,
                                        const char *format,
                                        Args &&...args) {
        if (sizeof...(Args) > 0) {
            Logger::GetInstance().VError(
                    file, line, function,
                    FormatArgs(format, fmt::make_format_args(args...)));
        } else {
            Logger::GetInstance().VError(file, line, function,
                                         std::string(format));
        }
    }
    template <typename... Args>
    static void LogWarning_(const char *file,
                            int line,
                            const char *function,
                            const char *format,
                            Args &&...args) {
        if (Logger::GetInstance().GetVerbosityLevel() >=
            VerbosityLevel::Warning) {
            if (sizeof...(Args) > 0) {
                Logger::GetInstance().VWarning(
                        file, line, function,
                        FormatArgs(format, fmt::make_format_args(args...)));
            } else {
                Logger::GetInstance().VWarning(file, line, function,
                                               std::string(format));
            }
        }
    }
    template <typename... Args>
    static void LogInfo_(const char *file,
                         int line,
                         const char *function,
                         const char *format,
                         Args &&...args) {
        if (Logger::GetInstance().GetVerbosityLevel() >= VerbosityLevel::Info) {
            if (sizeof...(Args) > 0) {
                Logger::GetInstance().VInfo(
                        file, line, function,
                        FormatArgs(format, fmt::make_format_args(args...)));
            } else {
                Logger::GetInstance().VInfo(file, line, function,
                                            std::string(format));
            }
        }
    }
    template <typename... Args>
    static void LogDebug_(const char *file,
                          int line,
                          const char *function,
                          const char *format,
                          Args &&...args) {
        if (Logger::GetInstance().GetVerbosityLevel() >=
            VerbosityLevel::Debug) {
            if (sizeof...(Args) > 0) {
                Logger::GetInstance().VDebug(
                        file, line, function,
                        FormatArgs(format, fmt::make_format_args(args...)));
            } else {
                Logger::GetInstance().VDebug(file, line, function,
                                             std::string(format));
            }
        }
    }
 
private:
    Logger();
    static std::string FormatArgs(const char *format, fmt::format_args args) {
        std::string err_msg = fmt::vformat(format, args);
        return err_msg;
    }
    void VError [[noreturn]] (const char *file,
                              int line,
                              const char *function,
                              const std::string &message) const;
    void VWarning(const char *file,
                  int line,
                  const char *function,
                  const std::string &message) const;
    void VInfo(const char *file,
               int line,
               const char *function,
               const std::string &message) const;
    void VDebug(const char *file,
                int line,
                const char *function,
                const std::string &message) const;
 
private:
    std::unique_ptr<Impl> impl_;
};
 
void CV_CORE_LIB_API SetVerbosityLevel(VerbosityLevel level);
 
VerbosityLevel CV_CORE_LIB_API GetVerbosityLevel();
 
class CV_CORE_LIB_API VerbosityContextManager {
public:
    VerbosityContextManager(VerbosityLevel level) : level_(level) {}
 
    void Enter() {
        level_backup_ = Logger::GetInstance().GetVerbosityLevel();
        Logger::GetInstance().SetVerbosityLevel(level_);
    }
 
    void Exit() { Logger::GetInstance().SetVerbosityLevel(level_backup_); }
 
private:
    VerbosityLevel level_;
    VerbosityLevel level_backup_;
};
 
class CV_CORE_LIB_API ConsoleProgressBar {
public:
    ConsoleProgressBar(size_t expected_count,
                       const std::string &progress_info,
                       bool active = false);
 
    void reset(size_t expected_count,
               const std::string &progress_info,
               bool active);
 
    ConsoleProgressBar &operator++();
 
    void setCurrentCount(size_t n);
 
private:
    const size_t resolution_ = 40;
    size_t expected_count_;
    size_t current_count_;
    std::string progress_info_;
    size_t progress_pixel_;
    bool active_;
};
 
}  // namespace utility
}  // namespace cloudViewer