logger.h

Go to the documentation of this file.

/*=========================================================================

  Project:   AtilaCalculatorSoftware
  File:      logger.h

  Copyright (c) 2020 - All rights reserved
  Distributed under the MIT License (https://opensource.org/licenses/MIT)

=========================================================================*/
#pragma once
#ifndef ATILACALCULATORSOFTWARE_LOGGER_H
#define ATILACALCULATORSOFTWARE_LOGGER_H

#include "common.h"
#include "core/utilities.h"
#include "log_entries.h"

#include <ctime>
#include <fstream>
#include <iomanip>
#include <map>
#include <regex>
#include <set>
#include <sstream>
#include <string>
#include <vector>

class LogMetaData {
  public:
    explicit LogMetaData(LogLevel level, time_t timestamp = time(nullptr));

    LogLevel getLogLevel();

    time_t getTimestamp() const;

  private:
    LogLevel level;

    time_t timestamp;
};

class Logger {
  public:
    Logger(const Logger& logger);


    ~Logger();

    Logger& operator=(const Logger& logger);

    size_t
    log(const std::string& message, LogLevel level = Debug, time_t timestamp = time(nullptr));

    static std::string getEncodedLogLevel(LogLevel level);

    static std::string formatInt(const int& value, int size);

    static std::string formatEncodedLogLevel(const std::string& str, LogLevel level);

    static std::string formatTime(std::string str, time_t timestamp, tm* t);

    static std::string format(LogMetaData metaData,
                              const std::string& message,
                              const std::string& format = Logger::getLoggingFormat());

    static Logger* getInstance();

    static LogEntries* getLogs();

    static std::string getLoggingFormat();

    static std::string getDefaultLoggingFormat();

    static void setVerbosity(bool verbosity);

    static void setVerboseLevel(LogLevel level);

    static void setVerboseLevelRange(LogLevel lowest, LogLevel highest);

    static void setVerboseLevels(std::set<LogLevel> levels);

    static void logToFile(const std::string& filename, bool legacy = true);

    static void setFileLogging(bool value);

    static void setLoggingFormat(std::string format);

    static size_t trace_s(const std::string& message);

    template<typename... TArgs> static size_t trace(TArgs const&... args) {
        return Logger::trace_s(concat(args...));
    }

    static size_t debug_s(const std::string& message);

    template<typename... TArgs> static size_t debug(TArgs const&... args) {
        return Logger::debug_s(concat(args...));
    }

    static size_t info_s(const std::string& message);

    template<typename... TArgs> static size_t info(TArgs const&... args) {
        return Logger::info_s(concat(args...));
    }

    static size_t warn_s(const std::string& message);

    template<typename... TArgs> static size_t warn(TArgs const&... args) {
        return Logger::warn_s(concat(args...));
    }

    static size_t error_s(const std::string& message);

    template<typename... TArgs> static size_t error(TArgs const&... args) {
        return Logger::error_s(concat(args...));
    }

    static size_t fatal_s(const std::string& message);

    template<typename... TArgs> static size_t fatal(TArgs const&... args) {
        return Logger::fatal_s(concat(args...));
    }

    static size_t addEntryListener(entry_listener listener);

  private:
    Logger();

    LogEntries* entries;

    bool verbose;

    std::set<LogLevel> verbosityLevels;

    bool fileLogging;

    std::ofstream loggingFile;

    std::vector<entry_listener> listeners;

    static LogTimeMode timeMode;

    static std::string logFormat;

    static std::string defaultLogFormat;

    static Logger* instance;
};

#endif // ATILACALCULATORSOFTWARE_LOGGER_H