Initial commit

include/okapi/api/util/logging.hpp

@@ -0,0 +1,192 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+#pragma once
+
+#include "okapi/api/coreProsAPI.hpp"
+#include "okapi/api/util/abstractTimer.hpp"
+#include "okapi/api/util/mathUtil.hpp"
+#include <memory>
+#include <mutex>
+
+#if defined(THREADS_STD)
+#else
+#include "okapi/impl/util/timer.hpp"
+#endif
+
+#define LOG_DEBUG(msg) logger->debug([=]() { return msg; })
+#define LOG_INFO(msg) logger->info([=]() { return msg; })
+#define LOG_WARN(msg) logger->warn([=]() { return msg; })
+#define LOG_ERROR(msg) logger->error([=]() { return msg; })
+
+#define LOG_DEBUG_S(msg) LOG_DEBUG(std::string(msg))
+#define LOG_INFO_S(msg) LOG_INFO(std::string(msg))
+#define LOG_WARN_S(msg) LOG_WARN(std::string(msg))
+#define LOG_ERROR_S(msg) LOG_ERROR(std::string(msg))
+
+namespace okapi {
+class Logger {
+  public:
+  enum class LogLevel {
+    debug = 4, ///< debug
+    info = 3,  ///< info
+    warn = 2,  ///< warn
+    error = 1, ///< error
+    off = 0    ///< off
+  };
+
+  /**
+   * A logger that does nothing.
+   */
+  Logger() noexcept;
+
+  /**
+   * A logger that opens the input file by name. If the file contains `/ser/`, the file will be
+   * opened in write mode. Otherwise, the file will be opened in append mode. The file will be
+   * closed when the logger is destructed.
+   *
+   * @param itimer A timer used to get the current time for log statements.
+   * @param ifileName The name of the log file to open.
+   * @param ilevel The log level. Log statements more verbose than this level will be disabled.
+   */
+  Logger(std::unique_ptr<AbstractTimer> itimer,
+         std::string_view ifileName,
+         const LogLevel &ilevel) noexcept;
+
+  /**
+   * A logger that uses an existing file handle. The file will be closed when the logger is
+   * destructed.
+   *
+   * @param itimer A timer used to get the current time for log statements.
+   * @param ifile The log file to open. Will be closed by the logger!
+   * @param ilevel The log level. Log statements more verbose than this level will be disabled.
+   */
+  Logger(std::unique_ptr<AbstractTimer> itimer, FILE *ifile, const LogLevel &ilevel) noexcept;
+
+  ~Logger();
+
+  constexpr bool isDebugLevelEnabled() const noexcept {
+    return toUnderlyingType(logLevel) >= toUnderlyingType(LogLevel::debug);
+  }
+
+  template <typename T> void debug(T ilazyMessage) noexcept {
+    if (isDebugLevelEnabled() && logfile && timer) {
+      std::scoped_lock lock(logfileMutex);
+      fprintf(logfile,
+              "%ld (%s) DEBUG: %s\n",
+              static_cast<long>(timer->millis().convert(millisecond)),
+              CrossplatformThread::getName().c_str(),
+              ilazyMessage().c_str());
+    }
+  }
+
+  constexpr bool isInfoLevelEnabled() const noexcept {
+    return toUnderlyingType(logLevel) >= toUnderlyingType(LogLevel::info);
+  }
+
+  template <typename T> void info(T ilazyMessage) noexcept {
+    if (isInfoLevelEnabled() && logfile && timer) {
+      std::scoped_lock lock(logfileMutex);
+      fprintf(logfile,
+              "%ld (%s) INFO: %s\n",
+              static_cast<long>(timer->millis().convert(millisecond)),
+              CrossplatformThread::getName().c_str(),
+              ilazyMessage().c_str());
+    }
+  }
+
+  constexpr bool isWarnLevelEnabled() const noexcept {
+    return toUnderlyingType(logLevel) >= toUnderlyingType(LogLevel::warn);
+  }
+
+  template <typename T> void warn(T ilazyMessage) noexcept {
+    if (isWarnLevelEnabled() && logfile && timer) {
+      std::scoped_lock lock(logfileMutex);
+      fprintf(logfile,
+              "%ld (%s) WARN: %s\n",
+              static_cast<long>(timer->millis().convert(millisecond)),
+              CrossplatformThread::getName().c_str(),
+              ilazyMessage().c_str());
+    }
+  }
+
+  constexpr bool isErrorLevelEnabled() const noexcept {
+    return toUnderlyingType(logLevel) >= toUnderlyingType(LogLevel::error);
+  }
+
+  template <typename T> void error(T ilazyMessage) noexcept {
+    if (isErrorLevelEnabled() && logfile && timer) {
+      std::scoped_lock lock(logfileMutex);
+      fprintf(logfile,
+              "%ld (%s) ERROR: %s\n",
+              static_cast<long>(timer->millis().convert(millisecond)),
+              CrossplatformThread::getName().c_str(),
+              ilazyMessage().c_str());
+    }
+  }
+
+  /**
+   * Closes the connection to the log file.
+   */
+  constexpr void close() noexcept {
+    if (logfile) {
+      fclose(logfile);
+      logfile = nullptr;
+    }
+  }
+
+  /**
+   * @return The default logger.
+   */
+  static std::shared_ptr<Logger> getDefaultLogger();
+
+  /**
+   * Sets a new default logger. OkapiLib classes use the default logger unless given another logger
+   * in their constructor.
+   *
+   * @param ilogger The new logger instance.
+   */
+  static void setDefaultLogger(std::shared_ptr<Logger> ilogger);
+
+  private:
+  const std::unique_ptr<AbstractTimer> timer;
+  const LogLevel logLevel;
+  FILE *logfile;
+  CrossplatformMutex logfileMutex;
+
+  static bool isSerialStream(std::string_view filename);
+};
+
+extern std::shared_ptr<Logger> defaultLogger;
+
+struct DefaultLoggerInitializer {
+  DefaultLoggerInitializer() {
+    if (count++ == 0) {
+      init();
+    }
+  }
+  ~DefaultLoggerInitializer() {
+    if (--count == 0) {
+      cleanup();
+    }
+  }
+
+  static int count;
+
+  static void init() {
+#if defined(THREADS_STD)
+    defaultLogger = std::make_shared<Logger>();
+#else
+    defaultLogger =
+      std::make_shared<Logger>(std::make_unique<Timer>(), "/ser/sout", Logger::LogLevel::warn);
+#endif
+  }
+
+  static void cleanup() {
+  }
+};
+
+static DefaultLoggerInitializer defaultLoggerInitializer; // NOLINT(cert-err58-cpp)
+} // namespace okapi