object based logger

helpers/dbg_log.cpp

@@ -1,54 +1,91 @@
 #include "dbg_log/dbg_log.hpp"
 #include "common_helpers/common_helpers.hpp"
+#include "utfcpp/utf8.h"
 
+#include <iterator>
+#include <cwchar>
 #include <cstdarg>
-#include <cstdio>
 #include <filesystem>
-#include <thread>
 #include <sstream>
-#include <chrono>
-#include <mutex>
+#include <string>
+#include <stdio.h>
 
-static FILE* out_file = nullptr;
-auto const static start_time = std::chrono::system_clock::now();
-static std::recursive_mutex f_mtx{};
+#include "common_helpers/os_detector.h"
 
-bool dbg_log::init(const wchar_t *path)
-{
-	auto p = std::filesystem::path(path).u8string();
-	return init(p.c_str());
-}
 
-bool dbg_log::init(const char *path)
+void dbg_log::open()
 {
 #ifndef EMU_RELEASE_BUILD
-	std::lock_guard lk(f_mtx);
-	if (!out_file) {
-		out_file = std::fopen(path, "a");
-		if (!out_file) {
-			return false;
-		}
+	if (!out_file && filepath.size()) {
+
+		// https://en.cppreference.com/w/cpp/filesystem/path/u8path
+		const auto fsp = std::filesystem::u8path(filepath);
+#if defined(__WINDOWS__)
+		out_file = _wfopen(fsp.c_str(), L"a");
+#else
+		out_file = std::fopen(fsp.c_str(), "a");
+#endif
+
 	}
 
 #endif
 
-	return true;
 }
 
-void dbg_log::write(const std::wstring &str)
+void dbg_log::write_stamp()
+{
+	auto elapsed = std::chrono::high_resolution_clock::now() - start_time;
+	auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count();
+	auto duration_us = std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();
+
+	std::stringstream ss{};
+	ss << "[" << duration_ms << " ms, " << duration_us << " us] ";
+	auto ss_str = ss.str();
+
+	std::fprintf(out_file, "%s", ss_str.c_str());
+}
+
+dbg_log::dbg_log(std::string_view path)
 {
 	
 #ifndef EMU_RELEASE_BUILD
-	write(common_helpers::wstr_to_a(str));
+	filepath = path;
 #endif
 
 }
 
-void dbg_log::write(const std::string &str)
+dbg_log::dbg_log(std::wstring_view path)
 {
 	
 #ifndef EMU_RELEASE_BUILD
-	write(str.c_str());
+	filepath = common_helpers::to_str(path);
+#endif
+
+}
+
+dbg_log::~dbg_log()
+{
+	
+#ifndef EMU_RELEASE_BUILD
+	close();
+#endif
+
+}
+
+void dbg_log::write(std::string_view str)
+{
+
+#ifndef EMU_RELEASE_BUILD
+	write(str.data());
+#endif
+
+}
+
+void dbg_log::write(std::wstring_view str)
+{
+
+#ifndef EMU_RELEASE_BUILD
+	write(str.data());
 #endif
 
 }
@@ -58,14 +95,9 @@ void dbg_log::write(const char *fmt, ...)
 
 #ifndef EMU_RELEASE_BUILD
 	std::lock_guard lk(f_mtx);
+	open();
 	if (out_file) {
-		auto elapsed = std::chrono::system_clock::now() - start_time;
-
-		std::stringstream ss{};
-		ss << "[" << std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count() << " ms] [tid: "  << std::this_thread::get_id() << "] ";
-		auto ss_str = ss.str();
-
-		std::fprintf(out_file, ss_str.c_str());
+		write_stamp();
 
 		std::va_list args;
 		va_start(args, fmt);
@@ -79,6 +111,27 @@ void dbg_log::write(const char *fmt, ...)
 
 }
 
+void dbg_log::write(const wchar_t *fmt, ...)
+{
+
+#ifndef EMU_RELEASE_BUILD
+	std::lock_guard lk(f_mtx);
+	open();
+	if (out_file) {
+		write_stamp();
+
+		std::va_list args;
+		va_start(args, fmt);
+		std::vfwprintf(out_file, fmt, args);
+		va_end(args);
+
+		std::fprintf(out_file, "\n");
+		std::fflush(out_file);
+	}
+#endif
+
+}
+
 void dbg_log::close()
 {
 

helpers/dbg_log/dbg_log.hpp

@@ -1,20 +1,32 @@
 #pragma once
 
 #include <string>
+#include <string_view>
+#include <mutex>
+#include <cstdio>
+#include <chrono>
 
-namespace dbg_log
+class dbg_log
 {
+private:
+    std::recursive_mutex f_mtx{};
+    std::string filepath{};
+    std::FILE *out_file{};
+    const std::chrono::high_resolution_clock::time_point start_time = std::chrono::high_resolution_clock::now();
 
-bool init(const wchar_t *path);
+    void open();
+    void write_stamp();
 
-bool init(const char *path);
+public:
+    dbg_log(std::string_view path);
+    dbg_log(std::wstring_view path);
+    ~dbg_log();
 
-void write(const std::wstring &str);
+    void write(std::string_view str);
+    void write(std::wstring_view str);
 
-void write(const std::string &str);
+    void write(const char* fmt, ...);
+    void write(const wchar_t* fmt, ...);
 
-void write(const char* fmt, ...);
-
-void close();
-    
-}
+    void close();
+};