RMGLog.hh

// Copyright (C) 2022 Luigi Pertoldi <https://orcid.org/0000-0002-0467-2571>
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option) any
// later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 
// Modified by Luigi Pertoldi <https://orcid.org/0000-0002-0467-2571> in 2022
 
#ifndef _RMG_LOG_HH_
#define _RMG_LOG_HH_

 
/*
 * Copyright (C) 2007-2018, the BAT core developer team
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 * For documentation see http://mpp.mpg.de/bat
 */
 
// ---------------------------------------------------------
 
#include <atomic>
#include <fstream>
#include <iostream>
#include <string>
 
#include "globals.hh"
 
#include "fmt/core.h"
 
#define OutDev(loglevel, ...) RMGLog::Out(loglevel, "[", __PRETTY_FUNCTION__, "] ", __VA_ARGS__)
 
#define OutFormatDev(loglevel, fmt, ...)                                                           \
  RMGLog::OutFormat(loglevel, "[" + std::string(__PRETTY_FUNCTION__) + "] " + fmt, __VA_ARGS__)
 
// ---------------------------------------------------------
 
class RMGLog {
 
  public:
 
    // definition of log level

    enum LogLevel {
      debug_event = 0, 
      debug = 10,      
      detail = 20,     
      summary = 30,    
      warning = 40,    
      error = 50,      
      fatal = 60,      
      nothing = 70     
    };
 
    enum Ansi {
      black = 30,
      red = 31,
      green = 32,
      yellow = 33,
      blue = 34,
      magenta = 35,
      cyan = 36,
      grey = 37,
      unspecified
    };


    RMGLog();


    static RMGLog::LogLevel GetLogLevel() { return fMinimumLogLevel; }

    static bool GetPrefix() { return fUsePrefix; }


    static void SetLogLevel(RMGLog::LogLevel loglevel) { fMinimumLogLevel = loglevel; }

    static void SetPrefix(bool flag) { fUsePrefix = flag; }

    static void SetProcNum(int proc_num) { fProcNum = proc_num; }

    static void SetInihibitStartupInfo(bool flag) { fFirstOutputDone = flag; }


    template<typename T> static void Out(RMGLog::LogLevel loglevel, const T& message);
 
    template<typename T, typename... Args>
    static void Out(RMGLog::LogLevel loglevel, const T& msg_first, const Args&... args);
 
    template<typename... Args>
    static void OutFormat(RMGLog::LogLevel loglevel, const std::string& fmt, const Args&... args);
 
    template<typename T, typename... Args>
    static void Out(RMGLog::LogLevel loglevel, T& msg_first, Args... msg_other) {
      RMGLog::Out(loglevel, msg_first, msg_other...);
    }

    static void StartupInfo();

    static const std::string& GetVersion() { return fVersion; }
 
    static bool SupportsColors(const std::ostream& os);
 
    template<RMGLog::Ansi color, typename T>
    static std::string Colorize(const T& msg, std::ostream& os, bool bold = false);
 
    static bool HadWarning() { return fHadWarning; }
    static bool HadError() { return fHadError; }

 
  private:
 
    template<typename T>
    static void Print(RMGLog::LogLevel loglevel, const T& msg, bool prefixed = true, bool do_flush = true);

    static std::string GetPrefix(RMGLog::LogLevel, std::ostream& os);

    static bool ShouldPrintWithLevel(RMGLog::LogLevel loglevel);

    static std::string fVersion;

    static RMGLog::LogLevel fMinimumLogLevel;

    static std::atomic<bool> fFirstOutputDone;

    static std::atomic<bool> fHadWarning;

    static std::atomic<bool> fHadError;

    static bool fUsePrefix;

    static int fProcNum;
};
 
#include "RMGLog.icc"
 
#endif
 
// vim: tabstop=2 shiftwidth=2 expandtab