Further reviewed formatting

Author: Twon

libraries/application/src/morpheus/application/application.cpp

@@ -1,6 +1,6 @@
 #include "morpheus/application/application.hpp"
-#include "morpheus/application/version.hpp"
 #include "morpheus/application/po/options.hpp"
+#include "morpheus/application/version.hpp"
 #include "morpheus/core/base/debugging.hpp"
 #include "morpheus/core/conformance/date.hpp"
 #include "morpheus/core/conformance/format.hpp"
@@ -23,11 +23,12 @@ namespace
 /// \brief Override the default termination handler to print the call stack before exiting the program to aid debugging.
 void terminationHandler()
 {
-    try{
+    try
+    {
         debugPrint(fmt_ns::format("{}", MORPHEUS_CURRENT_STACKTRACE));
     }
-    catch(...){
-
+    catch (...)
+    {
     }
     std::abort();
 }
@@ -48,14 +49,15 @@ void terminationHandler()
 } // namespace
 
 Application::Application(int argc, char const* const* argv)
-: mConfig(
-      [&]
-      {
-          po::Config config;
-          if (auto invalid = parseProgramOptions(argc, argv, po::HelpDocumentation{}, config)) {
-          }
-          return config;
-      }())
+    : mConfig(
+          [&]
+          {
+              po::Config config;
+              if (auto invalid = parseProgramOptions(argc, argv, po::HelpDocumentation{}, config))
+              {
+              }
+              return config;
+          }())
 //`: mLogName(getDefaultApplicationLogName())
 {
     std::set_terminate(terminationHandler);

libraries/application/src/morpheus/application/application.hpp

@@ -29,10 +29,7 @@ class Application
     /// Path to application log file.
     std::filesystem::path getLogPath() const noexcept { return mLogPath; }
 
-    void run()
-    {
-
-    }
+    void run() {}
 
 private:
     po::Config mConfig;             /// Common application configuration

libraries/application/src/morpheus/application/try_catch.hpp

@@ -20,7 +20,7 @@ void tryCatch(std::invocable auto f)
     {
         BOOST_LOG_TRIVIAL(error) << "Exception caught: " << ex.what() << std::endl << st_ns::stacktrace::current();
     }
-    catch(...)
+    catch (...)
     {
         BOOST_LOG_TRIVIAL(error) << "Unknown exception!\n" << st_ns::stacktrace::current();
     }

libraries/application/tests/po/adapters/boost/log.tests.cpp

@@ -46,7 +46,7 @@ TEST_CASE_METHOD(BoostLogFixture, "Test parsing of boost log types as program op
         auto getLogLevel = [](std::string_view param)
         {
             Logging logging{};
-            std::array cliOptions = { "dummyProgram.exe", "--log-level", param.data() };
+            std::array cliOptions = {"dummyProgram.exe", "--log-level", param.data()};
             auto const result = parseProgramOptions(static_cast<int>(cliOptions.size()), cliOptions.data(), HelpDocumentation{}, logging);
             REQUIRE(!result);
             return logging.logLevel;
@@ -73,7 +73,7 @@ TEST_CASE_METHOD(BoostLogFixture, "Test parsing of boost log types as program op
     }
     SECTION("Ensure invalid value parse correctly")
     {
-        std::array cliOptions = { "dummyProgram.exe", "--log-level", "invalid"};
+        std::array cliOptions = {"dummyProgram.exe", "--log-level", "invalid"};
         Logging logging;
         auto const result = parseProgramOptions(static_cast<int>(cliOptions.size()), cliOptions.data(), HelpDocumentation{}, logging);
         REQUIRE(result);

libraries/application/tests/po/adapters/std/filesystem.tests.cpp

@@ -12,8 +12,8 @@
 #include <array>
 #include <filesystem>
 #include <optional>
-#include <string_view>
 #include <string>
+#include <string_view>
 
 namespace morpheus::application::po
 {
@@ -39,13 +39,12 @@ TEST_CASE_METHOD(LoggingFixture, "Test parsing of std filesystem path as options
         auto getPath = [](std::string_view param)
         {
             Filesystem filesystem{};
-            std::array cliOptions = { "dummyProgram.exe", "--path", param.data() };
+            std::array cliOptions = {"dummyProgram.exe", "--path", param.data()};
             auto const result = parseProgramOptions(static_cast<int>(cliOptions.size()), cliOptions.data(), HelpDocumentation{}, filesystem);
             REQUIRE(!result);
             return filesystem.path;
         };
 
-
         auto const exeLocation = boost::dll::program_location().parent_path();
         REQUIRE(getPath(".") == std::filesystem::path("."));
         REQUIRE(getPath("..") == std::filesystem::path(".."));
@@ -57,7 +56,6 @@ TEST_CASE_METHOD(LoggingFixture, "Test parsing of std filesystem path as options
         // https://github.com/boostorg/program_options/issues/69
         REQUIRE(getPath("/home/user/path with spaces/.") == std::filesystem::path("/home/user/path with spaces/."));
     }
-
 }
 
 } // namespace morpheus::application::po

libraries/application/tests/po/options.tests.cpp

@@ -12,8 +12,8 @@
 #include <cstdint>
 #include <iostream>
 #include <optional>
-#include <string_view>
 #include <string>
+#include <string_view>
 #include <utility>
 
 namespace morpheus::application::po
@@ -87,7 +87,7 @@ TEST_CASE_METHOD(LoggingFixture, "Ensure options parsing of native types works",
         }
         WHEN("Parsing invalid parameters because the first parameter is not a program name")
         {
-            std::array const cliOptions = { "--first-name", "John", "--surname", "Doe", "--age", "42", "--year-of-birth", "1980", "--alive", "true" };
+            std::array const cliOptions = {"--first-name", "John", "--surname", "Doe", "--age", "42", "--year-of-birth", "1980", "--alive", "true"};
             // RedirectStream captureErrors(std::cerr); Capture error logging
             auto const result = parseProgramOptions(static_cast<int>(cliOptions.size()), cliOptions.data(), HelpDocumentation{}, person);
             THEN("Expect no error results and valid values extracted")
@@ -97,7 +97,7 @@ TEST_CASE_METHOD(LoggingFixture, "Ensure options parsing of native types works",
         }
         WHEN("Requesting the help text is displayed")
         {
-            std::array const cliOptions = { "dummyProgram.exe", "-h" };
+            std::array const cliOptions = {"dummyProgram.exe", "-h"};
             auto findOption = captureOutput(cliOptions, HelpDocumentation{}, person);
             THEN("Expect output to be successfully prints to screen")
             {
@@ -111,9 +111,9 @@ TEST_CASE_METHOD(LoggingFixture, "Ensure options parsing of native types works",
         }
         WHEN("Requesting the help text is displayed when providing a version")
         {
-            std::array const cliOptions = { "dummyProgram.exe", "-h" };
+            std::array const cliOptions = {"dummyProgram.exe", "-h"};
             HelpDocumentation helpWithVersion;
-            helpWithVersion.version = Version{ 1, 0, 0 };
+            helpWithVersion.version = Version{1, 0, 0};
             auto findOption = captureOutput(cliOptions, helpWithVersion, person);
             THEN("Expect output to be successfully prints to screen with version option")
             {
@@ -128,7 +128,7 @@ TEST_CASE_METHOD(LoggingFixture, "Ensure options parsing of native types works",
         }
         WHEN("Requesting the help text is displayed with multiple options objects")
         {
-            std::array const cliOptions = { "dummyProgram.exe", "-h" };
+            std::array const cliOptions = {"dummyProgram.exe", "-h"};
 
             struct Extra
             {

libraries/core/src/morpheus/core/base/debugging.cpp

@@ -24,7 +24,10 @@ void breakpoint_if_debugging() noexcept
         breakpoint();
 }
 
-bool is_debugger_present() noexcept { return boost::debug::under_debugger(); }
+bool is_debugger_present() noexcept
+{
+    return boost::debug::under_debugger();
+}
 
 void debugPrint(std::string_view const message)
 {

libraries/core/src/morpheus/core/base/scoped_action.hpp

@@ -29,8 +29,7 @@ class HoldReturnType;
 ///     Specialisation for entry action with a void return type.
 template <>
 class HoldReturnType<void>
-{
-};
+{};
 
 /// \class HoldReturnType
 ///     Holding type to own the return value of an entry action to a scoped action.
@@ -76,7 +75,8 @@ template <std::invocable EntryAction, std::invocable ExitAction>
 class [[nodiscard, maybe_unused]] ScopedAction : public detail::HoldReturnType<std::invoke_result_t<EntryAction>>
 {
 public:
-    constexpr ScopedAction(EntryAction onEntry, ExitAction onExit) : mAction(std::move(onExit))
+    constexpr ScopedAction(EntryAction onEntry, ExitAction onExit)
+        : mAction(std::move(onExit))
     {
         if constexpr (std::is_same_v<std::invoke_result_t<EntryAction>, void>)
             onEntry();

libraries/core/src/morpheus/core/functional/concepts/function.hpp

@@ -11,7 +11,7 @@ namespace morpheus::functional::concepts
 ///     <a href="https://eel.is/c++draft/func.require">[func.require]</a>, details at
 ///     <a href="https://en.cppreference.com/w/cpp/named_req/FunctionObject">FunctionObject</a>.
 template <typename T, typename... Args>
-concept Function = requires(T t){
+concept Function = requires(T t) {
     requires std::is_object_v<T>;
     requires std::invocable<T, Args...>;
 };

libraries/core/src/morpheus/core/functional/function_ref.hpp

@@ -98,49 +98,49 @@ class function_ref<Return(Args...)>
     template <class F>
     function_ref(F* f) noexcept
     requires std::is_function_v<F> and isInvokableWith<F>
-    : mInvoke([](Storage storage, Args... args) noexcept(isNoexcept) { return invoke(function_ref::get<F>(storage), std::forward<Args>(args)...); })
-    , mStorage(f)
+        : mInvoke([](Storage storage, Args... args) noexcept(isNoexcept) { return invoke(function_ref::get<F>(storage), std::forward<Args>(args)...); })
+        , mStorage(f)
     {}
 
     template <auto F>
     constexpr function_ref(nontype_t<F>) noexcept
-    : mInvoke([](Storage, Args... args) noexcept(isNoexcept) { return invoke(F, std::forward<Args>(args)...); })
+        : mInvoke([](Storage, Args... args) noexcept(isNoexcept) { return invoke(F, std::forward<Args>(args)...); })
     {}
 
     template <auto F, class T>
     constexpr function_ref(nontype_t<F>, T& object) noexcept
-        requires isInvokableWith<decltype(F), T&>
-    : mInvoke(
-          [](Storage storage, Args... args) noexcept(isNoexcept) -> Return
-          {
-              auto& objectStorage = *function_ref::get<constness<T>>(storage);
-              return invoke(F, objectStorage, std::forward<Args>(args)...);
-          })
-    , mStorage(std::addressof(object))
+    requires isInvokableWith<decltype(F), T&>
+        : mInvoke(
+              [](Storage storage, Args... args) noexcept(isNoexcept) -> Return
+              {
+                  auto& objectStorage = *function_ref::get<constness<T>>(storage);
+                  return invoke(F, objectStorage, std::forward<Args>(args)...);
+              })
+        , mStorage(std::addressof(object))
     {}
 
     template <auto F, class T>
     constexpr function_ref(nontype_t<F>, constness<T> const* object) noexcept
-        requires isInvokableWith<decltype(F), constness<T> const*>
-    : mInvoke(
-          [](Storage storage, Args... args) noexcept(isNoexcept) -> Return
-          {
-              constness<T>& objectStorage = *function_ref::get<T>(storage);
-              return invoke(F, objectStorage, std::forward<Args>(args)...);
-          })
-    , mStorage(std::addressof(object))
+    requires isInvokableWith<decltype(F), constness<T> const*>
+        : mInvoke(
+              [](Storage storage, Args... args) noexcept(isNoexcept) -> Return
+              {
+                  constness<T>& objectStorage = *function_ref::get<T>(storage);
+                  return invoke(F, objectStorage, std::forward<Args>(args)...);
+              })
+        , mStorage(std::addressof(object))
     {}
 
     template <class F, class T = std::remove_reference_t<F>>
     constexpr function_ref(F&& f) noexcept
-        requires(not std::is_same_v<F, function_ref> and not std::is_member_pointer_v<F> and isInvokableWith<F, constness<T>>)
-    : mInvoke(
-          [](Storage storage, Args... args) noexcept(isNoexcept) -> Return
-          {
-              constness<T>& objectStorage = *function_ref::get<T>(storage);
-              return invoke(objectStorage, std::forward<Args>(args)...);
-          })
-    , mStorage(std::addressof(f))
+    requires(not std::is_same_v<F, function_ref> and not std::is_member_pointer_v<F> and isInvokableWith<F, constness<T>>)
+        : mInvoke(
+              [](Storage storage, Args... args) noexcept(isNoexcept) -> Return
+              {
+                  constness<T>& objectStorage = *function_ref::get<T>(storage);
+                  return invoke(objectStorage, std::forward<Args>(args)...);
+              })
+        , mStorage(std::addressof(f))
     {}
 
     template <typename F, class T = std::remove_reference_t<F>>
@@ -167,17 +167,20 @@ class function_ref<Return(Args...)>
 
         template <class T>
         requires std::is_object_v<T>
-        constexpr explicit Storage(T* t) noexcept : p(t)
+        constexpr explicit Storage(T* t) noexcept
+            : p(t)
         {}
 
         template <class T>
         requires std::is_object_v<T>
-        constexpr explicit Storage(T const* t) noexcept : cp(t)
+        constexpr explicit Storage(T const* t) noexcept
+            : cp(t)
         {}
 
         template <class F>
         requires std::is_function_v<F>
-        constexpr explicit Storage(F* f) noexcept : fp(f)
+        constexpr explicit Storage(F* f) noexcept
+            : fp(f)
         {}
     };