tri11paragon
/
BLT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ansi

main
Brett 2025-03-05 01:55:14 -05:00
parent fcbc6b947d
commit 08e19c067e
5 changed files with 382 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

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

200
include/blt/logging/ansi.h
View File

@ -19,7 +19,10 @@
#ifndef BLT_LOGGING_COLORS_H
#define BLT_LOGGING_COLORS_H
#include <array>
#include <stdexcept>
#include <string>
#include <variant>
#include <blt/std/types.h>
#define BLT_ANSI_ESCAPE "\x1B"
@ -32,7 +35,9 @@ namespace blt::logging::ansi
{
namespace color
{
enum class color_mode : i32
inline std::array<u8, 10> reset_sequences = {0, 22, 22, 23, 24, 25, 26, 27, 28, 29};
enum class color_mode : u8
{
RESET_ALL = 0,
BOLD = 1,
@ -42,10 +47,9 @@ namespace blt::logging::ansi
BLINK = 5,
REVERSE = 7,
HIDDEN = 8,
STRIKE_THROUGH = 9,
};
STRIKE_THROUGH = 9, };
enum class color8 : i32
enum class color8 : u8
{
BLACK = 0,
RED = 1,
@ -58,7 +62,7 @@ namespace blt::logging::ansi
DEFAULT = 9
};
enum class color8_bright : i32
enum class color8_bright : u8
{
BLACK = 0,
RED = 1,
@ -67,33 +71,161 @@ namespace blt::logging::ansi
BLUE = 4,
MAGENTA = 5,
CYAN = 6,
WHITE = 7,
WHITE = 7, };
struct rgb_t
{
u8 r, g, b;
};
struct color256
{
explicit color256(u8 index) : color(index)
{}
color256(const u8 r, const u8 g, const u8 b) : color(rgb_t{r, g, b})
{
if (r > 5)
throw std::invalid_argument("r must be between 0 and 5");
if (g > 5)
throw std::invalid_argument("g must be between 0 and 5");
if (b > 5)
throw std::invalid_argument("b must be between 0 and 5");
}
[[nodiscard]] u8 index() const
{
if (std::holds_alternative<u8>(color))
return std::get<u8>(color);
const auto [r, g, b] = std::get<rgb_t>(color);
return (r * 36) + (g * 6) + b + 16;
}
private:
std::variant<u8, rgb_t> color;
};
struct color_rgb
{
color_rgb(const u8 r, const u8 g, const u8 b) : color(rgb_t{r, g, b})
{}
rgb_t color;
};
namespace detail
{
template <typename T>
struct color_converter
struct color_holder
{
using value_type = T;
T color;
bool alt = false;
};
template <typename T>
struct color_converter
{};
template <>
struct color_converter<color8>
{
static std::string to_string(color8 color, const bool background)
static std::string to_string(const color_holder<color8> color)
{
return (background ? "4" : "3") + std::to_string(static_cast<i32>(color));
return (color.alt ? "4" : "3") + std::to_string(static_cast<u8>(color.color));
}
};
template <>
struct color_converter<color8_bright>
{
static std::string to_string(color8_bright color, const bool background)
static std::string to_string(const color_holder<color8_bright> color)
{
return (background ? "10" : "9") + std::to_string(static_cast<i32>(color));
return (color.alt ? "10" : "9") + std::to_string(static_cast<u8>(color.color));
}
};
template <>
struct color_converter<color_mode>
{
static std::string to_string(const color_holder<color_mode> color)
{
return color.alt ? std::to_string(reset_sequences[static_cast<u8>(color.color)]) : std::to_string(static_cast<u8>(color.color));
}
};
template <>
struct color_converter<color256>
{
static std::string to_string(const color_holder<color256> color)
{
return (color.alt ? "48;5;" : "38;5;") + std::to_string(color.color.index());
}
};
template <>
struct color_converter<color_rgb>
{
static std::string to_string(const color_holder<color_rgb> color)
{
return (color.alt ? "48;2;" : "38;2;") + std::to_string(color.color.color.r) + ";" + std::to_string(color.color.color.g) + ";" +
std::to_string(color.color.color.b);
}
};
template <typename T>
struct ensure_holder
{
static color_holder<T> make(const T& color)
{
return color_holder<T>{color, false};
}
};
template <typename T>
struct ensure_holder<color_holder<T>>
{
static color_holder<T> make(const color_holder<T>& color)
{
return color;
}
};
template<typename T>
struct decay
{
using type = std::decay_t<T>;
};
template<typename T>
struct decay<color_holder<T>>
{
using type = std::decay_t<T>;
};
template<typename T>
using decay_t = typename decay<T>::type;
}
template <typename T>
auto fg(const T& color)
{
return detail::color_holder<T>{color, false};
}
template <typename T>
auto bg(const T& color)
{
return detail::color_holder<T>{color, true};
}
template <typename... Args>
std::string build(const Args&... args)
{
std::string result = BLT_ANSI_CSI;
((result += detail::color_converter<detail::decay_t<Args>>::to_string(detail::ensure_holder<Args>::make(args)), result += ';'), ...);
return result.substr(0, result.size() - 1) + "m";
}
}
@ -107,7 +239,7 @@ namespace blt::logging::ansi
inline const std::string form_feed = "\x0C";
inline const std::string carriage_return = "\x0D";
inline const std::string escape = BLT_ANSI_ESCAPE;
inline const std::string del = "\0x7F";
inline const std::string del = "\x7F";
inline const std::string csi = BLT_ANSI_CSI;
inline const std::string dsc = BLT_ANSI_DSC;
inline const std::string osc = BLT_ANSI_OSC;
@ -118,7 +250,7 @@ namespace blt::logging::ansi
inline const std::string home = BLT_ANSI_CSI "H";
template <bool UseH>
inline std::string move_to(i64 line, i64 column)
std::string move_to(const i64 line, const i64 column)
{
if constexpr (UseH)
return std::string(BLT_ANSI_CSI) + std::to_string(line) + ";" + std::to_string(column) + "H";
@ -126,37 +258,37 @@ namespace blt::logging::ansi
return std::string(BLT_ANSI_CSI) + std::to_string(line) + ";" + std::to_string(column) + "f";
}
inline std::string move_up(i64 lines)
inline std::string move_up(const i64 lines)
{
return std::string(BLT_ANSI_CSI) + std::to_string(lines) + "A";
}
inline std::string move_down(i64 lines)
inline std::string move_down(const i64 lines)
{
return std::string(BLT_ANSI_CSI) + std::to_string(lines) + "B";
}
inline std::string move_right(i64 columns)
inline std::string move_right(const i64 columns)
{
return std::string(BLT_ANSI_CSI) + std::to_string(columns) + "C";
}
inline std::string move_left(i64 columns)
inline std::string move_left(const i64 columns)
{
return std::string(BLT_ANSI_CSI) + std::to_string(columns) + "D";
}
inline std::string move_begin_down(i64 lines)
inline std::string move_begin_down(const i64 lines)
{
return std::string(BLT_ANSI_CSI) + std::to_string(lines) + "E";
}
inline std::string move_begin_up(i64 lines)
inline std::string move_begin_up(const i64 lines)
{
return std::string(BLT_ANSI_CSI) + std::to_string(lines) + "F";
}
inline std::string move_to(i64 column)
inline std::string move_to(const i64 column)
{
return std::string(BLT_ANSI_CSI) + std::to_string(column) + "G";
}
@ -164,9 +296,9 @@ namespace blt::logging::ansi
inline const std::string request_cursor_position = BLT_ANSI_CSI "6n";
inline const std::string move_up_one_line = BLT_ANSI_ESCAPE " M";
inline const std::string save_cursor_position_dec = BLT_ANSI_ESCAPE " 7";
inline const std::string resotre_cursor_position_dec = BLT_ANSI_ESCAPE " 8";
inline const std::string restore_cursor_position_dec = BLT_ANSI_ESCAPE " 8";
inline const std::string save_cursor_position_sco = BLT_ANSI_CSI "s";
inline const std::string resotre_cursor_position_sco = BLT_ANSI_CSI "u";
inline const std::string restore_cursor_position_sco = BLT_ANSI_CSI "u";
}
namespace erase
@ -179,6 +311,30 @@ namespace blt::logging::ansi
inline const std::string from_begin_of_line = BLT_ANSI_CSI "1K";
inline const std::string entire_line = BLT_ANSI_CSI "2K";
}
enum class mode : u8
{
mono40x25_text = 0,
color40x25_text = 1,
mono80x25_text = 2,
color80x25_text = 3,
color320x200_4color_graphics = 4,
mono320x200_graphics = 5,
mono640x200_graphics = 6,
line_wrapping = 7,
color320x200_graphics = 13,
color640x200_16color_graphics = 14,
mono640x350_2color_graphics = 15,
color640x350_16color_graphics = 16,
mono640x480_2color_graphics = 17,
color640x480_16color_graphics = 18,
color320_200_256color_graphics = 19
};
inline std::string use_mode(const mode mode)
{
return std::string(BLT_ANSI_CSI) + "=" + std::to_string(static_cast<u8>(mode)) + "h";
}
}
#endif //BLT_LOGGING_COLORS_H

