this is a breaking change (logging)

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20)
 include(cmake/color.cmake)
-set(BLT_VERSION 4.0.38)
+set(BLT_VERSION 5.0.0)
 
 set(BLT_TARGET BLT)
 

commit.py.save

@@ -1,74 +0,0 @@
-#!/usr/bin/python3
-
-import subprocess
-
-#---------------------------------------
-#		CONFIG
-#---------------------------------------
-
-VERSION_BEGIN_STR = "set(BLT_VERSION "
-VERSION_END_STR = ")"
-
-#---------------------------------------
-#	      DO NOT TOUCH
-#---------------------------------------
-
-type = input("What kind of commit is this ((M)ajor, (m)inor, (p)atch)? ")
-
-def load_cmake():
-	cmake_file = open("CMakeLists.txt", 'r')
-	cmake_text = cmake_file.read()
-	cmake_file.close()
-	return cmake_text
-
-def write_cmake(cmake_text):
-	cmake_file = open("CMakeLists.txt", 'w')
-	cmake_file.write(cmake_text)
-	cmake_file.close()
-
-def get_version(cmake_text):
-	begin = cmake_text.find(VERSION_BEGIN_STR) + len(find_text)
-	end = cmake_text.find(VERSION_END_STR, begin)
-	return (cmake_text[begin:end], begin, end)
-
-def split_version(cmake_text):
-	version, begin, end = get_version(cmake_text)
-	version_parts = version.split('.')
-	return (version_parts, begin, end)
-
-def recombine(cmake_text, version_parts, begin, end):
-	constructed_version = version_parts[0] + '.' + version_parts[1] + '.' + version_parts[2]
-	constructed_text_begin = cmake_text[0:begin]
-	constrcuted_text_end = cmake_text[end::]
-	return constructed_text_begin + constructed_version + constrcuted_text_end
-
-
-def inc_major(cmake_text):
-	version_parts, begin, end = split_version(cmake_text)
-	version_parts[0] = str(int(version_parts[0]) + 1)
-	return recombine(cmake_text, version_parts, begin, end)
-
-def inc_minor(cmake_text):
-	version_parts, begin, end = split_version(cmake_text)
-	version_parts[1] = str(int(version_parts[1]) + 1)
-	return recombine(cmake_text, version_parts, begin, end)
-
-def inc_patch(cmake_text):
-	version_parts, begin, end = split_version(cmake_text)
-	version_parts[2] = str(int(version_parts[2]) + 1)
-	return recombine(cmake_text, version_parts, begin, end)
-
-if type.startswith('M'):
-	print("Selected major")
-	write_cmake(inc_major(load_cmake()))
-elif type.startswith('m'):
-	print("Selected minor")
-	write_cmake(inc_minor(load_cmake()))
-elif type.startswith('p') or type.startswith('P') or len(type) == 0:
-	print("Selected patch")
-	write_cmake(inc_patch(load_cmake()))
-
-#subprocess.call("./py_commit_helper.sh")
-subprocess.call("git", "add", "*")
-subprocess.call("git", "commit")
-subprocess.call("sh -e 'git remote | xargs -L1 git push --all'")

include/blt/logging/logging.h

@@ -21,68 +21,63 @@
 
 #include <iostream>
 #include <ostream>
+#include <sstream>
 #include <string>
 #include <blt/std/utility.h>
