Lots of minor formatting ammendmends

Author: Twon

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

@@ -21,7 +21,6 @@ namespace morpheus
     #define MORPHEUS_ASSERT_ENABLED
 #endif
 
-
 #if defined(MORPHEUS_ASSERT_ENABLED)
     #define MORPHEUS_ASSERT_HANDLER(type, expr, msg) MORPHEUS_VERIFY_HANDLER(type, expr, msg)
 #else

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

@@ -60,6 +60,4 @@ enum class MORPHEUSCORE_EXPORT AssertType
 MORPHEUSCORE_EXPORT void assertHandler(AssertType type, sl_ns::source_location const location, std::string_view const expr,
                                        std::string_view message = std::string_view());
 
-
-
 } // namespace morpheus

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

@@ -2,7 +2,7 @@
 #pragma once
 
 #include <morpheus/core/base/cold.hpp>
-#include <morpheus/core/conformance/format.hpp> // IWYU pragma: export
+#include <morpheus/core/conformance/format.hpp>     // IWYU pragma: export
 #include <morpheus/core/conformance/stacktrace.hpp> // IWYU pragma: export
 
 #include <boost/exception/detail/error_info_impl.hpp>
@@ -28,14 +28,12 @@ using ExceptionInfo = boost::error_info<struct tag_stacktrace, st_ns::stacktrace
 ///      Format string specifying message output.
 /// \param[in] args
 ///     Arguments to be fed into the formatted message output
-template<class... Args>
+template <class... Args>
 [[noreturn]] MORPHEUS_FUNCTION_COLD void throwRuntimeException(fmt_ns::format_string<Args...> fmt, Args&&... args)
 {
     // Defect report https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2905r2.html resolves make_format_args to only accept l-values.
     throwRuntimeException(fmt_ns::vformat(fmt.get(), fmt_ns::make_format_args(args...)));
 }
 /// @}
 
-
-
 } // namespace morpheus

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

@@ -3,7 +3,8 @@
 #include <morpheus/core/base/assert_handler.hpp>
 
 #define MORPHEUS_VERIFY_HANDLER(type, expr, msg)                                                                                                               \
