nerdcruft/libcruft-util
1
0
Fork 0
Code Issues Releases Activity

log: use format_string to pass format specifiers

Browse Source
This commit is contained in:
Danny Robson 2023-11-19 09:38:07 +10:00
parent 6f17da5e59
commit 9804306f13
5 changed files with 59 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
log/log.hpp
View File

@ -28,15 +28,12 @@ namespace cruft::log {
void write (level_t, std::string_view msg); void write (level_t, std::string_view msg);
//------------------------------------------------------------------------- template <typename... ArgsT>
template <typename FormatT, typename ...ArgsT> void write (level_t _level, fmt::format_string<ArgsT...> fmt, ArgsT&&... args) {
void
write (level_t l, FormatT fmt, ArgsT &&...args)
{
default_sink ().write ( default_sink ().write (
packet ( packet (
l, _level,
std::forward<FormatT> (fmt), std::forward<fmt::format_string<ArgsT...>> (fmt),
std::forward<ArgsT> (args)... std::forward<ArgsT> (args)...
) )
); );
@ -58,7 +55,7 @@ namespace cruft::log {
do { \ do { \
::cruft::log::write ( \ ::cruft::log::write ( \
(LEVEL), \ (LEVEL), \
FMT_STRING(FMT) \ (FMT) \
__VA_OPT__(,) \ __VA_OPT__(,) \
__VA_ARGS__ \ __VA_ARGS__ \
); \ ); \

9
log/packet.hpp
View File

@ -36,15 +36,16 @@ namespace cruft::log {
) )
{ ; } { ; }
template <typename FormatT, typename ...ArgsT>
packet ( template <typename ...ArgsT>
constexpr packet (
level_t _level, level_t _level,
FormatT _format, fmt::format_string<ArgsT...> &&_format,
ArgsT &&..._args ArgsT &&..._args
) : packet ( ) : packet (
_level, _level,
fmt::format ( fmt::format (
std::forward<FormatT> (_format), std::forward<fmt::format_string<ArgsT...>> (_format),
std::forward<ArgsT> (_args)... std::forward<ArgsT> (_args)...
) )
) )

2
log/scoped.cpp
View File

@ -50,7 +50,7 @@ cruft::log::scoped_timer::~scoped_timer ()
write ( write (
m_level, m_level,
FMT_STRING("{:f}s, {:s}"), "{:f}s, {:s}",
float (duration) / 1'000'000'000.f, float (duration) / 1'000'000'000.f,
m_message m_message
); );

88
tap.hpp
View File

@ -48,13 +48,13 @@ namespace cruft::TAP {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
template <typename ...Args, size_t N> template <typename ...Args>
bool bool
expect (const bool test, const char (&format)[N], Args&&... args) expect (const bool test, fmt::format_string<Args...> format, Args&&... args)
{ {
m_output << (test ? "ok " : "not ok ") << ++m_size m_output << (test ? "ok " : "not ok ") << ++m_size
<< " - "; << " - ";
fmt::vprint (m_output, format, fmt::make_format_args (std::forward<Args> (args)...)); fmt::print (m_output, format, std::forward<Args> (args)...);
m_output << std::endl; m_output << std::endl;
if (!test) if (!test)
@ -64,12 +64,12 @@ namespace cruft::TAP {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
template <typename ...Args, size_t N> template <typename ...Args>
decltype(auto) decltype(auto)
expect (const std::function<bool(Args...)> &test, Args&&...args, const char (&fmt)[N]) expect (const std::function<bool(Args...)> &test, Args&&...args, fmt::format_string<Args...> fmt)
{ {
try { try {
return expect (test (std::forward<Args> (args)...), fmt); return expect (test (std::forward<Args> (args)...), std::move (fmt));
} catch (...) { } catch (...) {
return expect (false, fmt); return expect (false, fmt);
} }
@ -77,36 +77,40 @@ namespace cruft::TAP {
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
template <typename ValueT, size_t N, typename ...ArgsT> template <typename ValueT, typename ...ArgsT>
decltype(auto) decltype(auto)
expect_valid (ValueT &&value, char const (&fmt)[N], ArgsT &&...args) expect_valid (ValueT &&value, fmt::format_string<ArgsT...> fmt, ArgsT &&...args)
{ {
return expect ( return expect (
debug::is_valid ( debug::is_valid (
std::forward<ValueT> (value) std::forward<ValueT> (value)
), ),
fmt, std::move (fmt),
std::forward<ArgsT> (args)... std::forward<ArgsT> (args)...
); );
} }
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
template <typename ValueA, typename ValueB, std::size_t N, typename ...Args> template <typename ValueA, typename ValueB, typename ...Args>
decltype(auto) decltype(auto)
expect_mod (ValueA &&a, ValueB &&b, const char (&fmt)[N], Args &&...args) expect_mod (ValueA &&a, ValueB &&b, fmt::format_string<Args...> fmt, Args &&...args)
{ {
return expect (a % b == 0, fmt, std::forward<Args> (args)...); return expect (
a % b == 0,
std::move (fmt),
std::forward<Args> (args)...
);
} }
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
template <typename T, typename U, typename ...Args, size_t N> template <typename T, typename U, typename ...Args>
decltype(auto) decltype(auto)
expect_eq (const T &a, const U &b, const char (&fmt)[N], Args&&...args) expect_eq (const T &a, const U &b, fmt::format_string<Args...> fmt, Args&&...args)
{ {
#if 1 #if 1
return expect (almost_equal (a, b), fmt, std::forward<Args> (args)...); return expect (almost_equal (a, b), std::move (fmt), std::forward<Args> (args)...);
#else #else
if (almost_equal (a, b)) if (almost_equal (a, b))
return expect (true, fmt, std::forward<Args> (args)...); return expect (true, fmt, std::forward<Args> (args)...);
@ -117,63 +121,63 @@ namespace cruft::TAP {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
template <typename T, typename U, typename ...Args, size_t N> template <typename T, typename U, typename ...Args>
decltype(auto) decltype(auto)
expect_neq (const T &a, const U &b, const char (&fmt)[N], Args&&...args) expect_neq (const T &a, const U &b, fmt::format_string<Args...> fmt, Args&&...args)
{ {
return expect (!almost_equal (a, b), fmt, std::forward<Args> (args)...); return expect (!almost_equal (a, b), std::move (fmt), std::forward<Args> (args)...);
} }
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
template <typename ValueA, typename ValueB, typename ...Args, size_t N> template <typename ValueA, typename ValueB, typename ...Args>
decltype(auto) decltype(auto)
expect_gt (const ValueA &a, const ValueB &b, const char (&fmt)[N], Args&&...args) expect_gt (const ValueA &a, const ValueB &b, fmt::format_string<Args...> fmt, Args&&...args)
{ {
return expect (a > b, fmt, std::forward<Args> (args)...); return expect (a > b, std::move (fmt), std::forward<Args> (args)...);
} }
//--------------------------------------------------------------------- //---------------------------------------------------------------------
template <typename T, typename U, typename ...Args, size_t N> template <typename T, typename U, typename ...Args>
decltype(auto) decltype(auto)
expect_ge (const T &a, const U &b, const char (&fmt)[N], Args&&...args) expect_ge (const T &a, const U &b, fmt::format_string<Args...> fmt, Args&&...args)
{ {
return expect (a >= b, fmt, std::forward<Args> (args)...); return expect (a >= b, std::move (fmt), std::forward<Args> (args)...);
} }
//--------------------------------------------------------------------- //---------------------------------------------------------------------
template <typename T, typename U, typename ...Args, size_t N> template <typename T, typename U, typename ...Args>
decltype(auto) decltype(auto)
expect_lt (const T &a, const U &b, const char (&fmt)[N], Args&&...args) expect_lt (const T &a, const U &b, fmt::format_string<Args...> fmt, Args&&...args)
{ {
return expect (a < b, fmt, std::forward<Args> (args)...); return expect (a < b, std::move (fmt), std::forward<Args> (args)...);
} }
//--------------------------------------------------------------------- //---------------------------------------------------------------------
template <typename T, typename U, typename ...Args, size_t N> template <typename T, typename U, typename ...Args>
decltype(auto) decltype(auto)
expect_le (const T &a, const U &b, const char (&fmt)[N], Args&&...args) expect_le (const T &a, const U &b, fmt::format_string<Args...> fmt, Args&&...args)
{ {
return expect (a <= b, fmt, std::forward<Args> (args)...); return expect (a <= b, std::move (fmt), std::forward<Args> (args)...);
} }
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
template <typename T, typename ...Args, size_t N> template <typename T, typename ...Args>
decltype(auto) decltype(auto)
expect_nan (const T &t, const char (&fmt)[N], Args&&...args) expect_nan (const T &t, fmt::format_string<Args...> fmt, Args&&...args)
{ {
return expect (std::isnan (t), fmt, std::forward<Args> (args)...); return expect (std::isnan (t), std::move (fmt), std::forward<Args> (args)...);
} }
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
template <typename T, typename ...Args, size_t N> template <typename T, typename ...Args>
decltype(auto) decltype(auto)
expect_nothrow (T &&t, const char (&fmt)[N], Args&&...args) expect_nothrow (T &&t, fmt::format_string<Args...> fmt, Args&&...args)
{ {
bool success = true; bool success = true;
@ -183,14 +187,14 @@ namespace cruft::TAP {
success = false; success = false;
} }
return expect (success, fmt, std::forward<Args> (args)...); return expect (success, std::move (fmt), std::forward<Args> (args)...);
} }
//--------------------------------------------------------------------- //---------------------------------------------------------------------
template <typename E, typename T, typename ...Args, size_t N> template <typename E, typename T, typename ...Args>
decltype(auto) decltype(auto)
expect_throw (T &&t, const char (&fmt)[N], Args&&...args) expect_throw (T &&t, fmt::format_string<Args...> fmt, Args&&...args)
{ {
bool success = false; bool success = false;
@ -202,14 +206,14 @@ namespace cruft::TAP {
success = false; success = false;
} }
return expect (success, fmt, std::forward<Args> (args)...); return expect (success, std::move (fmt), std::forward<Args> (args)...);
} }
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
template <size_t N, typename ...Args> template <typename ...Args>
decltype(auto) decltype(auto)
fail (const char (&fmt)[N], Args &&...args) fail (fmt::format_string<Args...> fmt, Args &&...args)
{ {
return expect (false, fmt, std::forward<Args> (args)...); return expect (false, fmt, std::forward<Args> (args)...);
} }
@ -245,7 +249,7 @@ namespace cruft::TAP {
} catch (std::exception const &err) { } catch (std::exception const &err) {
tap.fail ("no exceptions: {:s}", err.what ()); tap.fail ("no exceptions: {:s}", err.what ());
} catch (cruft::error const &err) { } catch (cruft::error const &err) {
tap.fail ("no exceptions: {:s}", err); tap.fail ("no exceptions: {}", err);
} catch (...) { } catch (...) {
tap.fail ("no exceptions"); tap.fail ("no exceptions");
} }

4
test/list/sort.cpp
View File

@ -18,12 +18,12 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
template <std::size_t N, typename ...ArgsT> template <typename ...ArgsT>
static void static void
test_sort ( test_sort (
cruft::TAP::logger &tap, cruft::TAP::logger &tap,
std::vector<int> &&data, std::vector<int> &&data,
char const (&fmt)[N], fmt::format_string<ArgsT...> fmt,
ArgsT&&...args ArgsT&&...args
) { ) {
// Pre-allocate the array so that we don't get caught by pointer // Pre-allocate the array so that we don't get caught by pointer