#72 Complete rework of color formatter, added proper sgr encoding. Color flags parsing problem is fixed

Author: ChristianPanov

lwlog/include/details/argument_formatter/argument_buffers_pool_impl.h

@@ -61,7 +61,7 @@ namespace lwlog::details
         return m_args_buffers[slot_index];
     }
 
-        template<typename BufferLimits>
+    template<typename BufferLimits>
     const char(&argument_buffers_pool<BufferLimits>::get_args_buffer(std::uint8_t slot_index) const)
         [BufferLimits::arg_count][BufferLimits::argument]
     {

lwlog/include/details/memory_buffer.h

@@ -3,7 +3,7 @@
 #include <cstring>
 #include <cstddef>
 #include <memory>
-#include <string_view>
+#include <string>
 #include <charconv>
 
 namespace lwlog::details

lwlog/include/details/pattern/color_format_data.h

@@ -1,13 +1,14 @@
 #pragma once
 
+#include <string>
 #include <memory>
 #include <vector>
-#include <unordered_map>
 #include <algorithm>
 
 #include "attribute.h"
 #include "formatter.h"
 #include "alignment_formatter.h"
+#include "sgr_encoder.h"
 #include "details/record.h"
 #include "details/memory_buffer.h"
 
@@ -35,6 +36,8 @@ namespace lwlog::details
 		std::vector<std::string_view> parse_short_flags();
 
 	private:
+		sgr_encoder color_encoder;
+
 		details::memory_buffer<BufferLimits::pattern> m_pattern_buffer;
 
 		char m_cached_pattern_buffer[BufferLimits::pattern];

lwlog/include/details/pattern/pattern.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "pattern.h"
-#include "color_format_data.h"
 #include "formatters.h"
 
 namespace lwlog::details
@@ -94,42 +93,68 @@ namespace lwlog::details
 	template<typename BufferLimits>
 	void pattern<BufferLimits>::process_color_flags(bool use_color)
 	{
-		const char* const reset_seq{ use_color ? "\u001b[0m" : "" };
-		const std::uint8_t reset_seq_len{ use_color ?
-			static_cast<std::uint8_t>(4) :
-			static_cast<std::uint8_t>(0)
-		};
+		memory_buffer<10> color_buffer;
+
+		const char* const reset_seq{ use_color ? sgr_encoder::reset : "" };
+		const std::uint8_t reset_seq_len{ use_color ? sgr_encoder::reset_length : static_cast<std::uint8_t>(0) };
 
 		std::size_t pos{ 0 };
+		std::size_t dot_pos{ std::string_view::npos };
+		std::size_t open_brace_pos{ std::string_view::npos };
+		std::size_t close_brace_pos{ std::string_view::npos };
+
+		bool is_flag_valid{ true };
+
 		while (pos < m_pattern_buffer.size())
 		{
 			if (m_pattern_buffer[pos] == '.')
 			{
-				const std::size_t color_seq_end_pos{ m_pattern_buffer.data().find("(", pos) };
-				const std::string_view color_flag{ m_pattern_buffer.c_str() + pos, color_seq_end_pos - pos + 1 };
-
-				if (const auto it = color_data.find(color_flag); it != color_data.end())
-				{
-					const char* const color_seq{ use_color ? it->second.data() : "" };
-					const std::size_t color_seq_len{ use_color ? it->second.size() : 0 };
-
-					m_pattern_buffer.replace(pos, color_seq_end_pos - pos + 1, color_seq, color_seq_len);
-					pos += color_seq_len;
-				}
-				else
-				{
-					++pos;
-				}
+				dot_pos = pos;
+				is_flag_valid = true;
+			}
+			else if (m_pattern_buffer[pos] == '(')
+			{
+				open_brace_pos = pos;
 			}
 			else if (m_pattern_buffer[pos] == ')')
 			{
-				m_pattern_buffer.replace(pos, 1, reset_seq, reset_seq_len);
-				pos += reset_seq_len;
+				close_brace_pos = pos;
 			}
-			else
+			else if (m_pattern_buffer[pos] == ' ' && dot_pos != std::string_view::npos
+				&& (pos > dot_pos) && (pos < open_brace_pos))
 			{
-				++pos;
+				is_flag_valid = false;
 			}
+
+			if (dot_pos != std::string_view::npos && open_brace_pos != std::string_view::npos
+				&& close_brace_pos != std::string_view::npos)
+			{
+				if ((dot_pos < open_brace_pos && open_brace_pos < close_brace_pos) && is_flag_valid == true)
+				{
+					const std::size_t color_flag_len{ open_brace_pos - dot_pos + 1 };
+					const std::size_t color_name_len{ open_brace_pos - dot_pos - 1 };
+					const std::string_view color_name{ &m_pattern_buffer[dot_pos + 1], color_name_len };
+
+					color_encoder.encode(color_name, color_buffer);
+
+					const char* const color_seq{ use_color ? color_buffer.c_str() : "" };
+					const std::size_t color_seq_len{ use_color ? color_buffer.size() : 0 };
+
+					m_pattern_buffer.replace(dot_pos, color_flag_len, color_seq, color_seq_len);
+
+					const std::size_t recalculate_close_brace_pos{ close_brace_pos - color_flag_len + color_seq_len };
+					m_pattern_buffer.replace(recalculate_close_brace_pos, 1, reset_seq, reset_seq_len);
+
+					pos = recalculate_close_brace_pos + reset_seq_len;
+
+					is_flag_valid = true;
+					dot_pos = std::string_view::npos;
+					open_brace_pos = std::string_view::npos;
+					close_brace_pos = std::string_view::npos;
+				}
+			}
+
+			++pos;
 		}
 	}
 

lwlog/include/details/pattern/pattern_impl.h

@@ -0,0 +1,85 @@
+#include "sgr_encoder.h"
+#include <iostream>
+
+namespace lwlog::details
+{
+	void sgr_encoder::encode(std::string_view token, memory_buffer<10>& out)
+	{
+		std::string_view name{ token };
+
+		bool is_background{ false };
+		bool is_dark{ false };
+
+		constexpr auto starts_with = [](std::string_view str, std::string_view prefix) {
+			return str.compare(0, prefix.size(), prefix) == 0;
+			};
+
+		if (starts_with(name, "bg_"))	{ is_background = true; name.remove_prefix(3); }
+		if (starts_with(name, "dark_")) { is_dark		= true; name.remove_prefix(5); }
+
+		const sgr_color_spec* spec{ sgr_encoder::find_color_spec(name) };
+		if (!spec)
+		{
+			out.append(token);
+			return;
+		}
+
+		const std::uint8_t code{ sgr_encoder::resolve_color(*spec, is_background, is_dark) };
+
+		char code_digits[3]{};
+		std::uint8_t code_digits_count{};
+		if (code >= 100)
+		{
+			code_digits[0] = '1';
+			code_digits[1] = '0' + char((code / 10) % 10);
+			code_digits[2] = '0' + char(code % 10);
+			code_digits_count = 3;
+		}
+		else
+		{
+			code_digits[0] = '0' + char(code / 10);
+			code_digits[1] = '0' + char(code % 10);
+			code_digits_count = 2;
+		}
+
+		out.append("\x1b[");
+		out.append(code_digits, code_digits_count);
+		out.append('m');
+	}
+
+	const sgr_color_spec* sgr_encoder::find_color_spec(std::string_view color)
+	{
+		for (const auto& spec : sgr_colors)
+		{
+			if (spec.base_name == color)
+			{
+				return &spec;
+			}
+		}
+
+		return nullptr;
+	}
+
+	const std::uint8_t sgr_encoder::resolve_color(const sgr_color_spec& spec, bool is_background, bool is_dark)
+	{
+		const std::uint8_t channel_offset{ static_cast<std::uint8_t>(is_background ? 
+			color_channel_offset::background : color_channel_offset::foreground) };
+
+		if (spec.base_name == "grey")
+		{
+			const std::uint8_t grey_offset{ static_cast<std::uint8_t>(is_dark ? 
+				sgr_encoder::intensity_offset - 7 : 0) };
+			return spec.fg_base_code + channel_offset + grey_offset;
+		}
+
+		if (spec.base_name == "black")
+		{
+			return spec.fg_base_code + channel_offset;
+		}
+
+		const std::uint8_t color_intensity_offset{ static_cast<std::uint8_t>(
+			!is_dark ? sgr_encoder::intensity_offset : 0) 
+		};
+		return spec.fg_base_code + channel_offset + color_intensity_offset;
+	}
+}

lwlog/include/details/pattern/sgr_encoder.cpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "details/memory_buffer.h"
+
+namespace lwlog::details
+{
+	struct sgr_color_spec
+	{
+		std::string_view base_name;
+		std::uint8_t fg_base_code;
+	};
+
+	constexpr inline sgr_color_spec sgr_colors[] =
+	{
+		{ "black",		30 },
+		{ "white",		37 },
+		{ "grey",		37 },
+		{ "red",		31 },
+		{ "green",		32 },
+		{ "yellow",		33 },
+		{ "blue",		34 },
+		{ "magenta",	35 },
+		{ "cyan",		36 }
+	};
+
+	class sgr_encoder
+	{
+		enum class color_channel_offset { foreground = 0, background = 10 };
+		static constexpr std::uint8_t intensity_offset{ 60 };
+
+	public:
+		static constexpr const char* const reset{ "\x1b[0m" };
+		static constexpr std::uint8_t reset_length{ 4 };
+
+	public:
+		static void encode(std::string_view token, memory_buffer<10>& out);
+
+	private:
+		static const sgr_color_spec* find_color_spec(std::string_view color);
+		static const std::uint8_t resolve_color(const sgr_color_spec&, bool is_background, bool is_dark);
+	};
+}