+#include <blt/meta/meta.h>
 
 namespace blt::logging
 {
-    struct logger_t
+	struct logger_t
-    {
+	{
-        explicit logger_t(std::string fmt): fmt(std::move(fmt))
+		explicit logger_t() = default;
-        {
-        }
 
-        template <typename T>
+		template <typename T>
-        std::string make_string(T&& t)
+		void print_value(T&& t)
-        {
+		{
-            if constexpr (std::is_same_v<T, std::string> || std::is_convertible_v<T, std::string>)
+			static_assert(meta::is_streamable_v<T>, "T must be streamable in order to work with blt::logging!");
-                return std::forward<T>(t);
+			m_stream << std::forward<T>(t);
-            else if constexpr (std::is_same_v<T, std::string_view> || std::is_same_v<std::remove_const_t<T>, char*> || std::is_convertible_v<
+		}
-                T, std::string_view>)
-                return std::string(std::forward<T>(t));
-            else if constexpr (std::is_same_v<T, char>)
-                return std::string() + std::forward<T>(t);
-            else if constexpr (std::is_arithmetic_v<T>)
-                return std::to_string(std::forward<T>(t));
-            else
-            {
-                BLT_UNREACHABLE;
-            }
-        }
 
-        void compile();
+		template <typename... Args>
+		std::string log(std::string fmt, Args&&... args)
+		{
+			compile(std::move(fmt));
+			((consume_until_fmt(), print_value(std::forward<Args>(args))), ...);
+			return to_string();
+		}
 
-        void insert_next_value(const std::string& arg);
+		std::string to_string();
 
-        template <typename... Args>
+	private:
-        const std::string& log(Args&&... args)
+		void compile(std::string fmt);
-        {
-            (insert_next_value(make_string(std::forward<Args>(args))), ...);
-            return fmt;
-        }
 
-    private:
+		void consume_until_fmt();
-        std::string fmt;
-    };
 
-    void print(const std::string& fmt);
+		std::string m_fmt;
+		std::stringstream m_stream;
+		size_t m_last_fmt_pos = 0;
+	};
 
-    void newline();
+	void print(const std::string& fmt);
 
-    template<typename... Args>
+	void newline();
-    void print(std::string fmt, Args&&... args)
-    {
-        logger_t logger{std::move(fmt)};
-        logger.compile();
-        print(logger.log(std::forward<Args>(args)...));
-    }
 
-    template<typename... Args>
+	logger_t& get_global_logger();
-    void println(std::string fmt, Args&&... args)
+
-    {
+	template <typename... Args>
-        print(std::move(fmt), std::forward<Args>(args)...);
+	void print(std::string fmt, Args&&... args)
-        newline();
+	{
-    }
+		auto& logger = get_global_logger();
+		print(logger.log(std::move(fmt), std::forward<Args>(args)...));
+	}
+
+	template <typename... Args>
+	void println(std::string fmt, Args&&... args)
+	{
+		print(std::move(fmt), std::forward<Args>(args)...);
+		newline();
+	}
 }
 
 #endif // BLT_LOGGING_LOGGING_H

include/blt/std/logging.h

@@ -828,11 +828,6 @@ void flush() {
     std::cout.flush();
 }
 
-void newline()
-{
-    std::cout << std::endl;
-}
-
 }
 
 #endif

libraries/parallel-hashmap

@@ -1 +1 @@
-Subproject commit 7ef2e733416953b222851f9a360d7fc72d068ee5
+Subproject commit 93201da2ba5a6aba0a6e57ada64973555629b3e3

src/blt/logging/logging.cpp

@@ -20,26 +20,46 @@
 
 namespace blt::logging
 {
-    void logger_t::compile()
+	struct logging_thread_context_t
-    {
+	{
+		logger_t logger;
+	};
 
-    }
+	std::string logger_t::to_string()
+	{
+		auto str = m_stream.str();
+		m_stream.str("");
+		m_stream.clear();
+		return str;
+	}
 
-    void logger_t::insert_next_value(const std::string& arg)
+	void logger_t::compile(std::string fmt)
-    {
+	{
-        const auto begin = fmt.find('{');
+		m_fmt = std::move(fmt);
-        const auto end = fmt.find('}', begin);
+		m_last_fmt_pos = 0;
-        fmt.erase(fmt.begin() + static_cast<i64>(begin), fmt.begin() + static_cast<i64>(end) + 1);
+	}
-        fmt.insert(begin, arg);
-    }
 
-    void print(const std::string& fmt)
+	void logger_t::consume_until_fmt()
-    {
+	{
-        std::cout << fmt;
+		const auto begin = m_fmt.find('{', m_last_fmt_pos);
-    }
+		const auto end = m_fmt.find('}', begin);
+		m_stream << std::string_view(m_fmt.data() + static_cast<ptrdiff_t>(m_last_fmt_pos), begin - m_last_fmt_pos);
+		m_last_fmt_pos = end;
+	}
 
-    void newline()
+	logger_t& get_global_logger()
-    {
+	{
-        std::cout << std::endl;
+		thread_local logging_thread_context_t context;
-    }
+		return context.logger;
+	}
+
+	void print(const std::string& fmt)
+	{
+		std::cout << fmt;
+	}
+
+	void newline()
+	{
+		std::cout << std::endl;
+	}
 }