clang 15.0.5 reformat all files

arBmind · arBmind · commit a8319378e7b8 · 2022-12-21T19:41:01.000+01:00
diff --git a/.clang-format b/.clang-format
@@ -64,3 +64,7 @@ PointerAlignment: Left
 PenaltyReturnTypeOnItsOwnLine: 2000
 PenaltyBreakBeforeFirstCallParameter: 100
 PenaltyBreakTemplateDeclaration: 10
+
+RequiresClausePosition: SingleLine
+IndentRequiresClause: false
+BreakBeforeConceptDeclarations: Allowed
diff --git a/script/clang_format_all.sh b/script/clang_format_all.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+THIS_PATH="$(realpath "$0")"
+THIS_DIR="$(dirname "$THIS_PATH")"
+PROJECT_DIR="$(dirname "$THIS_DIR")"
+# echo -e $PROJECT_DIR
+
+FILE_LIST="$(find "$PROJECT_DIR" -not -path '*/googletest/*' | grep -E ".*(\.ino|\.cpp|\.c|\.h|\.hpp|\.hh)$")"
+# echo -e "Files found to format = \n\"\"\"\n$FILE_LIST\n\"\"\""
+
+# note: chunks file_list in 250 entry batches to not exceed path limits
+xargs -n 250 clang-format --verbose -i --style=file --fallback-style=none <<<$FILE_LIST
diff --git a/src/array19.lib/array19/AllocatedArrayOf.h b/src/array19.lib/array19/AllocatedArrayOf.h
@@ -3,8 +3,8 @@
 #include "MoveSliceOf.h"
 #include "SliceOf.single.h"
 
-#include <stddef.h> // size_t
 #include <new> // new allocators
