CVLog.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include "CVLog.h"
 
// CV_CORE_lib
#include <CVPlatform.h>
 
// System
#include <algorithm>
#include <cassert>
#include <vector>
 
#if !defined(CV_WINDOWS)
#define _vsnprintf vsnprintf
#endif
 
/***************
 *** Globals ***
 ***************/
 
// buffer for formatted string generation
static const size_t s_bufferMaxSize = 4096;
static char s_buffer[s_bufferMaxSize];
 
struct Message {
    Message(const QString& t, int f) : text(t), flags(f) {}
 
    QString text;
    int flags;
};
 
// message backup system
static bool s_backupEnabled;
// backuped messages
static std::vector<Message> s_backupMessages;
 
// message verbosity level
#ifdef QT_DEBUG
static int s_verbosityLevel = CVLog::LOG_VERBOSE;
#else
static int s_verbosityLevel = CVLog::LOG_STANDARD;
#endif
 
// unique console instance
static CVLog* s_instance = nullptr;
 
CVLog* CVLog::TheInstance() { return s_instance; }
 
void CVLog::EnableMessageBackup(bool state) { s_backupEnabled = state; }
 
int CVLog::VerbosityLevel() { return s_verbosityLevel; }
 
void CVLog::SetVerbosityLevel(int level) {
    s_verbosityLevel = std::min(
            level, static_cast<int>(LOG_ERROR));  // can't ignore error messages
}
 
void CVLog::LogMessage(const QString& message, int level) {
    // skip messages below the current 'verbosity' level
    if ((level & 7) < s_verbosityLevel) {
        return;
    }
 
    if (s_instance) {
        s_instance->logMessage(message, level);
    } else if (s_backupEnabled) {
        try {
            s_backupMessages.emplace_back(message, level);
        } catch (const std::bad_alloc&) {
            // nothing to do, the message will be lost...
        }
    }
}
 
void CVLog::RegisterInstance(CVLog* logInstance) {
    s_instance = logInstance;
    if (s_instance) {
        // if we have a valid instance, we can now flush the backuped messages
        for (const Message& message : s_backupMessages) {
            s_instance->logMessage(message.text, message.flags);
        }
        s_backupMessages.clear();
    }
}
 
// Conversion from '...' parameters to QString so as to call CVLog::logMessage
//(we get the "..." parameters as "printf" would do)
#define LOG_ARGS(flags)                                      \
    if (s_instance || s_backupEnabled) {                     \
        va_list args;                                        \
        va_start(args, format);                              \
        _vsnprintf(s_buffer, s_bufferMaxSize, format, args); \
        va_end(args);                                        \
        LogMessage(QString(s_buffer), flags);                \
    }
 
bool CVLog::PrintVerbose(const char* format, ...) {
    LOG_ARGS(LOG_VERBOSE)
    return true;
}
 
bool CVLog::PrintVerbose(const QString& message) {
    LogMessage(message, LOG_VERBOSE);
    return true;
}
 
bool CVLog::Print(const char* format, ...) {
    LOG_ARGS(LOG_STANDARD)
    return true;
}
 
bool CVLog::Print(const QString& message) {
    LogMessage(message, LOG_STANDARD);
    return true;
}
 
bool CVLog::PrintHigh(const char* format, ...) {
    LOG_ARGS(LOG_IMPORTANT)
    return true;
}
 
bool CVLog::PrintHigh(const QString& message) {
    LogMessage(message, LOG_IMPORTANT);
    return true;
}
 
bool CVLog::Warning(const char* format, ...) {
    LOG_ARGS(LOG_WARNING)
    return false;
}
 
bool CVLog::Warning(const QString& message) {
    LogMessage(message, LOG_WARNING);
    return false;
}
 
bool CVLog::Error(const char* format, ...) {
    LOG_ARGS(LOG_ERROR)
    return false;
}
 
bool CVLog::Error(const QString& message) {
    LogMessage(message, LOG_ERROR);
    return false;
}
 
bool CVLog::PrintDebug(const char* format, ...) {
#ifdef QT_DEBUG
    LOG_ARGS(LOG_STANDARD | DEBUG_FLAG)
#endif
    return true;
}
 
bool CVLog::PrintDebug(const QString& message) {
#ifdef QT_DEBUG
    LogMessage(message, LOG_STANDARD | DEBUG_FLAG);
#endif
    return false;
}
 
bool CVLog::WarningDebug(const char* format, ...) {
#ifdef QT_DEBUG
    LOG_ARGS(LOG_WARNING | DEBUG_FLAG)
#endif
    return false;
}
 
bool CVLog::WarningDebug(const QString& message) {
#ifdef QT_DEBUG
    LogMessage(message, LOG_WARNING | DEBUG_FLAG);
#endif
    return false;
}
 
bool CVLog::ErrorDebug(const char* format, ...) {
#ifdef QT_DEBUG
    LOG_ARGS(LOG_ERROR | DEBUG_FLAG)
#endif
    return false;
}
 
bool CVLog::ErrorDebug(const QString& message) {
#ifdef QT_DEBUG
    LogMessage(message, LOG_ERROR | DEBUG_FLAG);
#endif
    return false;
}