🎨 Committing clang-format changes

Author: Clang Robot

include/mfl/abstract_font_face.hpp

@@ -73,7 +73,8 @@ namespace mfl
         virtual ~abstract_font_face() = default;
         [[nodiscard]] virtual math_constants constants() const = 0;
         [[nodiscard]] virtual math_glyph_info glyph_info(const size_t glyph_index) const = 0;
-        [[nodiscard]] virtual size_t glyph_index_from_code_point(const code_point char_code, const bool use_large_variant) const = 0;
+        [[nodiscard]] virtual size_t glyph_index_from_code_point(const code_point char_code,
+                                                                 const bool use_large_variant) const = 0;
         [[nodiscard]] virtual std::vector<size_variant> horizontal_size_variants(const code_point char_code) const = 0;
         [[nodiscard]] virtual std::vector<size_variant> vertical_size_variants(const code_point char_code) const = 0;
         virtual void set_size(const points size) = 0;

include/mfl/layout.hpp

@@ -38,5 +38,6 @@ namespace mfl
         std::optional<std::string> error;
     };
 
-    layout_elements layout(const std::string_view input, const points font_size, const font_face_creator& create_font_face);
+    layout_elements layout(const std::string_view input, const points font_size,
+                           const font_face_creator& create_font_face);
 }

include/mfl/units.hpp

@@ -48,15 +48,23 @@ namespace mfl
 
 namespace fmt
 {
-    template<>
-    struct [[maybe_unused]] formatter<mfl::inches> : mfl::unit_formatter<mfl::inches, '\"'> {};
+    template <>
+    struct [[maybe_unused]] formatter<mfl::inches> : mfl::unit_formatter<mfl::inches, '\"'>
+    {
+    };
 
     template <>
-    struct [[maybe_unused]] formatter<mfl::dots_per_inch> : mfl::unit_formatter<mfl::dots_per_inch, 'd', 'p', 'i'> {};
+    struct [[maybe_unused]] formatter<mfl::dots_per_inch> : mfl::unit_formatter<mfl::dots_per_inch, 'd', 'p', 'i'>
+    {
+    };
 
     template <>
-    struct [[maybe_unused]] formatter<mfl::pixels> : mfl::unit_formatter<mfl::pixels, 'p', 'x'> {};
+    struct [[maybe_unused]] formatter<mfl::pixels> : mfl::unit_formatter<mfl::pixels, 'p', 'x'>
+    {
+    };
 
     template <>
-    struct [[maybe_unused]] formatter<mfl::points> : mfl::unit_formatter<mfl::points, 'p', 't'> {};
+    struct [[maybe_unused]] formatter<mfl::points> : mfl::unit_formatter<mfl::points, 'p', 't'>
+    {
+    };
 }

src/font_library.cpp

@@ -17,7 +17,8 @@ namespace mfl
             const auto capital_m_index = face.glyph_index_from_code_point('M', false);
             const auto capital_m_width = face.glyph_info(capital_m_index).width;
 
-            return {.size = size, .x_height = x_height, .capital_m_width = capital_m_width, .math_info = face.constants()};
+            return {
+                .size = size, .x_height = x_height, .capital_m_width = capital_m_width, .math_info = face.constants()};
         }
     }
 

src/noad/gen_script.cpp

@@ -92,9 +92,8 @@ namespace mfl
         dist_t sup_pos(const settings s, const cramping cramp, const bool is_nucleus_single_character,
                        const dist_t nuc_height, const dist_t sup_depth)
         {
-            const auto candidate_positions =
-                std::array{sup_pos0(s, is_nucleus_single_character, nuc_height), superscript_shift(s, cramp),
-                           sup_depth + (x_height(s) / 4)};
+            const auto candidate_positions = std::array{sup_pos0(s, is_nucleus_single_character, nuc_height),
+                                                        superscript_shift(s, cramp), sup_depth + (x_height(s) / 4)};
             return std::ranges::max(candidate_positions);
         }
 
@@ -170,8 +169,7 @@ namespace mfl
 
             if (sub_box && !sup_box) return make_subscript_hlist(s, std::move(nucleus), std::move(*sub_box));
 
-            if (!sub_box && sup_box)
-                return make_superscript_hlist(s, cramp, std::move(nucleus), std::move(*sup_box));
+            if (!sub_box && sup_box) return make_superscript_hlist(s, cramp, std::move(nucleus), std::move(*sup_box));
 
             return make_dual_scripts_hlist(s, cramp, std::move(nucleus), std::move(*sub_box), std::move(*sup_box));
         }
@@ -184,9 +182,8 @@ namespace mfl
         }
     }
 
