Formatting

include/luma/animation.hpp

@@ -7,6 +7,7 @@
 
 #include <modulus.hpp>
 
+
 namespace luma {
 
 enum class easing {

include/luma/application.hpp

@@ -23,7 +23,9 @@
 namespace luma {
 
 namespace detail {
+
 struct application_core;
+
 }
 
 struct frame_stats {
@@ -34,11 +36,11 @@ struct frame_stats {
 class application {
 public:
   explicit application(luma::application_config config = {});
-  application(luma::application const&) = delete;
-  application(luma::application&&) noexcept;
+  application(luma::application const &) = delete;
+  application(luma::application &&) noexcept;
   ~application();
-  auto operator=(luma::application const&) -> luma::application& = delete;
-  auto operator=(luma::application&&) noexcept -> luma::application&;
+  auto operator=(luma::application const &) -> luma::application & = delete;
+  auto operator=(luma::application &&) noexcept -> luma::application &;
   auto dispatch(std::function<std::expected<void, modulus::error>()> task) -> std::expected<void, modulus::error>;
   auto register_route(std::string name, std::function<std::expected<std::unique_ptr<luma::control>, modulus::error>()> factory) -> std::expected<void, modulus::error>;
   auto replace_route(std::string name) -> std::expected<void, modulus::error>;
@@ -58,7 +60,7 @@ public:
   auto set_root(std::expected<std::unique_ptr<luma::control>, modulus::error> root) -> std::expected<void, modulus::error>;
   auto set_root(std::unique_ptr<luma::control> root) -> std::expected<void, modulus::error>;
   template <typename CONTROL>
-    requires (std::is_base_of_v<luma::control, CONTROL> && !std::is_same_v<luma::control, CONTROL>)
+    requires(std::is_base_of_v<luma::control, CONTROL> && !std::is_same_v<luma::control, CONTROL>)
   auto set_root(std::unique_ptr<CONTROL> root) -> std::expected<void, modulus::error>;
   auto show_dialog(luma::dialog_options options) -> std::expected<void, modulus::error>;
   auto close_dialog(luma::dialog_result result) -> std::expected<void, modulus::error>;
@@ -73,7 +75,7 @@ private:
 };
 
 template <typename CONTROL>
-  requires (std::is_base_of_v<luma::control, CONTROL> && !std::is_same_v<luma::control, CONTROL>)
+  requires(std::is_base_of_v<luma::control, CONTROL> && !std::is_same_v<luma::control, CONTROL>)
 auto application::set_root(std::unique_ptr<CONTROL> root) -> std::expected<void, modulus::error> {
   return set_root(std::unique_ptr<luma::control>{std::move(root)});
 }

include/luma/assets.hpp

@@ -11,22 +11,23 @@
 
 #include <luma/render.hpp>
 
+
 namespace luma {
 
 class renderer_resources {
 public:
   virtual ~renderer_resources() = default;
-  virtual auto load_texture(std::string const& path) -> std::expected<std::shared_ptr<luma::texture>, modulus::error> = 0;
+  virtual auto load_texture(std::string const &path) -> std::expected<std::shared_ptr<luma::texture>, modulus::error> = 0;
 };
 
 class asset_cache {
 public:
-  explicit asset_cache(luma::renderer_resources& resources);
-  auto texture(std::string const& path) -> std::expected<std::shared_ptr<luma::texture>, modulus::error>;
+  explicit asset_cache(luma::renderer_resources &resources);
+  auto texture(std::string const &path) -> std::expected<std::shared_ptr<luma::texture>, modulus::error>;
   auto clear() -> void;
 private:
   struct in_flight_load;
-  luma::renderer_resources* resources_{};
+  luma::renderer_resources *resources_{};
   mutable std::mutex mutex_{};
   std::uint64_t generation_{};
   std::unordered_map<std::string, std::shared_ptr<luma::texture>> textures_{};

include/luma/config.hpp

@@ -10,6 +10,7 @@
 
 #include <luma/theme.hpp>
 
+
 namespace luma {
 
 struct display_config {
@@ -31,15 +32,15 @@ struct application_config {
   luma::theme theme{luma::default_theme()};
 };
 
-auto validate(luma::display_config const& config) -> std::expected<void, modulus::error>;
-auto validate(luma::touch_config const& config) -> std::expected<void, modulus::error>;
-auto validate(luma::application_config const& config) -> std::expected<void, modulus::error>;
-auto parse_display_config(boost::json::value const& value) -> std::expected<luma::display_config, modulus::error>;
-auto parse_touch_config(boost::json::value const& value) -> std::expected<luma::touch_config, modulus::error>;
-auto parse_application_config(boost::json::value const& value) -> std::expected<luma::application_config, modulus::error>;
-auto load_application_config(std::string const& path) -> std::expected<luma::application_config, modulus::error>;
-auto to_json(luma::display_config const& config) -> boost::json::value;
-auto to_json(luma::touch_config const& config) -> boost::json::value;
-auto to_json(luma::application_config const& config) -> boost::json::value;
+auto validate(luma::display_config const &config) -> std::expected<void, modulus::error>;
+auto validate(luma::touch_config const &config) -> std::expected<void, modulus::error>;
+auto validate(luma::application_config const &config) -> std::expected<void, modulus::error>;
+auto parse_display_config(boost::json::value const &value) -> std::expected<luma::display_config, modulus::error>;
+auto parse_touch_config(boost::json::value const &value) -> std::expected<luma::touch_config, modulus::error>;
+auto parse_application_config(boost::json::value const &value) -> std::expected<luma::application_config, modulus::error>;
+auto load_application_config(std::string const &path) -> std::expected<luma::application_config, modulus::error>;
+auto to_json(luma::display_config const &config) -> boost::json::value;
+auto to_json(luma::touch_config const &config) -> boost::json::value;
+auto to_json(luma::application_config const &config) -> boost::json::value;
 
 }

include/luma/control.hpp

@@ -6,19 +6,22 @@
 
 #include <luma/geometry.hpp>
 
+
 namespace luma {
 
 class draw_context;
+
 struct theme;
+
 struct touch_event;
 
 class control {
 public:
   virtual ~control();
-  virtual auto measure(luma::draw_context& context, luma::theme const& theme, luma::constraints limits) -> luma::size = 0;
+  virtual auto measure(luma::draw_context &context, luma::theme const &theme, luma::constraints limits) -> luma::size = 0;
   virtual auto arrange(luma::rect bounds) -> void;
-  virtual auto draw(luma::draw_context& context, luma::theme const& theme) const -> void = 0;
-  virtual auto handle_touch(luma::touch_event const& event) -> std::bool_t;
+  virtual auto draw(luma::draw_context &context, luma::theme const &theme) const -> void = 0;
+  virtual auto handle_touch(luma::touch_event const &event) -> std::bool_t;
   virtual auto invalidate_layout() -> void;
   virtual auto bind_layout_invalidator(std::function<void()> invalidator) -> void;
   virtual auto focusable() const -> std::bool_t;

include/luma/controls.hpp

@@ -76,7 +76,6 @@ public:
     std::weak_ptr<void> lifetime{};
     std::function<void()> callback{};
   };
-
   text_input_state(luma::text_field_options options, std::function<void(std::string)> on_change);
   auto snapshot() const -> luma::text_field_options;
   auto text() const -> std::string;
@@ -101,7 +100,7 @@ auto numeric_keyboard() -> luma::keyboard_layout;
 auto make_text_input(luma::text_field_options options, std::function<void(std::string)> on_change) -> std::expected<std::shared_ptr<luma::text_input_state>, modulus::error>;
 
 template <typename... CONTROLS>
-auto children(CONTROLS&&... controls) -> std::expected<std::vector<std::unique_ptr<luma::control>>, modulus::error>;
+auto children(CONTROLS &&...controls) -> std::expected<std::vector<std::unique_ptr<luma::control>>, modulus::error>;
 
 auto label(std::string text) -> std::expected<std::unique_ptr<luma::control>, modulus::error>;
 auto button(std::string text, std::function<void()> on_click) -> std::expected<std::unique_ptr<luma::control>, modulus::error>;
@@ -123,7 +122,7 @@ auto stack(std::vector<std::unique_ptr<luma::control>> children) -> std::expecte
 auto scroll_view(std::expected<std::unique_ptr<luma::control>, modulus::error> child, std::bool_t vertical = true, std::bool_t horizontal = false) -> std::expected<std::unique_ptr<luma::control>, modulus::error>;
 auto scroll_view(std::unique_ptr<luma::control> child, std::bool_t vertical = true, std::bool_t horizontal = false) -> std::expected<std::unique_ptr<luma::control>, modulus::error>;
 template <typename CONTROL>
-  requires (std::is_base_of_v<luma::control, CONTROL> && !std::is_same_v<luma::control, CONTROL>)
+  requires(std::is_base_of_v<luma::control, CONTROL> && !std::is_same_v<luma::control, CONTROL>)
 auto scroll_view(std::unique_ptr<CONTROL> child, std::bool_t vertical = true, std::bool_t horizontal = false) -> std::expected<std::unique_ptr<luma::control>, modulus::error>;
 auto list(std::expected<std::vector<std::unique_ptr<luma::control>>, modulus::error> children, std::float32_t gap = 4.0F) -> std::expected<std::unique_ptr<luma::control>, modulus::error>;
 auto list(std::vector<std::unique_ptr<luma::control>> children, std::float32_t gap = 4.0F) -> std::expected<std::unique_ptr<luma::control>, modulus::error>;
@@ -153,17 +152,16 @@ auto normalize_child(std::expected<std::unique_ptr<CONTROL>, modulus::error> chi
 }
 
 template <typename CONTROL>
-  requires (std::is_base_of_v<luma::control, CONTROL> && !std::is_same_v<luma::control, CONTROL>)
+  requires(std::is_base_of_v<luma::control, CONTROL> && !std::is_same_v<luma::control, CONTROL>)
 auto luma::scroll_view(std::unique_ptr<CONTROL> child, std::bool_t vertical, std::bool_t horizontal) -> std::expected<std::unique_ptr<luma::control>, modulus::error> {
   return luma::scroll_view(std::unique_ptr<luma::control>{std::move(child)}, vertical, horizontal);
 }
 
 template <typename... CONTROLS>
-auto luma::children(CONTROLS&&... controls) -> std::expected<std::vector<std::unique_ptr<luma::control>>, modulus::error> {
+auto luma::children(CONTROLS &&...controls) -> std::expected<std::vector<std::unique_ptr<luma::control>>, modulus::error> {
   auto result = std::vector<std::unique_ptr<luma::control>>{};
   result.reserve(sizeof...(controls));
-
-  auto append = [&result](auto&& input) -> std::expected<void, modulus::error> {
+  auto append = [&result](auto &&input) -> std::expected<void, modulus::error> {
     auto child = luma::detail::normalize_child(std::forward<decltype(input)>(input));
     if (!child) {
       return modulus::fail<void>(child.error());
@@ -171,13 +169,13 @@ auto luma::children(CONTROLS&&... controls) -> std::expected<std::vector<std::un
     result.push_back(std::move(*child));
     return {};
   };
-
   auto status = std::expected<void, modulus::error>{};
   ([&] {
     if (status) {
       status = append(std::forward<CONTROLS>(controls));
     }
-  }(), ...);
+  }(),
+   ...);
   if (!status) {
     return modulus::fail<std::vector<std::unique_ptr<luma::control>>>(status.error());
   }

include/luma/detail/errors.hpp

@@ -7,6 +7,7 @@
 
 #include <modulus.hpp>
 
+
 namespace luma::detail {
 
 constexpr std::int32_t error_invalid_argument{1};

include/luma/geometry.hpp

@@ -5,6 +5,7 @@
 
 #include <modulus.hpp>
 
+
 namespace luma {
 
 struct point {

include/luma/input.hpp

@@ -6,6 +6,7 @@
 
 #include <luma/geometry.hpp>
 
+
 namespace luma {
 
 enum class touch_phase {

include/luma/overlays.hpp

@@ -14,6 +14,7 @@
 
 #include <luma/control.hpp>
 
+
 namespace luma {
 
 enum class dialog_result {
@@ -41,10 +42,10 @@ public:
   auto close_dialog(luma::dialog_result result) -> std::expected<void, modulus::error>;
   auto show_toast(luma::toast toast) -> std::expected<void, modulus::error>;
   auto tick(std::chrono::steady_clock::duration delta) -> std::bool_t;
-  auto measure(luma::draw_context& context, luma::theme const& theme, luma::constraints limits) -> luma::size override;
+  auto measure(luma::draw_context &context, luma::theme const &theme, luma::constraints limits) -> luma::size override;
   auto arrange(luma::rect bounds) -> void override;
-  auto draw(luma::draw_context& context, luma::theme const& theme) const -> void override;
-  auto handle_touch(luma::touch_event const& event) -> std::bool_t override;
+  auto draw(luma::draw_context &context, luma::theme const &theme) const -> void override;
+  auto handle_touch(luma::touch_event const &event) -> std::bool_t override;
   auto invalidate_layout() -> void override;
   auto bind_layout_invalidator(std::function<void()> invalidator) -> void override;
 private:

include/luma/render.hpp

@@ -8,6 +8,7 @@
 #include <luma/geometry.hpp>
 #include <luma/theme.hpp>
 
+
 namespace luma {
 
 struct texture_info {
@@ -29,11 +30,11 @@ public:
   virtual auto stroke_line(luma::point from, luma::point to, std::float32_t thickness, luma::color color) -> void = 0;
   virtual auto fill_ellipse(luma::rect bounds, luma::color color) -> void = 0;
   virtual auto stroke_ellipse(luma::rect bounds, std::float32_t thickness, luma::color color) -> void = 0;
-  virtual auto draw_text(std::string_view text, luma::point origin, luma::text_style const& style, luma::color color) -> void = 0;
-  virtual auto draw_texture(luma::texture const& texture, luma::rect source, luma::rect destination, luma::color tint) -> void = 0;
+  virtual auto draw_text(std::string_view text, luma::point origin, luma::text_style const &style, luma::color color) -> void = 0;
+  virtual auto draw_texture(luma::texture const &texture, luma::rect source, luma::rect destination, luma::color tint) -> void = 0;
   virtual auto push_clip(luma::rect bounds) -> void = 0;
   virtual auto pop_clip() -> void = 0;
-  virtual auto measure_text(std::string_view text, luma::text_style const& style) const -> luma::size = 0;
+  virtual auto measure_text(std::string_view text, luma::text_style const &style) const -> luma::size = 0;
 };
 
 }

include/luma/routing.hpp

@@ -11,19 +11,20 @@
 
 #include <luma/control.hpp>
 
+
 namespace luma {
 
 class router {
 public:
   auto register_route(std::string name, std::function<std::expected<std::unique_ptr<luma::control>, modulus::error>()> factory) -> std::expected<void, modulus::error>;
   auto set_retire_handler(std::function<void(std::unique_ptr<luma::control>)> handler) -> void;
-  auto replace(std::string const& name) -> std::expected<void, modulus::error>;
-  auto push(std::string const& name) -> std::expected<void, modulus::error>;
+  auto replace(std::string const &name) -> std::expected<void, modulus::error>;
+  auto push(std::string const &name) -> std::expected<void, modulus::error>;
   auto pop() -> std::expected<void, modulus::error>;
   auto clear_stack() -> void;
-  auto current() -> luma::control*;
-  auto current() const -> luma::control const*;
-  auto current_route() const -> std::string const&;
+  auto current() -> luma::control *;
+  auto current() const -> luma::control const *;
+  auto current_route() const -> std::string const &;
 private:
   struct entry {
     std::string name{};

include/luma/theme.hpp

@@ -8,6 +8,7 @@
 
 #include <modulus.hpp>
 
+
 namespace luma {
 
 struct color {
@@ -38,12 +39,12 @@ struct theme {
 };
 
 auto default_theme() -> luma::theme;
-auto validate(luma::text_style const& style) -> std::expected<void, modulus::error>;
-auto validate(luma::theme const& theme) -> std::expected<void, modulus::error>;
-auto parse_color(boost::json::value const& value) -> std::expected<luma::color, modulus::error>;
-auto parse_theme(boost::json::value const& value) -> std::expected<luma::theme, modulus::error>;
-auto to_json(luma::color const& color) -> boost::json::value;
-auto to_json(luma::text_style const& style) -> boost::json::value;
-auto to_json(luma::theme const& theme) -> boost::json::value;
+auto validate(luma::text_style const &style) -> std::expected<void, modulus::error>;
+auto validate(luma::theme const &theme) -> std::expected<void, modulus::error>;
+auto parse_color(boost::json::value const &value) -> std::expected<luma::color, modulus::error>;
+auto parse_theme(boost::json::value const &value) -> std::expected<luma::theme, modulus::error>;
+auto to_json(luma::color const &color) -> boost::json::value;
+auto to_json(luma::text_style const &style) -> boost::json::value;
+auto to_json(luma::theme const &theme) -> boost::json::value;
 
 }

include/luma/window.hpp

@@ -13,6 +13,7 @@
 #include <luma/control.hpp>
 #include <luma/geometry.hpp>
 
+
 namespace luma {
 
 class window_manager;
@@ -27,17 +28,17 @@ struct window_options {
 
 class window {
 public:
-  window(luma::window const&) = delete;
-  window(luma::window&&) noexcept = default;
-  auto operator=(luma::window const&) -> luma::window& = delete;
-  auto operator=(luma::window&&) noexcept -> luma::window& = default;
+  window(luma::window const &) = delete;
+  window(luma::window &&) noexcept = default;
+  auto operator=(luma::window const &) -> luma::window & = delete;
+  auto operator=(luma::window &&) noexcept -> luma::window & = default;
   auto id() const -> std::uint64_t;
-  auto options() const -> luma::window_options const&;
+  auto options() const -> luma::window_options const &;
   auto set_bounds(luma::rect bounds) -> std::expected<void, modulus::error>;
   auto set_visible(std::bool_t value) -> void;
   auto visible() const -> std::bool_t;
-  auto content() -> luma::control*;
-  auto content() const -> luma::control const*;
+  auto content() -> luma::control *;
+  auto content() const -> luma::control const *;
 private:
   friend class luma::window_manager;
   window(std::uint64_t id, luma::window_options options, std::unique_ptr<luma::control> content);
@@ -53,12 +54,12 @@ public:
   auto bring_to_front(std::uint64_t id) -> std::expected<void, modulus::error>;
   auto set_bounds(std::uint64_t id, luma::rect bounds) -> std::expected<void, modulus::error>;
   auto set_visible(std::uint64_t id, std::bool_t visible) -> std::expected<void, modulus::error>;
-  auto find(std::uint64_t id) -> luma::window*;
+  auto find(std::uint64_t id) -> luma::window *;
   auto clear() -> void;
-  auto measure(luma::draw_context& context, luma::theme const& theme, luma::constraints limits) -> luma::size override;
+  auto measure(luma::draw_context &context, luma::theme const &theme, luma::constraints limits) -> luma::size override;
   auto arrange(luma::rect bounds) -> void override;
-  auto draw(luma::draw_context& context, luma::theme const& theme) const -> void override;
-  auto handle_touch(luma::touch_event const& event) -> std::bool_t override;
+  auto draw(luma::draw_context &context, luma::theme const &theme) const -> void override;
+  auto handle_touch(luma::touch_event const &event) -> std::bool_t override;
   auto invalidate_layout() -> void override;
   auto bind_layout_invalidator(std::function<void()> invalidator) -> void override;
 private: