From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Tyler Veness Date: Wed, 29 May 2024 16:29:55 -0700 Subject: [PATCH 01/10] Use fmtlib --- include/sleipnir/autodiff/expression_type.hpp | 16 +++++++---- include/sleipnir/optimization/problem.hpp | 1 + .../optimization/solver/exit_status.hpp | 16 +++++++---- .../optimization/solver/util/inertia.hpp | 22 ++++++++------- include/sleipnir/util/assert.hpp | 5 ++-- include/sleipnir/util/print.hpp | 27 ++++++++++--------- 6 files changed, 53 insertions(+), 34 deletions(-) diff --git a/include/sleipnir/autodiff/expression_type.hpp b/include/sleipnir/autodiff/expression_type.hpp index 12d0568f628d5b97c0c2f5291851d4b20921f9d3..d06d32dac6c7b6faeedefeaa107cedac8446a3ab 100644 --- a/include/sleipnir/autodiff/expression_type.hpp +++ b/include/sleipnir/autodiff/expression_type.hpp @@ -4,9 +4,10 @@ #include -#include #include +#include + namespace slp { /// Expression type. @@ -27,14 +28,16 @@ enum class ExpressionType : uint8_t { } // namespace slp +// @cond Suppress Doxygen + /// Formatter for ExpressionType. template <> -struct std::formatter { +struct fmt::formatter { /// Parse format string. /// /// @param ctx Format parse context. /// @return Format parse context iterator. - constexpr auto parse(std::format_parse_context& ctx) { + constexpr auto parse(fmt::format_parse_context& ctx) { return m_underlying.parse(ctx); } @@ -45,7 +48,8 @@ struct std::formatter { /// @param ctx Format context. /// @return Format context iterator. template - auto format(const slp::ExpressionType& type, FmtContext& ctx) const { + constexpr auto format(const slp::ExpressionType& type, + FmtContext& ctx) const { using enum slp::ExpressionType; switch (type) { @@ -65,5 +69,7 @@ struct std::formatter { } private: - std::formatter m_underlying; + fmt::formatter m_underlying; }; + +// @endcond diff --git a/include/sleipnir/optimization/problem.hpp b/include/sleipnir/optimization/problem.hpp index ccff8b9425b45fd1c790bc4da87b81f501a70d9c..41b44578b1e2783dbceb300b7c72ee0c8d1202df 100644 --- a/include/sleipnir/optimization/problem.hpp +++ b/include/sleipnir/optimization/problem.hpp @@ -15,6 +15,7 @@ #include #include +#include #include #include "sleipnir/autodiff/expression_type.hpp" diff --git a/include/sleipnir/optimization/solver/exit_status.hpp b/include/sleipnir/optimization/solver/exit_status.hpp index 0a48df7423b5a3dccd8e611e91befd32487fafdc..8786d6d64ac44ac88133df65a79636ec133b1b64 100644 --- a/include/sleipnir/optimization/solver/exit_status.hpp +++ b/include/sleipnir/optimization/solver/exit_status.hpp @@ -4,9 +4,10 @@ #include -#include #include +#include + namespace slp { /// Solver exit status. Negative values indicate failure. @@ -45,14 +46,16 @@ enum class ExitStatus : int8_t { } // namespace slp +// @cond Suppress Doxygen + /// Formatter for ExitStatus. template <> -struct std::formatter { +struct fmt::formatter { /// Parses format string. /// /// @param ctx Format parse context. /// @return Format parse context iterator. - constexpr auto parse(std::format_parse_context& ctx) { + constexpr auto parse(fmt::format_parse_context& ctx) { return m_underlying.parse(ctx); } @@ -63,7 +66,8 @@ struct std::formatter { /// @param ctx Format context. /// @return Format context iterator. template - auto format(const slp::ExitStatus& exit_status, FmtContext& ctx) const { + constexpr auto format(const slp::ExitStatus& exit_status, + FmtContext& ctx) const { using enum slp::ExitStatus; switch (exit_status) { @@ -97,5 +101,7 @@ struct std::formatter { } private: - std::formatter m_underlying; + fmt::formatter m_underlying; }; + +// @endcond diff --git a/include/sleipnir/optimization/solver/util/inertia.hpp b/include/sleipnir/optimization/solver/util/inertia.hpp index 49ee606f7e3f02f2f5c24079eb27a412dad3055f..2d2ce114be9c40e645d685b63465b977e0b70439 100644 --- a/include/sleipnir/optimization/solver/util/inertia.hpp +++ b/include/sleipnir/optimization/solver/util/inertia.hpp @@ -2,10 +2,10 @@ #pragma once -#include #include #include +#include namespace slp { @@ -77,14 +77,16 @@ class Inertia { } // namespace slp +// @cond Suppress Doxygen + /// Formatter for Inertia. template <> -struct std::formatter { +struct fmt::formatter { /// Parses format string. /// /// @param ctx Format parse context. /// @return Format parse context iterator. - constexpr auto parse(std::format_parse_context& ctx) { + constexpr auto parse(fmt::format_parse_context& ctx) { return m_underlying.parse(ctx); } @@ -95,18 +97,20 @@ struct std::formatter { /// @param ctx Format context. /// @return Format context iterator. template - auto format(const slp::Inertia& inertia, FmtContext& ctx) const { + constexpr auto format(const slp::Inertia& inertia, FmtContext& ctx) const { auto out = ctx.out(); - out = std::format_to(out, "("); + out = fmt::format_to(out, "("); out = m_underlying.format(inertia.positive, ctx); - out = std::format_to(out, ", "); + out = fmt::format_to(out, ", "); out = m_underlying.format(inertia.negative, ctx); - out = std::format_to(out, ", "); + out = fmt::format_to(out, ", "); out = m_underlying.format(inertia.zero, ctx); - return std::format_to(out, ")"); + return fmt::format_to(out, ")"); } private: - std::formatter m_underlying; + fmt::formatter m_underlying; }; + +// @endcond diff --git a/include/sleipnir/util/assert.hpp b/include/sleipnir/util/assert.hpp index 29dfe5416530a476417de3a4b6434d3b28d73120..783a0e71a1cb54bd1d6d17fa9d2bedd2038a8ef5 100644 --- a/include/sleipnir/util/assert.hpp +++ b/include/sleipnir/util/assert.hpp @@ -3,16 +3,17 @@ #pragma once #ifdef SLEIPNIR_PYTHON -#include #include #include +#include + /// Throws an exception in Python. #define slp_assert(condition) \ do { \ if (!(condition)) { \ auto location = std::source_location::current(); \ - throw std::invalid_argument(std::format( \ + throw std::invalid_argument(fmt::format( \ "{}:{}: {}: Assertion `{}' failed.", location.file_name(), \ location.line(), location.function_name(), #condition)); \ } \ diff --git a/include/sleipnir/util/print.hpp b/include/sleipnir/util/print.hpp index d436bf297b85cf84fad642fa43aa97063e7d6ebb..b2920580eea0297fc387b5168df78a1515a5dd60 100644 --- a/include/sleipnir/util/print.hpp +++ b/include/sleipnir/util/print.hpp @@ -4,47 +4,48 @@ #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS #include -#include #include #include + +#include #endif namespace slp { #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS -/// Wrapper around std::print() that squelches write failure exceptions. +/// Wrapper around fmt::print() that squelches write failure exceptions. template -void print(std::format_string fmt, T&&... args) { +void print(fmt::format_string fmt, T&&... args) { try { - std::print(fmt, std::forward(args)...); + fmt::print(fmt, std::forward(args)...); } catch (const std::system_error&) { } } -/// Wrapper around std::print() that squelches write failure exceptions. +/// Wrapper around fmt::print() that squelches write failure exceptions. template -void print(std::FILE* f, std::format_string fmt, T&&... args) { +void print(std::FILE* f, fmt::format_string fmt, T&&... args) { try { - std::print(f, fmt, std::forward(args)...); + fmt::print(f, fmt, std::forward(args)...); } catch (const std::system_error&) { } } -/// Wrapper around std::println() that squelches write failure exceptions. +/// Wrapper around fmt::println() that squelches write failure exceptions. template -void println(std::format_string fmt, T&&... args) { +void println(fmt::format_string fmt, T&&... args) { try { - std::println(fmt, std::forward(args)...); + fmt::println(fmt, std::forward(args)...); } catch (const std::system_error&) { } } -/// Wrapper around std::println() that squelches write failure exceptions. +/// Wrapper around fmt::println() that squelches write failure exceptions. template -void println(std::FILE* f, std::format_string fmt, T&&... args) { +void println(std::FILE* f, fmt::format_string fmt, T&&... args) { try { - std::println(f, fmt, std::forward(args)...); + fmt::println(f, fmt, std::forward(args)...); } catch (const std::system_error&) { } }