-    template<gen_script Script>
-    hlist gen_script_to_hlist(const settings s, const cramping cramp, const bool use_limit_pos,
-                              const Script& n)
+    template <gen_script Script>
+    hlist gen_script_to_hlist(const settings s, const cramping cramp, const bool use_limit_pos, const Script& n)
     {
         constexpr auto is_big_op = std::is_same_v<decltype(n), const big_op&>;
         auto nucleus = make_nucleus(s, cramp, is_big_op, n.nucleus);

src/noad/gen_script.hpp

@@ -23,7 +23,7 @@ namespace mfl
     template <typename ScriptNoad>
     concept gen_script = std::is_same_v<ScriptNoad, big_op> || std::is_same_v<ScriptNoad, script>;
 
-    template<gen_script Script>
+    template <gen_script Script>
     [[nodiscard]] hlist gen_script_to_hlist(const settings s, const cramping cramp, const bool use_limit_pos,
                                             const Script& n);
 }

src/noad/left_right.cpp

@@ -12,12 +12,14 @@ namespace mfl
         const auto requested_height = content.dims.depth + content.dims.height;
         hlist result;
         if (l.left_delim_code != 0)
-            result.nodes.emplace_back(make_auto_height_glyph(s, font_family::roman, l.left_delim_code, requested_height).first);
+            result.nodes.emplace_back(
+                make_auto_height_glyph(s, font_family::roman, l.left_delim_code, requested_height).first);
 
         result.nodes.emplace_back(std::move(content));
 
         if (l.right_delim_code != 0)
-            result.nodes.emplace_back(make_auto_height_glyph(s, font_family::roman, l.right_delim_code, requested_height).first);
+            result.nodes.emplace_back(
+                make_auto_height_glyph(s, font_family::roman, l.right_delim_code, requested_height).first);
 
         return result;
     }

src/noad/math_char.cpp

@@ -9,14 +9,13 @@ namespace mfl
     namespace
     {
         std::size_t find_best_size_glyph_index(const abstract_font_face& face, const code_point char_code,
-                                          const dist_t requested_size, const bool is_horizontal)
+                                               const dist_t requested_size, const bool is_horizontal)
         {
             using namespace units_literals;
             const auto variants =
                 is_horizontal ? face.horizontal_size_variants(char_code) : face.vertical_size_variants(char_code);
 
-            if (variants.empty())
-                return face.glyph_index_from_code_point(char_code, false);
+            if (variants.empty()) return face.glyph_index_from_code_point(char_code, false);
 
             auto result = variants.front().glyph_index;
             for (const auto v : variants)

src/noad/math_char.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
+#include "dist.hpp"
 #include "mfl/code_point.hpp"
 #include "mfl/font_family.hpp"
 #include "noad/item_kind.hpp"
-#include "dist.hpp"
 
 #include <utility>
 
@@ -30,10 +30,12 @@ namespace mfl
                                                        const code_point char_code, const bool use_large_variant);
 
     std::pair<glyph, horizontal_correction> make_auto_width_glyph(const settings s, const font_family family,
-                                                                  const code_point char_code, const dist_t requested_width);
+                                                                  const code_point char_code,
+                                                                  const dist_t requested_width);
 
     std::pair<glyph, horizontal_correction> make_auto_height_glyph(const settings s, const font_family family,
-                                                                   const code_point char_code, const dist_t requested_height);
+                                                                   const code_point char_code,
+                                                                   const dist_t requested_height);
 
     hlist math_char_to_hlist(const settings s, const math_char& mc);
 }

src/noad/noad.cpp

@@ -1,6 +1,5 @@
 #include "noad/noad.hpp"
 
-#include "node/hlist.hpp"
 #include "mlist_with_kind.hpp"
 #include "noad/accent.hpp"
 #include "noad/big_op.hpp"
@@ -12,6 +11,7 @@
 #include "noad/script.hpp"
 #include "noad/underline.hpp"
 #include "node/box.hpp"
+#include "node/hlist.hpp"
 #include "settings.hpp"
 
 #include <algorithm>