8
include/blt/logging/logging.h
View File

@ -130,8 +130,14 @@ namespace blt::logging
default:
handle_type(stream, type);
if constexpr (blt::meta::is_streamable_v<T>)
stream << t;
{
if constexpr (std::is_same_v<T, char> || std::is_same_v<T, signed char>)
stream << static_cast<int>(t);
else if constexpr (std::is_same_v<T, unsigned char>)
stream << static_cast<unsigned int>(t);
else
stream << t;
}else
stream << "{INVALID TYPE}";
}
};

2
libraries/parallel-hashmap

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

26
tests/logger_tests.cpp
View File

@ -17,13 +17,13 @@
*/
#include <iostream>
#include <sstream>
#include <blt/logging/ansi.h>
#include <blt/logging/logging.h>
#include <blt/std/assert.h>
#include <blt/std/utility.h>
struct some_silly_type_t
{
};
{};
auto expected_str = std::string(R"(This is a println!
This is a println with args '42'
@ -131,5 +131,27 @@ int main()
auto [passed, error_msg] = compare_strings(expected_str, ss.str());
BLT_ASSERT_MSG(passed && "Logger logged string doesn't match precomputed expected string!", error_msg.c_str());
namespace ansi = blt::logging::ansi;
namespace color = ansi::color;
for (blt::u8 r = 0; r < 6; r++)
{
for (blt::u8 g = 0; g < 6; g++)
{
for (blt::u8 b = 0; b < 6; b++)
{
blt::logging::println("{}This is a println with a color {:#3x} {:#3x} {:#3x}{}",
build(fg(color::color256{r, g, b}), bg(color::color256{
static_cast<unsigned char>(5 - r),
static_cast<unsigned char>(5 - g),
static_cast<unsigned char>(5 - b)
})), r, g, b, build(color::color_mode::RESET_ALL));
}
}
}
blt::logging::println("{}This is a color now with background{}",
build(color::color_mode::BOLD, fg(color::color8::CYAN), color::color_mode::DIM, bg(color::color8::YELLOW)),
build(color::color_mode::RESET_ALL));
// blt::logging::println("This is println {}\twith a std::endl in the middle of it");
}