-    do {                                                                                                                                                       \
+    do                                                                                                                                                         \
+    {                                                                                                                                                          \
         if ((!static_cast<bool>(expr))) [[unlikely]]                                                                                                           \
             assertHandler(type, MORPHEUS_CURRENT_LOCATION, #expr, msg);                                                                                        \
     }                                                                                                                                                          \
@@ -13,7 +14,7 @@
 ///     Helper macro to verify an expression succeeds.
 /// \param[in] expr
 ///     Expression to verify
-#define MORPHEUS_VERIFY(expr)          MORPHEUS_VERIFY_HANDLER(AssertType::Verify, expr, {})
+#define MORPHEUS_VERIFY(expr) MORPHEUS_VERIFY_HANDLER(AssertType::Verify, expr, {})
 
 /// \def MORPHEUS_VERIFY_MSG
 ///     Helper macro to verify an expression succeeds and print a message on failure.

libraries/core/src/morpheus/core/concurrency/generator.hpp

@@ -22,10 +22,10 @@ struct Generator
 {
 
     struct promise_type;
-    using handle_type = coro_ns::coroutine_handle<promise_type>; ///< Handle to generator coroutines.
-    using value_type = T;                                        ///< Value type from resulting generation.
+    using handle_type = coro_ns::coroutine_handle<promise_type>;                        ///< Handle to generator coroutines.
+    using value_type = T;                                                               ///< Value type from resulting generation.
     using reference = std::conditional_t<std::is_reference_v<T>, T, const value_type&>; ///< Reference type to the value type.
-    using pointer = std::add_pointer_t<reference>; ///< Pointer type to the value type.
+    using pointer = std::add_pointer_t<reference>;                                      ///< Pointer type to the value type.
 
     Generator(handle_type h) : coro(h) {}
 
@@ -57,7 +57,7 @@ struct Generator
 
         auto return_void() { return coro_ns::suspend_never{}; }
 
-        template<std::convertible_to<T> From>
+        template <std::convertible_to<T> From>
         auto yield_value(From&& from)
         {
             current_value = std::forward<From>(from);
@@ -75,8 +75,8 @@ struct Generator
     {
     public:
         using value_type = Generator::value_type; ///< Value type pointed to by the iterator.
-        using reference = Generator::reference; ///< Reference to the underlying value type pointed to by the iterator.
-        using pointer = Generator::pointer;     ///< Pointer to the underlying value type pointed to by the iterator.
+        using reference = Generator::reference;   ///< Reference to the underlying value type pointed to by the iterator.
+        using pointer = Generator::pointer;       ///< Pointer to the underlying value type pointed to by the iterator.
         using difference_type = std::ptrdiff_t;
         using iterator_category = std::input_iterator_tag;
 

libraries/core/src/morpheus/core/containers/concepts/allocator_aware.hpp

@@ -13,7 +13,7 @@ namespace morpheus::containers::concepts
 ///     <a href="https://eel.is/c++draft/container.alloc.reqmts">[container.alloc.reqmts]</a>, details at
 ///     <a href="https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer">AllocatorAwareContainer</a>.
 template <typename X>
-concept AllocatorAware = Container<X> && requires(X x, X&& rx, typename X::allocator_type a){
+concept AllocatorAware = Container<X> && requires(X x, X&& rx, typename X::allocator_type a) {
     requires std::same_as<typename X::allocator_type::value_type, typename X::value_type>;
     requires std::default_initializable<X>;
     { X(a) };

libraries/core/src/morpheus/core/containers/concepts/contiguous.hpp

@@ -13,7 +13,7 @@ namespace morpheus::containers::concepts
 ///     <a href="https://eel.is/c++draft/container.requirements.general">[container.requirements.general]</a>, details at
 ///     <a href="https://en.cppreference.com/w/cpp/named_req/ContiguousContainer">ContiguousContainer</a>.
 template <typename T>
-concept Contiguous = StrictSequence<T> && requires(T t){
+concept Contiguous = StrictSequence<T> && requires(T t) {
     requires std::contiguous_iterator<typename T::iterator>;
     requires std::contiguous_iterator<typename T::const_iterator>;
 };

libraries/core/src/morpheus/core/containers/unordered_dense.hpp

@@ -12,46 +12,49 @@ namespace morpheus::containers
 /// \struct string_hash
 ///     Defines a hasher for string which enable heterogeneous overloads as outlined at
 ///     <a href="https://github.com/martinus/unordered_dense?tab=readme-ov-file#324-heterogeneous-overloads-using-is_transparent ">unordered_dense</a>
-struct string_hash {
+struct string_hash
+{
     using is_transparent = void; ///< Enable heterogeneous overloads
     using is_avalanching = void; ///< Mark class as high quality avalanching hash
 
-    [[nodiscard]] auto operator()(std::string_view str) const noexcept -> std::uint64_t {
-        return ankerl::unordered_dense::hash<std::string_view>{}(str);
-    }
+    [[nodiscard]] auto operator()(std::string_view str) const noexcept -> std::uint64_t { return ankerl::unordered_dense::hash<std::string_view>{}(str); }
 };
 
 namespace details
 {
 
-template<typename K, typename V>
-struct UnorderdDenseMap {
+template <typename K, typename V>
+struct UnorderdDenseMap
+{
     using type = ankerl::unordered_dense::map<K, V>;
 };
 
-template<typename V>
-struct UnorderdDenseMap<std::string, V> {
+template <typename V>
+struct UnorderdDenseMap<std::string, V>
+{
     using type = ankerl::unordered_dense::map<std::string, V, string_hash, std::equal_to<>>;
 };
 
-template<typename V>
-struct UnorderdDenseSet {
+template <typename V>
+struct UnorderdDenseSet
+{
     using type = ankerl::unordered_dense::set<V>;
 };
 
-template<>
-struct UnorderdDenseSet<std::string> {
+template <>
+struct UnorderdDenseSet<std::string>
+{
     using type = ankerl::unordered_dense::set<std::string, string_hash, std::equal_to<>>;
 };
 
-}
+} // namespace details
 
 /// Helper alias which ensure users get heterogeneous overloads where possible.
-template<typename K, typename V>
+template <typename K, typename V>
 using UnorderedMap = typename details::UnorderdDenseMap<K, V>::type;
 
 /// Helper alias which ensure users get heterogeneous overloads where possible.
-template<typename V>
-using UnorderedSet = typename details::UnorderdDenseSet< V>::type;
+template <typename V>
+using UnorderedSet = typename details::UnorderdDenseSet<V>::type;
 
-}
+} // namespace morpheus::containers

libraries/core/src/morpheus/core/conversion/string.hpp

@@ -13,14 +13,14 @@ namespace morpheus::conversion
 ///     A class template the represents a customisation point to specialise to provide conversion between a type and
 ///     its string representation.
 /// \tparam T The type to convert to and from a string.
-template<typename T>
+template <typename T>
 struct StringConverter
 {
     /// A deleted constructor indicates a disabled string converter
     StringConverter() = delete;
 };
 
-template<typename T>
+template <typename T>
 concept StringConvertionEnabled = std::is_constructible_v<StringConverter<T>>;
 
 /// Convert a value of type T to its string representation.

libraries/core/src/morpheus/core/memory/concepts/copier.hpp

@@ -11,9 +11,7 @@ namespace morpheus::memory::concepts
 template <typename T, typename C>
 concept Copier = requires(T t, C c) {
     typename T::deleter_type;
-    {
-        t(c)
-    } -> std::same_as<C*>;
+    { t(c) } -> std::same_as<C*>;
 };
 
 /// \struct default_copy