fmt: update to v11.0.0 (#266)

* fmt: update to v11.0.0 for significant performance and API improvements 🎉 * ensure format helpers are const * fixing more of the types * make format helper functions const * revert change to abi_encoder from find-replace * fix formatter parse function which cannot be const because it modifies presentation * update format includes
esp-cpp · Jul 1, 2024 · c044871 · c044871
1 parent 9ac15bc
commit c044871
Show file tree

Hide file tree

Showing 33 changed files with 222 additions and 148 deletions.
diff --git a/components/adc/include/adc_types.hpp b/components/adc/include/adc_types.hpp
@@ -24,21 +24,21 @@ static bool operator==(const AdcConfig &lhs, const AdcConfig &rhs) { return !(lh
 
 // for libfmt printing of adc_unit_t
 template <> struct fmt::formatter<adc_unit_t> : fmt::formatter<std::string> {
-  template <typename FormatContext> auto format(adc_unit_t t, FormatContext &ctx) {
+  template <typename FormatContext> auto format(adc_unit_t t, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "ADC_UNIT_{}", (int)t + 1);
   }
 };
 
 // for libfmt printing of adc_channel_t
 template <> struct fmt::formatter<adc_channel_t> : fmt::formatter<std::string> {
-  template <typename FormatContext> auto format(adc_channel_t t, FormatContext &ctx) {
+  template <typename FormatContext> auto format(adc_channel_t t, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "ADC_CHANNEL_{}", (int)t);
   }
 };
 
 // for libfmt printing of adc_atten_t
 template <> struct fmt::formatter<adc_atten_t> : fmt::formatter<std::string> {
-  template <typename FormatContext> auto format(adc_atten_t t, FormatContext &ctx) {
+  template <typename FormatContext> auto format(adc_atten_t t, FormatContext &ctx) const {
     switch (t) {
     case ADC_ATTEN_DB_0:
       return fmt::format_to(ctx.out(), "ADC_ATTEN_DB_0");
@@ -55,9 +55,12 @@ template <> struct fmt::formatter<adc_atten_t> : fmt::formatter<std::string> {
 
 // for easy serialization of AdcConfig with libfmt
 template <> struct fmt::formatter<espp::AdcConfig> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
-  template <typename FormatContext> auto format(const espp::AdcConfig &c, FormatContext &ctx) {
+  template <typename FormatContext>
+  auto format(const espp::AdcConfig &c, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "AdcConfig(unit={}, channel={}, attenuation={})", c.unit,
                           c.channel, c.attenuation);
   }

diff --git a/components/ads7138/include/ads7138.hpp b/components/ads7138/include/ads7138.hpp
@@ -1497,10 +1497,12 @@ class Ads7138 : public BasePeripheral<> {
 // for allowing easy serialization/printing of the
 // espp::Ads7138::OverSamplingRatio enum
 template <> struct fmt::formatter<espp::Ads7138::OversamplingRatio> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::Ads7138::OversamplingRatio const &ratio, FormatContext &ctx) {
+  auto format(espp::Ads7138::OversamplingRatio const &ratio, FormatContext &ctx) const {
     switch (ratio) {
     case espp::Ads7138::OversamplingRatio::NONE:
       return fmt::format_to(ctx.out(), "NONE");
@@ -1527,10 +1529,12 @@ template <> struct fmt::formatter<espp::Ads7138::OversamplingRatio> {
 // for allowing easy serialization/printing of the
 // espp::Ads7138::Mode enum
 template <> struct fmt::formatter<espp::Ads7138::Mode> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::Ads7138::Mode const &mode, FormatContext &ctx) {
+  auto format(espp::Ads7138::Mode const &mode, FormatContext &ctx) const {
     switch (mode) {
     case espp::Ads7138::Mode::MANUAL:
       return fmt::format_to(ctx.out(), "MANUAL");
@@ -1547,10 +1551,12 @@ template <> struct fmt::formatter<espp::Ads7138::Mode> {
 // for allowing easy serialization/printing of the
 // espp::Ads7138::DataFormat enum
 template <> struct fmt::formatter<espp::Ads7138::DataFormat> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::Ads7138::DataFormat const &format, FormatContext &ctx) {
+  auto format(espp::Ads7138::DataFormat const &format, FormatContext &ctx) const {
     switch (format) {
     case espp::Ads7138::DataFormat::RAW:
       return fmt::format_to(ctx.out(), "RAW");
@@ -1565,10 +1571,12 @@ template <> struct fmt::formatter<espp::Ads7138::DataFormat> {
 // for allowing easy serialization/printing of the
 // espp::Ads7138::Append enum
 template <> struct fmt::formatter<espp::Ads7138::Append> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::Ads7138::Append const &format, FormatContext &ctx) {
+  auto format(espp::Ads7138::Append const &format, FormatContext &ctx) const {
     switch (format) {
     case espp::Ads7138::Append::NONE:
       return fmt::format_to(ctx.out(), "NONE");
@@ -1585,10 +1593,12 @@ template <> struct fmt::formatter<espp::Ads7138::Append> {
 // for allowing easy serialization/printing of the
 // espp::Ads7138::Channel enum
 template <> struct fmt::formatter<espp::Ads7138::Channel> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::Ads7138::Channel const &ch, FormatContext &ctx) {
+  auto format(espp::Ads7138::Channel const &ch, FormatContext &ctx) const {
     switch (ch) {
     case espp::Ads7138::Channel::CH0:
       return fmt::format_to(ctx.out(), "CH0");
@@ -1615,10 +1625,12 @@ template <> struct fmt::formatter<espp::Ads7138::Channel> {
 // for allowing easy serialization/printing of a
 // std::vector<espp::Ads7138::Channel> object
 template <> struct fmt::formatter<std::vector<espp::Ads7138::Channel>> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(std::vector<espp::Ads7138::Channel> const &channels, FormatContext &ctx) {
+  auto format(std::vector<espp::Ads7138::Channel> const &channels, FormatContext &ctx) const {
     std::string result = "{";
     for (auto const &ch : channels) {
       result += fmt::format("{}, ", ch);

diff --git a/components/bldc_haptics/include/detent_config.hpp b/components/bldc_haptics/include/detent_config.hpp
@@ -151,10 +151,12 @@ static const DetentConfig RETURN_TO_CENTER_WITH_DETENTS = {
 // for allowing easy serialization/printing of the
 // DetentConfig
 template <> struct fmt::formatter<espp::detail::DetentConfig> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::detail::DetentConfig const &detent_config, FormatContext &ctx) {
+  auto format(espp::detail::DetentConfig const &detent_config, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(),
                           "DetentConfig:\n"
                           "\tposition_width: {} radians ({} degrees)\n"

diff --git a/components/bldc_motor/include/bldc_types.hpp b/components/bldc_motor/include/bldc_types.hpp
@@ -42,10 +42,10 @@ enum class FocType {
 
 // for easy printing of enums using fmt
 template <> struct fmt::formatter<espp::detail::MotionControlType> {
-  constexpr auto parse(format_parse_context &ctx) { return ctx.begin(); }
+  constexpr auto parse(format_parse_context &ctx) const { return ctx.begin(); }
 
   template <typename FormatContext>
-  auto format(espp::detail::MotionControlType t, FormatContext &ctx) {
+  auto format(espp::detail::MotionControlType t, FormatContext &ctx) const {
     switch (t) {
     case espp::detail::MotionControlType::TORQUE:
       return fmt::format_to(ctx.out(), "TORQUE");
@@ -64,10 +64,10 @@ template <> struct fmt::formatter<espp::detail::MotionControlType> {
 };
 
 template <> struct fmt::formatter<espp::detail::TorqueControlType> {
-  constexpr auto parse(format_parse_context &ctx) { return ctx.begin(); }
+  constexpr auto parse(format_parse_context &ctx) const { return ctx.begin(); }
 
   template <typename FormatContext>
-  auto format(espp::detail::TorqueControlType t, FormatContext &ctx) {
+  auto format(espp::detail::TorqueControlType t, FormatContext &ctx) const {
     switch (t) {
     case espp::detail::TorqueControlType::VOLTAGE:
       return fmt::format_to(ctx.out(), "VOLTAGE");
@@ -82,9 +82,9 @@ template <> struct fmt::formatter<espp::detail::TorqueControlType> {
 };
 
 template <> struct fmt::formatter<espp::detail::FocType> {
-  constexpr auto parse(format_parse_context &ctx) { return ctx.begin(); }
+  constexpr auto parse(format_parse_context &ctx) const { return ctx.begin(); }
 
-  template <typename FormatContext> auto format(espp::detail::FocType t, FormatContext &ctx) {
+  template <typename FormatContext> auto format(espp::detail::FocType t, FormatContext &ctx) const {
     switch (t) {
     case espp::detail::FocType::SINE_PWM:
       return fmt::format_to(ctx.out(), "SINE_PWM");

diff --git a/components/bldc_motor/include/sensor_direction.hpp b/components/bldc_motor/include/sensor_direction.hpp
@@ -19,10 +19,10 @@ enum class SensorDirection {
 
 // for printing SensorDirection using libfmt
 template <> struct fmt::formatter<espp::detail::SensorDirection> {
-  constexpr auto parse(format_parse_context &ctx) { return ctx.begin(); }
+  constexpr auto parse(format_parse_context &ctx) const { return ctx.begin(); }
 
   template <typename FormatContext>
-  auto format(espp::detail::SensorDirection dir, FormatContext &ctx) {
+  auto format(espp::detail::SensorDirection dir, FormatContext &ctx) const {
     switch (dir) {
     case espp::detail::SensorDirection::CLOCKWISE:
       return fmt::format_to(ctx.out(), "CLOCKWISE");

diff --git a/components/ble_gatt_server/include/ble_gatt_server.hpp b/components/ble_gatt_server/include/ble_gatt_server.hpp
@@ -685,10 +685,10 @@ class BleGattServer : public BaseComponent {
 #if !CONFIG_BT_NIMBLE_EXT_ADV || defined(_DOXYGEN_)
 // for easy printing of the advertising parameters using libfmt
 template <> struct fmt::formatter<espp::BleGattServer::AdvertisingParameters> {
-  constexpr auto parse(format_parse_context &ctx) { return ctx.begin(); }
+  constexpr auto parse(format_parse_context &ctx) const { return ctx.begin(); }
   template <typename FormatContext>
   auto format(const espp::BleGattServer::AdvertisingParameters &advertising_params,
-              FormatContext &ctx) {
+              FormatContext &ctx) const {
     if (advertising_params.directed_address) {
       return fmt::format_to(
           ctx.out(),
@@ -711,9 +711,9 @@ template <> struct fmt::formatter<espp::BleGattServer::AdvertisingParameters> {
 
 // for easy printing of the DisconnectReason enum using libfmt
 template <> struct fmt::formatter<espp::BleGattServer::DisconnectReason> {
-  constexpr auto parse(format_parse_context &ctx) { return ctx.begin(); }
+  constexpr auto parse(format_parse_context &ctx) const { return ctx.begin(); }
   template <typename FormatContext>
-  auto format(const espp::BleGattServer::DisconnectReason &reason, FormatContext &ctx) {
+  auto format(const espp::BleGattServer::DisconnectReason &reason, FormatContext &ctx) const {
     switch (reason) {
     case espp::BleGattServer::DisconnectReason::UNKNOWN:
       return fmt::format_to(ctx.out(), "UNKNOWN");

diff --git a/components/bm8563/include/bm8563.hpp b/components/bm8563/include/bm8563.hpp
@@ -192,28 +192,36 @@ class Bm8563 : public BasePeripheral<> {
 // for allowing easy serialization/printing of the
 // espp::Bm8563::Date, espp::Bm8563::Time, and espp::Bm8563::DateTime
 template <> struct fmt::formatter<espp::Bm8563::Date> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
-  template <typename FormatContext> auto format(espp::Bm8563::Date const &d, FormatContext &ctx) {
+  template <typename FormatContext>
+  auto format(espp::Bm8563::Date const &d, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "{{.year = {}, .month = {}, .weekday = {}, .day = {}}}",
                           d.year, d.month, d.weekday, d.day);
   }
 };
 
 template <> struct fmt::formatter<espp::Bm8563::Time> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
-  template <typename FormatContext> auto format(espp::Bm8563::Time const &t, FormatContext &ctx) {
+  template <typename FormatContext>
+  auto format(espp::Bm8563::Time const &t, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "{{.hour = {}, .minute = {}, .second = {}}}", t.hour, t.minute,
                           t.second);
   }
 };
 
 template <> struct fmt::formatter<espp::Bm8563::DateTime> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::Bm8563::DateTime const &dt, FormatContext &ctx) {
+  auto format(espp::Bm8563::DateTime const &dt, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "{{.date = {}, .time = {}}}", dt.date, dt.time);
   }
 };
diff --git a/components/color/include/color.hpp b/components/color/include/color.hpp
@@ -132,19 +132,23 @@ class Hsv {
 // for allowing easy serialization/printing of the
 // Rgb
 template <> struct fmt::formatter<espp::Rgb> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
-  template <typename FormatContext> auto format(espp::Rgb const &rgb, FormatContext &ctx) {
+  template <typename FormatContext> auto format(espp::Rgb const &rgb, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "({}, {}, {})", rgb.r, rgb.g, rgb.b);
   }
 };
 
 // for allowing easy serialization/printing of the
 // Rgb
 template <> struct fmt::formatter<espp::Hsv> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
-  template <typename FormatContext> auto format(espp::Hsv const &hsv, FormatContext &ctx) {
+  template <typename FormatContext> auto format(espp::Hsv const &hsv, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "({}, {}, {})", hsv.h, hsv.s, hsv.v);
   }
 };
diff --git a/components/drv2605/include/drv2605.hpp b/components/drv2605/include/drv2605.hpp
@@ -276,9 +276,9 @@ class Drv2605 : public BasePeripheral<> {
 
 // for easy printing of the enums with the libfmt library:
 template <> struct fmt::formatter<espp::Drv2605::Mode> {
-  constexpr auto parse(format_parse_context &ctx) { return ctx.begin(); }
+  constexpr auto parse(format_parse_context &ctx) const { return ctx.begin(); }
 
-  template <typename FormatContext> auto format(espp::Drv2605::Mode m, FormatContext &ctx) {
+  template <typename FormatContext> auto format(espp::Drv2605::Mode m, FormatContext &ctx) const {
     switch (m) {
     case espp::Drv2605::Mode::INTTRIG:
       return fmt::format_to(ctx.out(), "INTTRIG");
@@ -303,9 +303,10 @@ template <> struct fmt::formatter<espp::Drv2605::Mode> {
 };
 
 template <> struct fmt::formatter<espp::Drv2605::Waveform> {
-  constexpr auto parse(format_parse_context &ctx) { return ctx.begin(); }
+  constexpr auto parse(format_parse_context &ctx) const { return ctx.begin(); }
 
-  template <typename FormatContext> auto format(espp::Drv2605::Waveform w, FormatContext &ctx) {
+  template <typename FormatContext>
+  auto format(espp::Drv2605::Waveform w, FormatContext &ctx) const {
     switch (w) {
     case espp::Drv2605::Waveform::END:
       return fmt::format_to(ctx.out(), "END");
@@ -352,9 +353,10 @@ template <> struct fmt::formatter<espp::Drv2605::Waveform> {
 };
 
 template <> struct fmt::formatter<espp::Drv2605::Library> {
-  constexpr auto parse(format_parse_context &ctx) { return ctx.begin(); }
+  constexpr auto parse(format_parse_context &ctx) const { return ctx.begin(); }
 
-  template <typename FormatContext> auto format(espp::Drv2605::Library l, FormatContext &ctx) {
+  template <typename FormatContext>
+  auto format(espp::Drv2605::Library l, FormatContext &ctx) const {
     switch (l) {
     case espp::Drv2605::Library::EMPTY:
       return fmt::format_to(ctx.out(), "EMPTY");

diff --git a/components/esp-box/include/esp-box.hpp b/components/esp-box/include/esp-box.hpp
@@ -391,7 +391,7 @@ class EspBox : public BaseComponent {
 
 // for easy printing of BoxType using libfmt
 template <> struct fmt::formatter<espp::EspBox::BoxType> : fmt::formatter<std::string> {
-  template <typename FormatContext> auto format(espp::EspBox::BoxType c, FormatContext &ctx) {
+  template <typename FormatContext> auto format(espp::EspBox::BoxType c, FormatContext &ctx) const {
     std::string name;
     switch (c) {
     case espp::EspBox::BoxType::UNKNOWN:
@@ -411,7 +411,7 @@ template <> struct fmt::formatter<espp::EspBox::BoxType> : fmt::formatter<std::s
 // for easy printing of TouchpadData using libfmt
 template <> struct fmt::formatter<espp::EspBox::TouchpadData> : fmt::formatter<std::string> {
   template <typename FormatContext>
-  auto format(const espp::EspBox::TouchpadData &c, FormatContext &ctx) {
+  auto format(const espp::EspBox::TouchpadData &c, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(),
                           "TouchpadData{{num_touch_points={}, x={}, y={}, btn_state={}}}",
                           c.num_touch_points, c.x, c.y, c.btn_state);

diff --git a/components/filters/include/biquad_filter.hpp b/components/filters/include/biquad_filter.hpp
@@ -151,21 +151,25 @@ class BiquadFilterDf2 {
 // for allowing easy serialization/printing of the
 // espp::BiquadFilterDf1
 template <> struct fmt::formatter<espp::BiquadFilterDf1> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::BiquadFilterDf1 const &bqf, FormatContext &ctx) {
+  auto format(espp::BiquadFilterDf1 const &bqf, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "DF1 - B: {}, A: {}", bqf.b_, bqf.a_);
   }
 };
 
 // for allowing easy serialization/printing of the
 // espp::BiquadFilterDf2
 template <> struct fmt::formatter<espp::BiquadFilterDf2> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::BiquadFilterDf2 const &bqf, FormatContext &ctx) {
+  auto format(espp::BiquadFilterDf2 const &bqf, FormatContext &ctx) const {
     return fmt::format_to(ctx.out(), "DF2 - B: {}, A: {}", bqf.b_, bqf.a_);
   }
 };
diff --git a/components/filters/include/butterworth_filter.hpp b/components/filters/include/butterworth_filter.hpp
@@ -75,10 +75,12 @@ class ButterworthFilter : public SosFilter<(ORDER + 1) / 2, Impl> {
 // for allowing easy serialization/printing of the
 // espp::ButterworthFilter
 template <size_t ORDER, class Impl> struct fmt::formatter<espp::ButterworthFilter<ORDER, Impl>> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
-  auto format(espp::ButterworthFilter<ORDER, Impl> const &f, FormatContext &ctx) {
+  auto format(espp::ButterworthFilter<ORDER, Impl> const &f, FormatContext &ctx) const {
     auto &&out = ctx.out();
     fmt::format_to(out, "Butterworth - [");
     if constexpr (ORDER > 0) {