Further formattings

Author: Twon

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

@@ -15,7 +15,8 @@ namespace morpheus::application
 ///
 ///
 // template<typename T>
-class Application {
+class Application
+{
 public:
     ///
     /// \param[in] argc The number of command line arguments.
@@ -34,7 +35,7 @@ class Application {
     }
 
 private:
-    po::Config mConfig; /// Common application configuration
+    po::Config mConfig;             /// Common application configuration
     std::filesystem::path mLogPath; /// Path to application log file.
 };
 

libraries/application/src/morpheus/application/po/adapters/boost/asio.hpp

@@ -6,8 +6,8 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/any.hpp>
 #include <boost/asio/ip/tcp.hpp>
-#include <boost/system/error_code.hpp>
 #include <boost/program_options.hpp>
+#include <boost/system/error_code.hpp>
 
 #include <string>
 #include <vector>

libraries/application/src/morpheus/application/po/adapters/boost/log.hpp

@@ -1,20 +1,21 @@
 #pragma once
 
 // IWYU pragma: always_keep
-#include <boost/any.hpp>
 #include <boost/algorithm/string.hpp>
+#include <boost/any.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/program_options.hpp>
 
 #include <string>
 #include <vector>
 
-
-namespace boost {
+namespace boost
+{
 
 BOOST_LOG_OPEN_NAMESPACE
 
-namespace trivial {
+namespace trivial
+{
 
 template <class CharType>
 void validate(boost::any& v, std::vector<std::basic_string<CharType>> const& values, severity_level*, int)
@@ -40,8 +41,8 @@ void validate(boost::any& v, std::vector<std::basic_string<CharType>> const& val
         throw po::validation_error(po::validation_error::invalid_option_value);
 }
 
-}
+} // namespace trivial
 
 BOOST_LOG_CLOSE_NAMESPACE
 
-} // namespace boost::log::trivial
+} // namespace boost

libraries/application/src/morpheus/application/po/adapters/scannable.hpp

@@ -14,7 +14,7 @@ namespace boost
 {
 
 template <class CharType, typename S>
-requires  morpheus::meta::concepts::Scannable<S, CharType>
+requires morpheus::meta::concepts::Scannable<S, CharType>
 void validate(boost::any& v, std::vector<std::basic_string<CharType>> const& values, S*, int)
 {
     namespace po = boost::program_options;

libraries/application/src/morpheus/application/po/options.hpp

@@ -18,8 +18,8 @@
     #pragma GCC diagnostic pop
 #endif // (MORPHEUS_COMPILER == MORPHEUS_GNUC_COMPILER)
 
-#include <iostream>
 #include <filesystem>
+#include <iostream>
 #include <optional>
 #include <span>
 
@@ -38,17 +38,17 @@ concept CustomProgramOptions = requires(T& t, boost::program_options::options_de
 ///     Holds common help documentation information for applications.
 struct HelpDocumentation
 {
-    std::string_view name; ///< The name of the application, typically the executable name.
-    std::string_view synopsis; ///< A brief synopsis of the application, typically a one-liner describing its purpose.
+    std::string_view name;          ///< The name of the application, typically the executable name.
+    std::string_view synopsis;      ///< A brief synopsis of the application, typically a one-liner describing its purpose.
     std::optional<Version> version; ///< The version of the application, if available.
 };
 
 std::optional<int> parseProgramOptions(int argc, char const* const* argv, HelpDocumentation const& msgDetails, CustomProgramOptions auto&... options)
 {
-    return parseProgramOptions(std::span<char const * const>{argv, static_cast<std::size_t>(argc)}, msgDetails, options...);
+    return parseProgramOptions(std::span<char const* const>{argv, static_cast<std::size_t>(argc)}, msgDetails, options...);
 }
 
-std::optional<int> parseProgramOptions(std::span<char const * const> parameters, HelpDocumentation const& msgDetails, CustomProgramOptions auto&... options)
+std::optional<int> parseProgramOptions(std::span<char const* const> parameters, HelpDocumentation const& msgDetails, CustomProgramOptions auto&... options)
 {
     namespace po = boost::program_options;
     try
@@ -94,5 +94,4 @@ std::optional<int> parseProgramOptions(std::span<char const * const> parameters,
     return std::nullopt;
 }
 
-
 } // namespace morpheus::application::po

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

@@ -10,16 +10,16 @@ namespace morpheus::functional
 ///     Starting point or an overload type build of lambdas
 /// \note
 ///     Following the example of https://www.modernescpp.com/index.php/visiting-a-std-variant-with-the-overload-pattern
-template<typename... Ts>
+template <typename... Ts>
 struct Overload : std::remove_cvref_t<Ts>...
 {
     using std::remove_cvref_t<Ts>::operator()...;
 };
 
-template<class... Ts>
+template <class... Ts>
 Overload(Ts...) -> Overload<Ts...>;
 
-template<class... Ts>
+template <class... Ts>
 auto makeVisitor(Ts&&... ts)
 {
     return Overload<Ts...>(std::forward<Ts>(ts)...);

libraries/core/src/morpheus/core/serialisation/binary_writer.hpp

@@ -5,8 +5,8 @@
 #include "morpheus/core/serialisation/concepts/writer_archetype.hpp"
 #include "morpheus/core/serialisation/exceptions.hpp"
 
-#include <cstdint>
 #include <cstddef>
+#include <cstdint>
 #include <iosfwd>
 #include <optional>
 #include <span>
@@ -76,8 +76,8 @@ class BinaryWriter
         // https://stackoverflow.com/questions/24482028/why-is-stdstreamsize-defined-as-signed-rather-than-unsigned
         auto const writtenSize = static_cast<std::size_t>(mOutStream.rdbuf()->sputn(reinterpret_cast<const char*>(&value), sizeof(value)));
         if (writtenSize != sizeof(value))
-            throwBinaryException(fmt_ns::format("Error writing data to stream.  Attempted to write {} bytes, but only {} bytes were written.", sizeof(value),
-                                 writtenSize));
+            throwBinaryException(
+                fmt_ns::format("Error writing data to stream.  Attempted to write {} bytes, but only {} bytes were written.", sizeof(value), writtenSize));
     }
 
     /// \copydoc morpheus::serialisation::concepts::WriterArchetype::write(std::string_view const)
@@ -100,8 +100,8 @@ class BinaryWriter
 
         auto const writtenSize = static_cast<std::size_t>(mOutStream.rdbuf()->sputn(reinterpret_cast<const char*>(value.data()), value.size()));
         if (writtenSize != value.size())
-            throwBinaryException(fmt_ns::format("Error writing data to stream.  Attempted to write {} bytes, but only {} bytes were written.", value.size(),
-                                 writtenSize));
+            throwBinaryException(
+                fmt_ns::format("Error writing data to stream.  Attempted to write {} bytes, but only {} bytes were written.", value.size(), writtenSize));
     }
 
     /// Write a string literal to the serialisation.

libraries/core/src/morpheus/core/serialisation/exceptions.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "morpheus/core/base/export.hpp"
 #include "morpheus/core/base/cold.hpp"
+#include "morpheus/core/base/export.hpp"
 
 #include <stdexcept>
 #include <string>

libraries/core/tests/conformance/scan.tests.cpp

@@ -28,4 +28,4 @@ TEST_CASE("Ensure scan is supported and working", "[morpheus.conformance.scan]")
     }
 }
 
-} // morpheus
+} // namespace morpheus

libraries/core/tests/conformance/stacktrace.tests.cpp

@@ -28,4 +28,4 @@ TEST_CASE("Ensure stacktrace is supported and working", "[morpheus.conformance.s
     }
 }
 
-}
+} // namespace morpheus