+#include <stddef.h> // size_t
 #include <type_traits> // is_nothrow_*
 
 namespace array19 {
@@ -52,7 +52,8 @@ template<class T> struct AllocatedArrayOf final {
     }
 
     template<class... Ts> requires(sizeof...(Ts) > 0) && requires(Ts&&... args) { (T{(Ts &&) args}, ...); }
-    explicit AllocatedArrayOf(Ts&&... args) : m_pointer(Utils::allocate(sizeof...(Ts))), m_count(0) {
+    explicit AllocatedArrayOf(Ts&&... args) : m_pointer(Utils::allocate(sizeof...(Ts)))
+                                            , m_count(0) {
         (new (m_pointer + m_count++) T{(Ts &&) args}, ...);
     }
 
diff --git a/src/array19.lib/array19/AllocatedArrayOf.test.cpp b/src/array19.lib/array19/AllocatedArrayOf.test.cpp
@@ -1,5 +1,6 @@
-#include "AllocatedArrayOf.equals.h"
 #include "AllocatedArrayOf.h"
+
+#include "AllocatedArrayOf.equals.h"
 #include "AllocatedArrayOf.ostream.h"
 #include "SliceOf.carray.h"
 #include "SliceOf.equals.h"
diff --git a/src/array19.lib/array19/AllocatedArrayUtils.h b/src/array19.lib/array19/AllocatedArrayUtils.h
@@ -2,8 +2,8 @@
 #include "MoveSliceOf.h"
 #include "SliceOf.h"
 
-#include <stddef.h> // size_t
 #include <new> // ::operator new, ::operator delete
+#include <stddef.h> // size_t
 #include <string.h> // memcpy
 #include <type_traits>
 #include <utility>
diff --git a/src/array19.lib/array19/Array.ostream.h b/src/array19.lib/array19/Array.ostream.h
@@ -1,8 +1,8 @@
 #pragma once
 #include "Array.h"
 
-#include <stddef.h> // size_t
 #include <ostream>
+#include <stddef.h> // size_t
 
 namespace array19 {
 
diff --git a/src/array19.lib/array19/DynamicArrayOf.h b/src/array19.lib/array19/DynamicArrayOf.h
@@ -3,8 +3,8 @@
 #include "MoveSliceOf.h"
 #include "SliceOf.single.h"
 
-#include <stddef.h> // size_t
 #include <new> // launder
+#include <stddef.h> // size_t
 
 namespace array19 {
 
@@ -49,7 +49,8 @@ template<class T> struct DynamicArrayOf final {
     }
 
     template<class... Ts> requires(sizeof...(Ts) > 0) && requires(Ts&&... args) { (T{(Ts &&) args}, ...); }
-    explicit DynamicArrayOf(Ts&&... args) : m_pointer(Utils::allocate(sizeof...(Ts))), m_capacity(sizeof...(Ts)) {
+    explicit DynamicArrayOf(Ts&&... args) : m_pointer(Utils::allocate(sizeof...(Ts)))
+                                          , m_capacity(sizeof...(Ts)) {
         (new (m_pointer + m_count++) T{(Ts &&) args}, ...);
     }
 
diff --git a/src/array19.lib/array19/DynamicArrayOf.test.cpp b/src/array19.lib/array19/DynamicArrayOf.test.cpp
@@ -1,6 +1,7 @@
+#include "DynamicArrayOf.h"
+
 #include "Array.h"
 #include "DynamicArrayOf.equals.h"
-#include "DynamicArrayOf.h"
 #include "DynamicArrayOf.ostream.h"
 #include "SliceOf.carray.h"
 #include "SliceOf.equals.h"
diff --git a/src/array19.lib/array19/SliceOf.test.cpp b/src/array19.lib/array19/SliceOf.test.cpp
@@ -1,5 +1,6 @@
-#include "SliceOf.carray.h"
 #include "SliceOf.h"
+
+#include "SliceOf.carray.h"
 #include "SliceOf.store.h"
 
 #include <gtest/gtest.h>
diff --git a/src/array19.lib/array19/Zip.h b/src/array19.lib/array19/Zip.h
@@ -47,6 +47,6 @@ template<class A, class B> struct Zip {
     B* b{};
 };
 
-template<class A, class B> Zip(A&, B&)->Zip<A, B>;
+template<class A, class B> Zip(A&, B&) -> Zip<A, B>;
 
 } // namespace array19
diff --git a/src/array19.lib/array19/Zip.test.cpp b/src/array19.lib/array19/Zip.test.cpp
@@ -1,6 +1,7 @@
-#include "Array.h"
 #include "Zip.h"
 
+#include "Array.h"
+
 using namespace array19;
 
 void constexpr_Zip_test() {
diff --git a/src/enum19.lib/enum19/Enum.h b/src/enum19.lib/enum19/Enum.h
@@ -35,8 +35,7 @@ template<class T> constexpr void metaEnumFor(ADL*, T*) {
 
 template<class T> constexpr auto meta_enum_for = metaEnumFor(adl, nullptr_to<T>);
 
-template<class T>
-concept HasMetaEnum = !std::is_same_v<void, decltype(metaEnumFor(adl, nullptr_to<T>))>;
+template<class T> concept HasMetaEnum = (!std::is_same_v<void, decltype(metaEnumFor(adl, nullptr_to<T>))>);
 
 template<class Enum> struct MetaEnumMember {
     size_t index;
diff --git a/src/enum19.lib/enum19/Enum.names.h b/src/enum19.lib/enum19/Enum.names.h
@@ -23,8 +23,7 @@ constexpr auto unknown_of = [] {
 }();
 
 /// true if v is a known member of the enum
-template<auto v>
-requires(std::is_enum_v<decltype(v)>) constexpr auto is_member = [] {
+template<auto v> requires(std::is_enum_v<decltype(v)>) constexpr auto is_member = [] {
     using T = decltype(v);
     for (auto& m : meta_enum_for<T>.members) {
         if (m.value == v) return true;
@@ -43,17 +42,15 @@ template<class T> requires(std::is_enum_v<T>) constexpr auto valueName(T v) {
 template<auto v> constexpr auto value_name = valueName(v);
 
 /// StringStore of "Enum::"+value_name<v>
-template<auto v>
-requires(std::is_enum_v<decltype(v)>) constexpr auto type_value_name = [] {
+template<auto v> requires(std::is_enum_v<decltype(v)>) constexpr auto type_value_name = [] {
     using T = decltype(v);
     constexpr auto rope = Rope{meta_enum_for<T>.name, viewLiteral("::"), value_name<v>};
     constexpr auto N = ropeCount(rope);
     return ropeStore<N>(rope);
 }();
 
 /// StringStore of value_name<v> + " (xx)" where xx is the decimal representation of v
-template<auto v>
-requires(std::is_enum_v<decltype(v)>) constexpr auto debug_value_name = [] {
+template<auto v> requires(std::is_enum_v<decltype(v)>) constexpr auto debug_value_name = [] {
     using T = decltype(v);
     constexpr auto underlying = static_cast<std::underlying_type_t<T>>(v);
     if constexpr (is_member<v>) {
diff --git a/src/enum19.lib/enum19/Enum.ostream.h b/src/enum19.lib/enum19/Enum.ostream.h
@@ -14,7 +14,9 @@ template<class Enum> auto enumNameOstream(std::ostream& out, const Enum& e) -> s
 }
 
 /// This wrapper enables ADL for ostream operator
-template<class T> requires(std::is_enum_v<T>) struct EnumName { T v; };
+template<class T> requires(std::is_enum_v<T>) struct EnumName {
+    T v;
+};
 template<class T> EnumName(T) -> EnumName<T>;
 
 template<class T> auto operator<<(std::ostream& out, EnumName<T> wrapper) -> std::ostream& {
diff --git a/src/enum19.lib/enum19/Enum.test.cpp b/src/enum19.lib/enum19/Enum.test.cpp
@@ -1,4 +1,5 @@
 #include "Enum.h"
+
 #include "string19/StringView.equals.h"
 #include "string19/StringView.literal.h"
 #include "string19/StringView.ostream.h"
diff --git a/src/lookup19.lib/lookup19/OrderedSliceOf.h b/src/lookup19.lib/lookup19/OrderedSliceOf.h
@@ -31,7 +31,7 @@ template<class T, class Less> struct OrderedSliceOf {
 
     [[nodiscard]] constexpr operator SliceOf<const T>() const noexcept { return SliceOf<const T>{m_data, m_count}; }
 
-    template<class K>[[nodiscard]] constexpr auto lowerBound(K&& key) -> Element* {
+    template<class K> [[nodiscard]] constexpr auto lowerBound(K&& key) -> Element* {
         auto less = Less{};
         auto lower_bound = m_data;
         auto count = m_count;
@@ -48,7 +48,7 @@ template<class T, class Less> struct OrderedSliceOf {
         return lower_bound;
     }
 
-    template<class K>[[nodiscard]] constexpr auto upperBound(K&& key) -> Element* {
+    template<class K> [[nodiscard]] constexpr auto upperBound(K&& key) -> Element* {
         auto less = Less{};
         auto upper_bound = m_data;
         auto count = m_count;
@@ -65,7 +65,7 @@ template<class T, class Less> struct OrderedSliceOf {
         return upper_bound;
     }
 
-    template<class K>[[nodiscard]] constexpr auto equalRange(K&& key) -> OrderedSliceOf {
+    template<class K> [[nodiscard]] constexpr auto equalRange(K&& key) -> OrderedSliceOf {
         auto less = Less{};
         auto count = m_count;
         auto lower_bound = m_data;
diff --git a/src/meta19.lib/meta19/Type.h b/src/meta19.lib/meta19/Type.h
@@ -8,7 +8,9 @@ namespace meta19 {
 /// - nesting Type<Type<X>> is not allowed
 /// - intentionally left without implementation to avoid compiler overhead for that
 template<class> struct Type;
-template<class T> struct Type<Type<T>> { static_assert(sizeof(T) && false, "nested Type!"); };
+template<class T> struct Type<Type<T>> {
+    static_assert(sizeof(T) && false, "nested Type!");
+};
 
 /// type value wrapper for any C++ type
 /// notes:
diff --git a/src/optional19.lib/optional19/Optional.h b/src/optional19.lib/optional19/Optional.h
@@ -90,8 +90,8 @@ template<class T> struct OptionalStorage {
 
 /// simplified specialization if no destructor is required
 /// * storing actual type saves a lot of casting overhead
-template<class T>
-requires(std::is_trivially_default_constructible_v<T>&& std::is_trivially_destructible_v<T>) struct OptionalStorage<T> {
+template<class T> requires(std::is_trivially_default_constructible_v<T> && std::is_trivially_destructible_v<T>)
+struct OptionalStorage<T> {
     T m_value{};
     bool m_valid{};
 
diff --git a/src/optional19.lib/optional19/Optional.ostream.h b/src/optional19.lib/optional19/Optional.ostream.h
@@ -12,4 +12,4 @@ template<class T> auto operator<<(std::ostream& out, const Optional<T>& opt) ->
         return out << "nullopt";
 }
 
-} // namespace optional19
+} // namespace optional19
diff --git a/src/optional19.lib/optional19/Optional.test.cpp b/src/optional19.lib/optional19/Optional.test.cpp
@@ -1,5 +1,6 @@
-#include "Optional.equals.h"
 #include "Optional.h"
+
+#include "Optional.equals.h"
 #include "Optional.ostream.h"
 
 #include <gtest/gtest.h>
diff --git a/src/optional19.lib/optional19/PackedOptional.test.cpp b/src/optional19.lib/optional19/PackedOptional.test.cpp
@@ -1,5 +1,6 @@
-#include "PackedOptional.equals.h"
 #include "PackedOptional.h"
+
+#include "PackedOptional.equals.h"
 #include "PackedOptional.ostream.h"
 
 #include <gtest/gtest.h>
diff --git a/src/optional19.lib/optional19/PackedOptionalNan.test.cpp b/src/optional19.lib/optional19/PackedOptionalNan.test.cpp
@@ -1,6 +1,7 @@
+#include "PackedOptionalNan.h"
+
 #include "PackedOptional.equals.h"
 #include "PackedOptional.ostream.h"
-#include "PackedOptionalNan.h"
 
 #include <gtest/gtest.h>
 
diff --git a/src/partial19.lib/partial19/Partial.h b/src/partial19.lib/partial19/Partial.h
@@ -150,9 +150,7 @@ template<class... Ts> struct Partial {
         auto factory_args = []<class T, class... Xs>(T*, void* ptr, Xs&&... xs) {
             (details::ConditionalPlacementNew<std::is_same_v<T, StoredOf<Xs>>>::apply((Xs &&) xs, ptr), ...);
         };
-        auto factory = [&]<class T>(Type<T>*, void* ptr) {
-            factory_args(nullptr_to<T>, ptr, (Vs&&)vs...);
-        };
+        auto factory = [&]<class T>(Type<T>*, void* ptr) { factory_args(nullptr_to<T>, ptr, (Vs &&) vs...); };
         return fromFactory(hasValue, factory);
     }
 
diff --git a/src/partial19.lib/partial19/Partial.test.cpp b/src/partial19.lib/partial19/Partial.test.cpp
@@ -1,5 +1,6 @@
-#include "Partial.equals.h"
 #include "Partial.h"
+
+#include "Partial.equals.h"
 #include "Partial.ostream.h"
 
 #include <gtest/gtest.h>
diff --git a/src/serialize19.lib/serialize19/Archive.h b/src/serialize19.lib/serialize19/Archive.h
@@ -8,9 +8,10 @@ namespace serialize19 {
 /// - ReadArchive
 /// - SizeArchive
 /// - WriteToArchive
-template<class A> concept Archive = requires(A& a, ArchiveMode& mode, int v) {
-    mode = A::mode;
-    a.withPrimitive(v);
-};
+template<class A>
+concept Archive = requires(A& a, ArchiveMode& mode, int v) {
+                      mode = A::mode;
+                      a.withPrimitive(v);
+                  };
 
 } // namespace serialize19
diff --git a/src/serialize19.lib/serialize19/SizeArchive.h b/src/serialize19.lib/serialize19/SizeArchive.h
@@ -4,8 +4,8 @@
 #include "SizeAppender.h"
 #include "serialize.h"
 
-#include <stddef.h> // size_t
 #include <cstdint>
+#include <stddef.h> // size_t
 
 namespace serialize19 {
 
@@ -33,7 +33,7 @@ static_assert(Archive<SizeArchive>);
 
 // note: SizeArchive wont modify the value, but serialize methods can only have one signature
 // note: Archive is a template argument to allow fallback to Fallback
-template<Archive A, class T> requires(std::is_same_v<A, SizeArchive>&& std::is_const_v<T>) void serialize(A& a, T& v) {
+template<Archive A, class T> requires(std::is_same_v<A, SizeArchive> && std::is_const_v<T>) void serialize(A& a, T& v) {
     serialize(a, const_cast<std::remove_const_t<T>&>(v));
 }
 
diff --git a/src/serialize19.lib/serialize19/WriteToArchive.h b/src/serialize19.lib/serialize19/WriteToArchive.h
@@ -29,8 +29,8 @@ template<EndianBehaviour endian = EndianBehaviour::Keep> struct WriteToArchive {
 static_assert(Archive<WriteToArchive<>>);
 
 // note: Writing wont modify the value, but serialize methods can only have one signature
-template<class T, EndianBehaviour endian>
-requires(std::is_const_v<T>) void serialize(WriteToArchive<endian>& wa, T& v) {
+template<class T, EndianBehaviour endian> requires(std::is_const_v<T>)
+void serialize(WriteToArchive<endian>& wa, T& v) {
     serialize(wa, const_cast<std::remove_const_t<T>&>(v));
 }
 
diff --git a/src/serialize19.lib/serialize19/serialize.Partial.h b/src/serialize19.lib/serialize19/serialize.Partial.h
@@ -2,8 +2,8 @@
 #include "partial19/Partial.h" // requires partial19
 #include "serialize.h"
 
-#include <stddef.h> // size_t
 #include <cstdint>
+#include <stddef.h> // size_t
 
 namespace serialize19 {
 
diff --git a/src/serialize19.lib/serialize19/serialize.h b/src/serialize19.lib/serialize19/serialize.h
@@ -13,7 +13,7 @@ struct SerializeFallback {
 };
 template<class A> void serialize(A&, SerializeFallback) {}
 
-template<class T> concept SerializePrimitive = !std::is_const_v<T> && (std::is_arithmetic_v<T> || std::is_enum_v<T>);
+template<class T> concept SerializePrimitive = (!std::is_const_v<T> && (std::is_arithmetic_v<T> || std::is_enum_v<T>));
 
 template<Archive A, SerializePrimitive V> auto serialize(A& a, V& v) { a.withPrimitive(v); }
 
diff --git a/src/serialize19.lib/serialize19/serialize.std_variant.h b/src/serialize19.lib/serialize19/serialize.std_variant.h
@@ -1,8 +1,8 @@
 #pragma once
 #include "serialize.h"
 
-#include <stddef.h> // size_t
 #include <meta19/nullptr_to.h>
+#include <stddef.h> // size_t
 #include <variant>
 
 namespace serialize19 {
diff --git a/src/signal19.lib/signal19/Subscriptions.test.cpp b/src/signal19.lib/signal19/Subscriptions.test.cpp
@@ -1,6 +1,7 @@
-#include "SignalWith.h"
 #include "Subscriptions.h"
 
+#include "SignalWith.h"
+
 #include <gtest/gtest.h>
 
 using namespace signal19;
diff --git a/src/string19.lib/string19/StringView.test.cpp b/src/string19.lib/string19/StringView.test.cpp
@@ -1,4 +1,5 @@
 #include "StringView.h"
+
 #include "StringView.literal.h"
 
 #include <gtest/gtest.h>
diff --git a/src/strong19.lib/strong19/Strong.h b/src/strong19.lib/strong19/Strong.h
@@ -5,7 +5,7 @@
 #include "string19/StringView.literal.h"
 
 #ifndef Q_MOC_RUN
-#include <compare>
+#    include <compare>
 #endif
 #include <type_traits>
 
@@ -24,9 +24,8 @@ template<class V> struct Weak {
     static_assert(!is_strong<V>);
     V v{};
     constexpr Weak() = default;
-    template<class... Ts>
-    requires(sizeof...(Ts) > 0 && std::is_constructible_v<V, Ts...>) constexpr explicit Weak(Ts&&... ts)
-            : v((Ts &&) ts...) {}
+    template<class... Ts> requires(sizeof...(Ts) > 0 && std::is_constructible_v<V, Ts...>)
+    constexpr explicit Weak(Ts&&... ts) : v((Ts &&) ts...) {}
     bool operator==(const Weak&) const = default;
 };
 
diff --git a/src/strong19.lib/strong19/Strong.hash.h b/src/strong19.lib/strong19/Strong.hash.h
@@ -1,8 +1,8 @@
 #pragma once
 #include "Strong.h"
 
-#include <stddef.h> // size_t
 #include <functional> // std::hash
+#include <stddef.h> // size_t
 
 namespace strong19 {
 
diff --git a/src/strong19.lib/strong19/Strong.ostream.h b/src/strong19.lib/strong19/Strong.ostream.h
diff --git a/src/strong19.lib/strong19/Strong.test.cpp b/src/strong19.lib/strong19/Strong.test.cpp
diff --git a/src/tuple19.lib/tuple19/Tuple.bind.test.cpp b/src/tuple19.lib/tuple19/Tuple.bind.test.cpp
diff --git a/src/tuple19.lib/tuple19/Tuple.test.cpp b/src/tuple19.lib/tuple19/Tuple.test.cpp
diff --git a/src/variant19.lib/variant19/None.test.cpp b/src/variant19.lib/variant19/None.test.cpp
diff --git a/src/variant19.lib/variant19/Variant.h b/src/variant19.lib/variant19/Variant.h
diff --git a/src/variant19.lib/variant19/Variant.test.cpp b/src/variant19.lib/variant19/Variant.test.cpp

Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,8 @@`
`3`	`3`	`#include "MoveSliceOf.h"`
`4`	`4`	`#include "SliceOf.single.h"`
`5`	`5`
`6`		`-#include <stddef.h> // size_t`
`7`	`6`	`#include <new> // launder`
	`7`	`+#include <stddef.h> // size_t`
`8`	`8`
`9`	`9`	`namespace array19 {`
`10`	`10`
`@@ -49,7 +49,8 @@ template<class T> struct DynamicArrayOf final {`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`template<class... Ts> requires(sizeof...(Ts) > 0) && requires(Ts&&... args) { (T{(Ts &&) args}, ...); }`
`52`		`- explicit DynamicArrayOf(Ts&&... args) : m_pointer(Utils::allocate(sizeof...(Ts))), m_capacity(sizeof...(Ts)) {`
	`52`	`+ explicit DynamicArrayOf(Ts&&... args) : m_pointer(Utils::allocate(sizeof...(Ts)))`
	`53`	`+ , m_capacity(sizeof...(Ts)) {`
`53`	`54`	`(new (m_pointer + m_count++) T{(Ts &&) args}, ...);`
`54`	`55`	`}`
`55`	`56`