@@ -39,22 +39,20 @@ namespace mfl
 
         hlist noad_to_hlist(const settings s, const cramping cramp, const noad& n)
         {
-            return std::visit(
-                overload{[&](const math_char& c) { return math_char_to_hlist(s, c); },
-                         [&](const radical& r) { return radical_to_hlist(s, cramp, r); },
-                         [&](const accent& a) { return accent_to_hlist(s, cramp, a); },
-                         [](const vcenter&) { return hlist{}; },
-                         [&](const overline& o) { return overline_to_hlist(s, cramp, o); },
-                         [&](const underline& u) { return underline_to_hlist(s, cramp, u); },
-                         [&](const fraction& f) { return fraction_to_hlist(s, cramp, f); },
-                         [&](const left_right& l) { return left_right_to_hlist(s, cramp, l); },
-                         [&](const script& sc) { return script_to_hlist(s, cramp, sc); },
-                         [&](const big_op& b) { return big_op_to_hlist(s, cramp, b); },
-                         [](const math_space&) { return hlist{}; },
-                         [&](const mlist& m) { return to_hlist(s, cramp, false, m.noads); },
-                         [&](const mlist_with_kind& m) { return to_hlist(s, cramp, false, m.noads); }
-                         },
-                n);
+            return std::visit(overload{[&](const math_char& c) { return math_char_to_hlist(s, c); },
+                                       [&](const radical& r) { return radical_to_hlist(s, cramp, r); },
+                                       [&](const accent& a) { return accent_to_hlist(s, cramp, a); },
+                                       [](const vcenter&) { return hlist{}; },
+                                       [&](const overline& o) { return overline_to_hlist(s, cramp, o); },
+                                       [&](const underline& u) { return underline_to_hlist(s, cramp, u); },
+                                       [&](const fraction& f) { return fraction_to_hlist(s, cramp, f); },
+                                       [&](const left_right& l) { return left_right_to_hlist(s, cramp, l); },
+                                       [&](const script& sc) { return script_to_hlist(s, cramp, sc); },
+                                       [&](const big_op& b) { return big_op_to_hlist(s, cramp, b); },
+                                       [](const math_space&) { return hlist{}; },
+                                       [&](const mlist& m) { return to_hlist(s, cramp, false, m.noads); },
+                                       [&](const mlist_with_kind& m) { return to_hlist(s, cramp, false, m.noads); }},
+                              n);
         }
 
         ilist noads_to_intermediate_terms(const settings s, const cramping cramp, const std::vector<noad>& noads)
@@ -65,8 +63,7 @@ namespace mfl
                 if (std::holds_alternative<math_space>(n)) { result.terms.emplace_back(std::get<math_space>(n)); }
                 else
                 {
-                    result.terms.emplace_back(
-                        inoad{.translated_noad = noad_to_hlist(s, cramp, n), .kind = kind(n)});
+                    result.terms.emplace_back(inoad{.translated_noad = noad_to_hlist(s, cramp, n), .kind = kind(n)});
                 }
             }
 
@@ -112,12 +109,11 @@ namespace mfl
                 {.left = item_kind::op, .right = item_kind::ord, .space = thin_skip_always}};
 
             const auto is_entry_for_items = [&](const table_entry& e) {
-                return (((e.left == left) or (e.left == item_kind::any)) and
-                        ((e.right == right) or (e.right == item_kind::any)));
+                return (((e.left == left) or (e.left == item_kind::any))
+                        and ((e.right == right) or (e.right == item_kind::any)));
             };
 
-            if (const auto it = std::ranges::find_if(table, is_entry_for_items); it != table.end())
-                return it->space;
+            if (const auto it = std::ranges::find_if(table, is_entry_for_items); it != table.end()) return it->space;
 
             return std::nullopt;
         }
@@ -151,8 +147,8 @@ namespace mfl
 
         item_kind kind_of_next_inoad(const std::span<const intermediate_term> iterms)
         {
-            const auto it =
-                std::ranges::find_if(iterms, [](const intermediate_term& t) { return std::holds_alternative<inoad>(t); });
+            const auto it = std::ranges::find_if(
+                iterms, [](const intermediate_term& t) { return std::holds_alternative<inoad>(t); });
 
             return it == iterms.end() ? item_kind::none : std::get<inoad>(*it).kind;
         }
@@ -171,7 +167,8 @@ namespace mfl
             return std::ranges::find(kinds, kind) != kinds.end();
         }
 
-        item_kind change_kind(const item_kind prev_kind, const item_kind kind, const std::span<const intermediate_term> iterms)
+        item_kind change_kind(const item_kind prev_kind, const item_kind kind,
+                              const std::span<const intermediate_term> iterms)
         {
             if (kind != item_kind::bin) return kind;
 
@@ -194,7 +191,8 @@ namespace mfl
                     kind = change_kind(prev_kind, n.kind, tail);
                     const auto space = make_space(s, math_spacing(prev_kind, n.kind));
                     result.nodes.insert(result.nodes.end(), space.nodes.begin(), space.nodes.end());
-                    result.nodes.insert(result.nodes.end(), n.translated_noad.nodes.begin(), n.translated_noad.nodes.end());
+                    result.nodes.insert(result.nodes.end(), n.translated_noad.nodes.begin(),
+                                        n.translated_noad.nodes.end());
                 }
                 else if (std::holds_alternative<ispace>(term))
                 {
@@ -216,7 +214,9 @@ namespace mfl
         item_kind nucleus_kind(const script& s)
         {
             if ((s.nucleus.size() == 1) && (std::holds_alternative<math_char>(s.nucleus.front())))
-            { return std::get<math_char>(s.nucleus.front()).kind; }
+            {
+                return std::get<math_char>(s.nucleus.front()).kind;
+            }
 
             return item_kind::ord;
         }