[pre-commit.ci] pre-commit autoupdate (#330)

* [pre-commit.ci] pre-commit autoupdate

updates:
- [github.com/pre-commit/mirrors-clang-format: v17.0.6 → v18.1.1](pre-commit/mirrors-clang-format@v17.0.6...v18.1.1)

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

.pre-commit-config.yaml

@@ -47,7 +47,7 @@ repos:
       - id: end-of-file-fixer
       - id: check-shebang-scripts-are-executable
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v17.0.6
+    rev: v18.1.1
     hooks:
       - id: clang-format
         types:

units/unit_definitions.hpp

@@ -852,8 +852,8 @@ namespace precise {
             return ((static_cast<std::uint32_t>(val >> bit) & 0x1U) > 0U) ? 1 :
                                                                             0;
         }
-        constexpr auto bShiftu(std::uint16_t val, std::uint32_t bit)
-            -> unsigned int
+        constexpr auto
+            bShiftu(std::uint16_t val, std::uint32_t bit) -> unsigned int
         {
             return ((static_cast<std::uint32_t>(val >> bit) & 0x1U) > 0U) ? 1U :
                                                                             0U;

units/units.hpp

@@ -742,17 +742,14 @@ class uncertain_measurement {
         float val,
         float uncertainty_val,
         const unit& base) noexcept :
-        value_(val),
-        uncertainty_(uncertainty_val), units_(base)
+        value_(val), uncertainty_(uncertainty_val), units_(base)
     {
     }
     /// construct from a single precision value, and unit assume uncertainty is
     /// 0
     explicit constexpr uncertain_measurement(
         float val,
-        const unit& base) noexcept :
-        value_(val),
-        units_(base)
+        const unit& base) noexcept : value_(val), units_(base)
     {
     }
 
@@ -761,16 +758,15 @@ class uncertain_measurement {
     explicit constexpr uncertain_measurement(
         double val,
         const unit& base) noexcept :
-        value_(static_cast<float>(val)),
-        units_(base)
+        value_(static_cast<float>(val)), units_(base)
     {
     }
     /// construct from a regular measurement and uncertainty value
     explicit constexpr uncertain_measurement(
         const measurement& val,
         float uncertainty_val) noexcept :
-        value_(static_cast<float>(val.value())),
-        uncertainty_(uncertainty_val), units_(val.units())
+        value_(static_cast<float>(val.value())), uncertainty_(uncertainty_val),
+        units_(val.units())
     {
     }
     /// construct from a regular measurement and an uncertainty measurement
@@ -1417,22 +1413,19 @@ class fixed_precise_measurement {
 
     explicit constexpr fixed_precise_measurement(
         const precise_measurement& val) :
-        value_(val.value()),
-        units_(val.units())
+        value_(val.value()), units_(val.units())
     {
     }
 
     constexpr fixed_precise_measurement(
         const fixed_precise_measurement& val) noexcept :
-        value_(val.value()),
-        units_(val.units())
+        value_(val.value()), units_(val.units())
     {
     }
 
     constexpr fixed_precise_measurement(
         fixed_precise_measurement&& val) noexcept :
-        value_(val.value()),
-        units_(val.units())
+        value_(val.value()), units_(val.units())
     {
     }
 

units/units_decl.hpp

@@ -113,11 +113,10 @@ namespace detail {
             unsigned int iflag,
             unsigned int eflag,
             unsigned int equation) :
-            meter_(meters),
-            second_(seconds), kilogram_(kilograms), ampere_(amperes),
-            candela_(candelas), kelvin_(kelvins), mole_(moles),
-            radians_(radians), currency_(currencys), count_(counts),
-            per_unit_(per_unit), i_flag_(iflag), e_flag_(eflag),
+            meter_(meters), second_(seconds), kilogram_(kilograms),
+            ampere_(amperes), candela_(candelas), kelvin_(kelvins),
+            mole_(moles), radians_(radians), currency_(currencys),
+            count_(counts), per_unit_(per_unit), i_flag_(iflag), e_flag_(eflag),
             equation_(equation)
         {
         }
@@ -780,17 +779,15 @@ class precise_unit {
     // NOLINTNEXTLINE(modernize-use-equals-default)
     constexpr precise_unit() noexcept {};
     explicit constexpr precise_unit(const detail::unit_data& base_unit) noexcept
-        :
-        base_units_(base_unit)
+        : base_units_(base_unit)
     {
     }
 
     /// Construct from multiplier, base_unit
     constexpr precise_unit(
         double mult,
         const detail::unit_data& base_unit) noexcept :
-        multiplier_(mult),
-        base_units_(base_unit)
+        multiplier_(mult), base_units_(base_unit)
     {
     }
 
@@ -799,17 +796,15 @@ class precise_unit {
         double mult,
         const detail::unit_data& base_unit,
         std::uint32_t commodity_code) noexcept :
-        multiplier_(mult),
-        base_units_(base_unit), commodity_(commodity_code)
+        multiplier_(mult), base_units_(base_unit), commodity_(commodity_code)
     {
     }
 
     /// Construct from multiplier, base_unit, commodity
     explicit constexpr precise_unit(
         const detail::unit_data& base_unit,
         std::uint32_t commodity_code) noexcept :
-        base_units_(base_unit),
-        commodity_(commodity_code)
+        base_units_(base_unit), commodity_(commodity_code)
     {
     }
 

webserver/unit_web_server.cpp

@@ -244,26 +244,28 @@ void handle_request(
     };
 
     // generate a conversion response
-    auto const html_response = [&req](
-                                   const std::string& html_page,
-                                   const std::vector<
-                                       std::pair<std::string, std::string>>&
-                                       substitutions) {
-        http::response<http::string_body> res{http::status::ok, req.version()};
-        res.set(http::field::server, "UNITS WEB SERVER" UNITS_VERSION_STRING);
-        res.set(http::field::content_type, "text/html");
-        res.keep_alive(req.keep_alive());
-        auto resp = html_page;
-        string_substitution(resp, substitutions);
-
-        if (req.method() != http::verb::head) {
-            res.body() = resp;
-            res.prepare_payload();
-        } else {
-            res.content_length(resp.size());
-        }
-        return res;
-    };
+    auto const html_response =
+        [&req](
+            const std::string& html_page,
+            const std::vector<std::pair<std::string, std::string>>&
+                substitutions) {
+            http::response<http::string_body> res{
+                http::status::ok, req.version()};
+            res.set(
+                http::field::server, "UNITS WEB SERVER" UNITS_VERSION_STRING);
+            res.set(http::field::content_type, "text/html");
+            res.keep_alive(req.keep_alive());
+            auto resp = html_page;
+            string_substitution(resp, substitutions);
+
+            if (req.method() != http::verb::head) {
+                res.body() = resp;
+                res.prepare_payload();
+            } else {
+                res.content_length(resp.size());
+            }
+            return res;
+        };
     // generate a conversion response
     auto const trivial_response = [&req](const std::string& value) {
         http::response<http::string_body> res{http::status::ok, req.version()};
@@ -280,27 +282,29 @@ void handle_request(
     };
 
     // generate a conversion response
-    auto const json_response = [&req](
-                                   const std::string& json_string,
-                                   const std::vector<
-                                       std::pair<std::string, std::string>>&
-                                       substitutions) {
-        http::response<http::string_body> res{http::status::ok, req.version()};
-        res.set(http::field::server, "UNITS WEB SERVER" UNITS_VERSION_STRING);
-        res.set(http::field::content_type, "application/json");
-        res.keep_alive(req.keep_alive());
-        auto resp = json_string;
-        string_substitution(resp, substitutions);
-
-        if (req.method() != http::verb::head) {
-            res.body() = resp;
-            res.prepare_payload();
-        } else {
-            res.content_length(resp.size());
-        }
+    auto const json_response =
+        [&req](
+            const std::string& json_string,
+            const std::vector<std::pair<std::string, std::string>>&
+                substitutions) {
+            http::response<http::string_body> res{
+                http::status::ok, req.version()};
+            res.set(
+                http::field::server, "UNITS WEB SERVER" UNITS_VERSION_STRING);
+            res.set(http::field::content_type, "application/json");
+            res.keep_alive(req.keep_alive());
+            auto resp = json_string;
+            string_substitution(resp, substitutions);
+
+            if (req.method() != http::verb::head) {
+                res.body() = resp;
+                res.prepare_payload();
+            } else {
+                res.content_length(resp.size());
+            }
 
-        return res;
-    };
+            return res;
+        };
     ++request_count;
 
     switch (req.method()) {