Updated README.md

Merge remote-tracking branch 'origin/main'
Rewritten most functionality to be more generic and flexible. Cleaned up code as well. Implemented formatter system for easier wrapping. Made it easier for custom loggers to be built from jlog generics and primitives. Removed unused ultra short and short loggers to remove clutter.
2024-06-19 11:26:53 -04:00 · 2024-06-19 11:25:01 -04:00 · 2024-06-19 11:23:57 -04:00 · 2024-06-18 21:49:22 -04:00 · 2024-06-18 14:40:31 -04:00 · 2024-06-18 12:11:41 -04:00
7 changed files with 241 additions and 410 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -48,7 +48,7 @@ install(FILES ${jlog_HEADERS} DESTINATION include/${PROJECT_NAME})

 #add_subdirectory(tests)

-target_link_libraries(jlog PUBLIC Event)
+target_link_libraries(jlog PRIVATE Event)

 add_executable(LoggerDemo main.cpp)
 target_link_libraries(LoggerDemo PUBLIC ${PROJECT_NAME})
--- a/README.md
+++ b/README.md
@@ -15,12 +15,11 @@ jlog is a C++ library for logging to file, console, and event callbacks.
 ## Installation

 Include this repository as a CPM dependency, and link against the library.
-(TODO: Show the relevant CMake script lines.)

 ```cmake
 CPMAddPackage(
        NAME jlog
-        URL https://git.redacted.cc/josh/jlog/archive/Prerelease-2.zip
+        URL https://git.redacted.cc/josh/jlog/archive/Prerelease-7.zip
 )
 # ...
 include_directories(${jlog_SOURCE_DIR}/include)
@@ -37,6 +36,8 @@ Using jlog is straightforward:
 #include <jlog.h>

 int main() {
+    LOGLEVEL(jlog::severity::debug); // <- see jlog::severity for full list of log levels
+
    INFO("This is barely useful information.");
    DEBUG("Debugging Information");
    VERBOSE("Yadda Yadda Yadda");
@@ -57,12 +58,10 @@ int main() {

 * Custom Contexts: Allow users to specify custom logging contexts for better organization.
  * Disable & sort by context (other categories?)
-* Custom Formats: Add support for custom log message formats.
 * Documentation
 * Thread Safety
 * Memory Safety
 * Stream Support
-* Identify File, Line, Function name via macros (I hate macros!!!)

 ## License

--- a/include/jlog/ansi_escape_codes.hpp
+++ b/include/jlog/ansi_escape_codes.hpp
@@ -37,101 +37,101 @@ namespace jlog::ansi_escape_codes
 #else
 namespace jlog::ansi_escape_codes
 {
-    static const std::string CURSOR_HOME = "\033[H";
+    inline static const std::string CURSOR_HOME = "\033[H";

-    static const std::string ERASE_SCREEN_AFTER_CURSOR = "\033[0J";
-    static const std::string ERASE_SCREEN_BEFORE_CURSOR = "\033[1J";
-    static const std::string ERASE_SCREEN_ALL = "\033[2J";
-    static const std::string ERASE_LINE_AFTER_CURSOR = "\033[0K";
-    static const std::string ERASE_LINE_BEFORE_CURSOR = "\033[1K";
-    static const std::string ERASE_LINE_ALL = "\033[2K";
+    inline static const std::string ERASE_SCREEN_AFTER_CURSOR = "\033[0J";
+    inline static const std::string ERASE_SCREEN_BEFORE_CURSOR = "\033[1J";
+    inline static const std::string ERASE_SCREEN_ALL = "\033[2J";
+    inline static const std::string ERASE_LINE_AFTER_CURSOR = "\033[0K";
+    inline static const std::string ERASE_LINE_BEFORE_CURSOR = "\033[1K";
+    inline static const std::string ERASE_LINE_ALL = "\033[2K";

-    static const std::string RESET = "\033[0m";
-    static const std::string BOLD  = "\033[1m";
-    static const std::string DIM   = "\033[2m";
+    inline static const std::string RESET = "\033[0m";
+    inline static const std::string BOLD  = "\033[1m";
+    inline static const std::string DIM   = "\033[2m";

    /// These are some examples of private modes, which are not defined by the spec, but are implemented in most terminals.
    /// @see xterm control sequences for a more in-depth list.
    /// https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
    /// @note While these modes may be supported by most terminals, some may not work in multiplexers like tmux.

-    static const std::string CURSOR_INVISIBLE = "\033[?25l";
-    static const std::string CURSOR_VISIBLE   = "\033[?25h";
-    static const std::string RESTORE_SCREEN   = "\033[?47l";
-    static const std::string SAVE_SCREEN      = "\033[?47h";
+    inline static const std::string CURSOR_INVISIBLE = "\033[?25l";
+    inline static const std::string CURSOR_VISIBLE   = "\033[?25h";
+    inline static const std::string RESTORE_SCREEN   = "\033[?47l";
+    inline static const std::string SAVE_SCREEN      = "\033[?47h";


-    static const std::string FG_BLACK = "\033[30m";
-    static const std::string FG_RED = "\033[31m";
-    static const std::string FG_GREEN = "\033[32m";
-    static const std::string FG_YELLOW = "\033[33m";
-    static const std::string FG_BLUE = "\033[34m";
-    static const std::string FG_MAGENTA = "\033[35m";
-    static const std::string FG_CYAN = "\033[36m";
-    static const std::string FG_WHITE = "\033[37m";
-    static const std::string FG_DEFAULT = "\033[39m";
+    inline static const std::string FG_BLACK = "\033[30m";
+    inline static const std::string FG_RED = "\033[31m";
+    inline static const std::string FG_GREEN = "\033[32m";
+    inline static const std::string FG_YELLOW = "\033[33m";
+    inline static const std::string FG_BLUE = "\033[34m";
+    inline static const std::string FG_MAGENTA = "\033[35m";
+    inline static const std::string FG_CYAN = "\033[36m";
+    inline static const std::string FG_WHITE = "\033[37m";
+    inline static const std::string FG_DEFAULT = "\033[39m";


-    static const std::string FG_BRIGHT_BLACK = "\033[90m";
-    static const std::string FG_BRIGHT_RED = "\033[91m";
-    static const std::string FG_BRIGHT_GREEN = "\033[92m";
-    static const std::string FG_BRIGHT_YELLOW = "\033[93m";
-    static const std::string FG_BRIGHT_BLUE = "\033[94m";
-    static const std::string FG_BRIGHT_MAGENTA = "\033[95m";
-    static const std::string FG_BRIGHT_CYAN = "\033[96m";
-    static const std::string FG_BRIGHT_WHITE = "\033[97m";
+    inline static const std::string FG_BRIGHT_BLACK = "\033[90m";
+    inline static const std::string FG_BRIGHT_RED = "\033[91m";
+    inline static const std::string FG_BRIGHT_GREEN = "\033[92m";
+    inline static const std::string FG_BRIGHT_YELLOW = "\033[93m";
+    inline static const std::string FG_BRIGHT_BLUE = "\033[94m";
+    inline static const std::string FG_BRIGHT_MAGENTA = "\033[95m";
+    inline static const std::string FG_BRIGHT_CYAN = "\033[96m";
+    inline static const std::string FG_BRIGHT_WHITE = "\033[97m";


-    static const std::string BG_BLACK = "\033[40m";
-    static const std::string BG_RED   = "\033[41m";
-    static const std::string BG_GREEN = "\033[42m";
-    static const std::string BG_YELLOW = "\033[43m";
-    static const std::string BG_BLUE = "\033[44m";
-    static const std::string BG_MAGENTA = "\033[45m";
-    static const std::string BG_CYAN = "\033[46m";
-    static const std::string BG_WHITE = "\033[47m";
-    static const std::string BG_DEFAULT = "\033[49m";
+    inline static const std::string BG_BLACK = "\033[40m";
+    inline static const std::string BG_RED   = "\033[41m";
+    inline static const std::string BG_GREEN = "\033[42m";
+    inline static const std::string BG_YELLOW = "\033[43m";
+    inline static const std::string BG_BLUE = "\033[44m";
+    inline static const std::string BG_MAGENTA = "\033[45m";
+    inline static const std::string BG_CYAN = "\033[46m";
+    inline static const std::string BG_WHITE = "\033[47m";
+    inline static const std::string BG_DEFAULT = "\033[49m";

-    static const std::string BG_BRIGHT_BLACK = "\033[100m";
-    static const std::string BG_BRIGHT_RED = "\033[101m";
-    static const std::string BG_BRIGHT_GREEN = "\033[102m";
-    static const std::string BG_BRIGHT_YELLOW = "\033[103m";
-    static const std::string BG_BRIGHT_BLUE = "\033[104m";
-    static const std::string BG_BRIGHT_MAGENTA = "\033[105m";
-    static const std::string BG_BRIGHT_CYAN = "\033[106m";
-    static const std::string BG_BRIGHT_WHITE = "\033[107m";
+    inline static const std::string BG_BRIGHT_BLACK = "\033[100m";
+    inline static const std::string BG_BRIGHT_RED = "\033[101m";
+    inline static const std::string BG_BRIGHT_GREEN = "\033[102m";
+    inline static const std::string BG_BRIGHT_YELLOW = "\033[103m";
+    inline static const std::string BG_BRIGHT_BLUE = "\033[104m";
+    inline static const std::string BG_BRIGHT_MAGENTA = "\033[105m";
+    inline static const std::string BG_BRIGHT_CYAN = "\033[106m";
+    inline static const std::string BG_BRIGHT_WHITE = "\033[107m";

-    std::string true_color(uint8_t r, uint8_t g, uint8_t b)
+    inline std::string true_color(uint8_t r, uint8_t g, uint8_t b)
    {
        return std::format("\033[38;2;{};{};{}m", r, g, b);
    }

-    std::string cursor_to(int line, int col)
+    inline std::string cursor_to(int line, int col)
    {
        return "";
    }

-    std::string cursor_up(int lines)
+    inline std::string cursor_up(int lines)
    {
        return "";
    }

-    std::string cursor_down(int lines)
+    inline std::string cursor_down(int lines)
    {
        return "";
    }

-    std::string cursor_left(int cols)
+    inline std::string cursor_left(int cols)
    {
        return "";
    }

-    std::string cursor_right(int cols)
+    inline std::string cursor_right(int cols)
    {
        return "";
    }

-    std::string cursor_to_col(int col)
+    inline std::string cursor_to_col(int col)
    {
        return "";
    }
--- a/include/jlog/jlog.hpp
+++ b/include/jlog/jlog.hpp
@@ -25,16 +25,18 @@

 namespace jlog
 {
-    enum class severity
+    enum class severity : uint8_t
    {
        none,
-        verbose,
-        debug,
        warning,
        error,
-        fatal
+        fatal,
+        verbose,
+        debug,
    };

+    inline severity loglevel = severity::debug; // Default log level always debug
+
    struct LogEntry
    {
        severity level;
@@ -63,75 +65,85 @@ namespace jlog

    void log(std::vector<token> tokens);

-    void info(const std::string& message);
-    void sinfo(const std::string& message);
-    void usinfo(const std::string& message);
+    // Generic formatters for building loggers.
+    std::vector<token> trace_format(
+        const std::string& func,
+        const std::string& file,
+        int line);

-    void verbose(const std::string& message);
-    void sverbose(const std::string& message);
-    void usverbose(const std::string& message);
+    std::vector<token> log_format(
+        const std::string& severity_name,
+        const std::string& message,
+        const std::string& severity_colorCode = ansi_escape_codes::FG_WHITE);

-    void debug(const std::string& message);
-    void sdebug(const std::string& message);
-    void usdebug(const std::string& message);
+    std::vector<token> log_detailed_format(
+    const std::string& severity_name,
+    const std::string& message,
+    const std::string& func,
+    const std::string& file,
+    int line,
+    const std::string& severity_colorCode = ansi_escape_codes::FG_WHITE);

-    void warning(const std::string& message);
-    void swarning(const std::string& message);
-    void uswarning(const std::string& message);
+    // Predefined generic loggers for jlog.
+    std::vector<token> info_format(const std::string& message);

-    void error(const std::string& message);
-    void serror(const std::string& message);
-    void userror(const std::string& message);
+    std::vector<token> info_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line);

-    void fatal(const std::string& message);
-    void sfatal(const std::string& message);
-    void usfatal(const std::string& message);
+    std::vector<token> warning_format(const std::string& message);

-    void info_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void sinfo_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void usinfo_spec(const std::string& message, const std::string& func, const std::string& file, int line);
+    std::vector<token> warning_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line);

-    void verbose_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void sverbose_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void usverbose_spec(const std::string& message, const std::string& func, const std::string& file, int line);
+    std::vector<token> error_format(const std::string& message);

-    void debug_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void sdebug_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void usdebug_spec(const std::string& message, const std::string& func, const std::string& file, int line);
+    std::vector<token> error_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line);

-    void warning_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void swarning_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void uswarning_spec(const std::string& message, const std::string& func, const std::string& file, int line);
+    std::vector<token> fatal_format(const std::string& message);

-    void error_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void serror_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void userror_spec(const std::string& message, const std::string& func, const std::string& file, int line);
+    std::vector<token> fatal_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line);

-    void fatal_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void sfatal_spec(const std::string& message, const std::string& func, const std::string& file, int line);
-    void usfatal_spec(const std::string& message, const std::string& func, const std::string& file, int line);
+    std::vector<token> verbose_format(const std::string& message);
+
+    std::vector<token> verbose_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line);
+
+    std::vector<token> debug_format(const std::string& message);
+
+    std::vector<token> debug_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line);
 }

-#define INFO(i)    jlog::info_spec(i, FUNCTION, __FILE__, __LINE__);
-#define SINFO(i)   jlog::sinfo_spec(i, FUNCTION, __FILE__, __LINE__);
-#define USINFO(i)   jlog::usinfo_spec(i, FUNCTION, __FILE__, __LINE__);
+#define INFO(i)    if (jlog::loglevel >= jlog::severity::none) { jlog::log(jlog::info_detailed_format(i, FUNCTION, __FILE__, __LINE__)); };

-#define VERBOSE(i) jlog::verbose_spec(i, FUNCTION, __FILE__, __LINE__);
-#define SVERBOSE(i) jlog::sverbose_spec(i, FUNCTION, __FILE__, __LINE__);
-#define USVERBOSE(i) jlog::usverbose_spec(i, FUNCTION, __FILE__, __LINE__);
+#define VERBOSE(i) if (jlog::loglevel >= jlog::severity::verbose) { jlog::log(jlog::verbose_detailed_format(i, FUNCTION, __FILE__, __LINE__)); };

-#define DEBUG(i)   jlog::debug_spec(i, FUNCTION, __FILE__, __LINE__);
-#define SDEBUG(i)   jlog::sdebug_spec(i, FUNCTION, __FILE__, __LINE__);
-#define USDEBUG(i)   jlog::usdebug_spec(i, FUNCTION, __FILE__, __LINE__);
+#define DEBUG(i)   if (jlog::loglevel >= jlog::severity::debug) { jlog::log(jlog::debug_detailed_format(i, FUNCTION, __FILE__, __LINE__)); };

-#define WARNING(i) jlog::warning_spec(i, FUNCTION, __FILE__, __LINE__);
-#define SWARNING(i) jlog::swarning_spec(i, FUNCTION, __FILE__, __LINE__);
-#define USWARNING(i) jlog::uswarning_spec(i, FUNCTION, __FILE__, __LINE__);
+#define WARNING(i) if (jlog::loglevel >= jlog::severity::warning) { jlog::log(jlog::warning_detailed_format(i, FUNCTION, __FILE__, __LINE__)); };

-#define ERROR(i)   jlog::error_spec(i, FUNCTION, __FILE__, __LINE__);
-#define SERROR(i)   jlog::serror_spec(i, FUNCTION, __FILE__, __LINE__);
-#define USERROR(i)   jlog::userror_spec(i, FUNCTION, __FILE__, __LINE__);
+#define ERROR(i)   if (jlog::loglevel >= jlog::severity::error) { jlog::log(jlog::error_detailed_format(i, FUNCTION, __FILE__, __LINE__)); };

-#define FATAL(i)   jlog::fatal_spec(i, FUNCTION, __FILE__, __LINE__);
-#define SFATAL(i)   jlog::sfatal_spec(i, FUNCTION, __FILE__, __LINE__);
-#define USFATAL(i)   jlog::usfatal_spec(i, FUNCTION, __FILE__, __LINE__);
+#define FATAL(i)   if (jlog::loglevel >= jlog::severity::fatal) { jlog::log(jlog::fatal_detailed_format(i, FUNCTION, __FILE__, __LINE__)); };
+
+#define LOGLEVEL(i) jlog::loglevel = i;
--- a/main.cpp
+++ b/main.cpp
@@ -1,7 +1,22 @@
 #include <jlog/jlog.hpp>

+// Writing custom wrappers for jlog is super easy!
+void coollog(std::vector<jlog::token> tokens) {
+    std::vector<jlog::token> wtokens;
+    auto group = jlog::token{.content = "COOLLOGGER"};
+    wtokens.push_back(group);
+    wtokens.insert(wtokens.end(), tokens.begin(), tokens.end());
+    jlog::log(wtokens);
+}
+
+// We can either define custom logging macros or redefine jlog's builtin macros.
+#define COOLINFO(i) coollog(jlog::info_format(i));
+#define COOLINFOTRACE(i) coollog(jlog::info_detailed_format(i, FUNCTION, __FILE__, __LINE__));
+
 int main()
 {
+    LOGLEVEL(jlog::severity::debug); // <- see jlog::severity for full list of log levels
+
    INFO("This is barely useful information.");
    DEBUG("Debugging Information");
    VERBOSE("Yadda Yadda Yadda");
@@ -9,22 +24,10 @@ int main()
    ERROR("Oops, something went wrong.");
    FATAL("Unrecoverable Error!!!");

-    SINFO("This is even less useful information.");
-    SDEBUG("Shorter Debugging Information");
-    SVERBOSE("Yadda Yadda");
-    SWARNING("Minute miscalculation!");
-    SERROR("Oops, something went wrong, but the programmer used the short error logger so you're fucked!");
-    SFATAL("Unrecoverable Error, but the programmer used the short fatal logger so you're even more fucked!!!");
-
-    USINFO("This is EVEN less useful information.");
-    USDEBUG("Ultra compact debugging information.");
-    USVERBOSE("Isn't this an oxymoron?");
-    USWARNING("Captain Qwark grade miscalculation!");
-    USERROR("You're fucked!");
-    USFATAL("You're super fucked!!!");
+    COOLINFO("This is really cool!!!");
+    COOLINFOTRACE("THIS IS EVEN COOLER!!!");

    return 0;
-    ///
 }

 //Windows :(
--- a/src/jlog/linux/jlog.cpp
+++ b/src/jlog/linux/jlog.cpp
@@ -50,314 +50,129 @@ namespace jlog {
        log_to_file("\n");
    }

-    void direct(const std::string &message) { log({{.content = message, .delimiter=""}});}
-
-    void info(const std::string &message) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_WHITE, .content = "INFO"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({timestamp, severity, content});
-    }
-
-    void sinfo(const std::string &message) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_WHITE, .content = "INFO"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({severity, content});
-    }
-    void usinfo(const std::string &message) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_WHITE, .content = "INFO"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({severity, content});
-    }
-
-    void verbose(const std::string &message) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_CYAN, .content = "VERBOSE"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({timestamp, severity, content});
-        //log(ansi_escape_codes::FG_CYAN, "VERBOSE", message);
-    }
-
-    void sverbose(const std::string &message) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_CYAN, .content = "VERBOSE"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({severity, content});
-        //log(ansi_escape_codes::FG_CYAN, "VERBOSE", message);
-    }
-
-    void usverbose(const std::string &message) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_CYAN, .content = "VERBOSE"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({severity, content});
-        //log(ansi_escape_codes::FG_CYAN, "VERBOSE", message);
-    }
-
-    void debug(const std::string &message) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_GREEN, .content = "DEBUG"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({timestamp, severity, content});
-
-    }
-
-    void sdebug(const std::string &message) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_GREEN, .content = "DEBUG"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({severity, content});
-    }
-
-    void usdebug(const std::string &message) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_GREEN, .content = "DEBUG"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({severity, content});
-    }
-
-    void warning(const std::string &message) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_YELLOW, .content = "WARNING"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({timestamp, severity, content});
-        //log(ansi_escape_codes::FG_YELLOW, "WARNING", message);
-    }
-
-    void uswarning(const std::string &message) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_YELLOW, .content = "WARNING"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({severity, content});
-        //log(ansi_escape_codes::FG_YELLOW, "WARNING", message);
-    }
-
-    void error(const std::string &message) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_RED, .content = "ERROR"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({timestamp, severity, content});
-        //log(ansi_escape_codes::FG_RED, "ERROR", message);
-    }
-
-    void userror(const std::string &message) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_RED, .content = "ERROR"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = };
-        log({severity, content});
-        //log(ansi_escape_codes::FG_RED, "ERROR", message);
-    }
-
-    void fatal(const std::string &message) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_BRIGHT_RED, .content = "FATAL"};
-        auto content = token{.content = message, .delimiter = ""};
-
-        log({timestamp, severity, content});
-    }
-
-    void usfatal(const std::string &message) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_BRIGHT_RED, .content = "FATAL"};
-        auto content = token{.content = message, .delimiter = ""};
-
-        log({severity, content});
-    }
-
-    void info_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_WHITE, .content = "INFO"};
-        auto content = token{.content = message, .delimiter = ""};
+    // Generic formatters for building loggers.
+    std::vector<token> trace_format(
+        const std::string& func,
+        const std::string& file,
+        int line)
+    {
        auto trace = token{.content = func};
        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({timestamp, trace, filedata, severity, content});
+        return {trace, filedata};
    }

-    void sinfo_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_WHITE, .content = "INFO"};
+    std::vector<token> log_format(
+        const std::string& severity_name,
+        const std::string& message,
+        const std::string& severity_colorCode)
+    {
+        auto severity = token{.colorCode = severity_colorCode, .content = severity_name};
        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({trace, filedata, severity, content});
-        //log({severity, content});
+        return {severity, content};
    }

-    void usinfo_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_WHITE, .content = "INFO"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = func};
-        //auto filedata = token{.content = std::format("{}:{}", file, line)};
-        //log({trace, filedata, severity, content});
-        log({severity, content});
+    std::vector<token> log_detailed_format(
+    const std::string& severity_name,
+    const std::string& message,
+    const std::string& func,
+    const std::string& file,
+    int line,
+    const std::string& severity_colorCode)
+    {
+        std::vector<token> tokens;
+        auto timestamp = token{.content = jlog::get_timestamp()};
+        auto tf_tokens = trace_format(func, file, line);
+        auto lf_tokens = log_format(severity_name, message, severity_colorCode);
+        tokens.push_back(timestamp);
+        tokens.insert(tokens.end(), tf_tokens.begin(), tf_tokens.end());
+        tokens.insert(tokens.end(), lf_tokens.begin(), lf_tokens.end());
+        return tokens;
    }

-    void verbose_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_CYAN, .content = "VERBOSE"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({timestamp, trace, filedata, severity, content});
+
+
+    // Predefined generic loggers for jlog.
+    std::vector<token> info_format(const std::string& message)
+    {
+        return log_format("INFO", message);
    }

-    void sverbose_spec(const std::string &message, const std::string &func, const std::string &file,
-            int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_CYAN, .content = "VERBOSE"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({trace, filedata, severity, content});
+    std::vector<token> info_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line)
+    {
+        return log_detailed_format("INFO", message, func, file, line);
    }

-    void usverbose_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_CYAN, .content = "VERBOSE"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = func};
-        //auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({severity, content});
+    std::vector<token> warning_format(const std::string& message)
+    {
+        return log_format("INFO", message, ansi_escape_codes::FG_YELLOW);
    }

-    void debug_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_GREEN, .content = "DEBUG"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({timestamp, trace, filedata, severity, content});
+    std::vector<token> warning_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line)
+    {
+        return log_detailed_format("WARNING", message, func, file, line, ansi_escape_codes::FG_YELLOW);
    }

-    void sdebug_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_GREEN, .content = "DEBUG"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({trace, filedata, severity, content});
+    std::vector<token> error_format(const std::string& message)
+    {
+        return log_format("ERROR", message, ansi_escape_codes::FG_RED);
    }

-    void usdebug_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_GREEN, .content = "DEBUG"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = func};
-        //auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({severity, content});
+    std::vector<token> error_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line)
+    {
+        return log_detailed_format("ERROR", message, func, file, line, ansi_escape_codes::FG_RED);
    }

-    void warning_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_YELLOW, .content = "WARNING"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({timestamp, trace, filedata, severity, content});
+    std::vector<token> fatal_format(const std::string& message)
+    {
+        return log_format("FATAL", message, ansi_escape_codes::FG_BRIGHT_RED);
    }

-    void swarning_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_YELLOW, .content = "WARNING"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({trace, filedata, severity, content});
+    std::vector<token> fatal_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line)
+    {
+        return log_detailed_format("FATAL", message, func, file, line, ansi_escape_codes::FG_BRIGHT_RED);
    }

-    void uswarning_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_YELLOW, .content = "WARNING"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = func};
-        //auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({severity, content});
+    std::vector<token> verbose_format(const std::string& message)
+    {
+        return log_format("VERBOSE", message, ansi_escape_codes::FG_CYAN);
    }

-    void error_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_RED, .content = "ERROR"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({timestamp, trace, filedata, severity, content});
+    std::vector<token> verbose_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line)
+    {
+        return log_detailed_format("VERBOSE", message, func, file, line, ansi_escape_codes::FG_CYAN);
    }

-    void serror_spec(const std::string &message, const std::string &func, const std::string &file,
-            int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_RED, .content = "ERROR"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({trace, filedata, severity, content});
+    std::vector<token> debug_format(const std::string& message)
+    {
+        return log_format("DEBUG", message, ansi_escape_codes::FG_GREEN);
    }

-    void userror_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        //auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_RED, .content = "ERROR"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = func};
-        //auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({severity, content});
-    }
-
-    void fatal_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_BRIGHT_RED, .content = "FATAL"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({timestamp, trace, filedata, severity, content});
-    }
-
-    void sfatal_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_BRIGHT_RED, .content = "FATAL"};
-        auto content = token{.content = message, .delimiter = ""};
-        auto trace = token{.content = func};
-        auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({trace, filedata, severity, content});
-    }
-
-    void usfatal_spec(const std::string &message, const std::string &func, const std::string &file,
-        int line) {
-        auto timestamp = token{.content = get_timestamp()};
-        auto severity = token{.colorCode = ansi_escape_codes::FG_BRIGHT_RED, .content = "FATAL"};
-        auto content = token{.content = message, .delimiter = ""};
-        //auto trace = token{.content = func};
-        //auto filedata = token{.content = std::format("{}:{}", file, line)};
-        log({severity, content});
+    std::vector<token> debug_detailed_format(
+        const std::string &message,
+        const std::string &func,
+        const std::string &file,
+        int line)
+    {
+        return log_detailed_format("DEBUG", message, func, file, line, ansi_escape_codes::FG_GREEN);
    }
 }
--- a/src/jlog/windows/jlog.cpp
+++ b/src/jlog/windows/jlog.cpp
@@ -55,6 +55,8 @@ namespace jlog {
        log({{.content = message, .delimiter = ""}});
    }

+    std::vector<token> info_format(const std::string& message
+
    void info(const std::string& message) {
        auto timestamp = token{.content = get_timestamp()};
        auto severity = token{.colorCode = ansi_escape_codes::FG_WHITE, .content = "INFO"};
Author	SHA1	Message	Date
maxine	c5d3f7dc82	Updated README.md	2024-06-19 11:26:53 -04:00
maxine	aaa7318672	Merge remote-tracking branch 'origin/main'	2024-06-19 11:25:01 -04:00
maxine	95f2c761c7	Rewritten most functionality to be more generic and flexible. Cleaned up code as well. Implemented formatter system for easier wrapping. Made it easier for custom loggers to be built from jlog generics and primitives. Removed unused ultra short and short loggers to remove clutter.	2024-06-19 11:23:57 -04:00
Redacted	16d1eaa1ee	Update README.md	2024-06-18 21:49:22 -04:00
Redacted	80d9bcd240	Update include/jlog/jlog.hpp Fix definition clash when using in multiple projects.	2024-06-18 14:40:31 -04:00
maxine	2799c918b8	Implemented log level handling/switching. Use LOGLEVEL macro for setting level/severity. See jlog::severity in jlog.hpp for more information.	2024-06-18 12:11:41 -04:00
maxine	a86e70a055	Merge remote-tracking branch 'origin/main'	2024-06-18 11:10:20 -04:00
maxine	3cf70f5f4f	removed todo from README	2024-06-18 11:10:13 -04:00
Redacted	3a28d4e43b	Update ansi_escape_codes.hpp Fix problem that'd sometimes cause errors when using the macros in a lot of different files.	2024-06-18 00:44:07 -04:00
josh	e5cfd25fcc	Merge remote-tracking branch 'origin/main'	2024-06-17 13:51:29 -04:00
josh	b0793828f6	Try to make dependency private	2024-06-17 13:51:18 -04:00