Style: clang-format: Disable KeepEmptyLinesAtTheStartOfBlocks

Which means that reduz' beloved style which we all became used to
will now be changed automatically to remove the first empty line.

This makes us lean closer to 1TBS (the one true brace style) instead
of hybridating it with some Allman-inspired spacing.

There's still the case of braces around single-statement blocks that
needs to be addressed (but clang-format can't help with that, but
clang-tidy may if we agree about it).

Part of #33027.

1 files changed, 0 insertions, 28 deletions

diff --git a/core/sort_array.h b/core/sort_array.h
index 8aff0fb502..2dd7c20eae 100644
--- a/core/sort_array.h
+++ b/core/sort_array.h
@@ -42,7 +42,6 @@
 
 template <class T>
 struct _DefaultComparator {
-
 	_FORCE_INLINE_ bool operator()(const T &a, const T &b) const { return (a < b); }
 };
 
@@ -54,7 +53,6 @@ struct _DefaultComparator {
 
 template <class T, class Comparator = _DefaultComparator<T>, bool Validate = SORT_ARRAY_VALIDATE_ENABLED>
 class SortArray {
-
 	enum {
 
 		INTROSORT_THRESHOLD = 16
@@ -64,7 +62,6 @@ public:
 	Comparator compare;
 
 	inline const T &median_of_3(const T &a, const T &b, const T &c) const {
-
 		if (compare(a, b))
 			if (compare(b, c))
 				return b;
@@ -90,10 +87,8 @@ public:
 	/* Heap / Heapsort functions */
 
 	inline void push_heap(int p_first, int p_hole_idx, int p_top_index, T p_value, T *p_array) const {
-
 		int parent = (p_hole_idx - 1) / 2;
 		while (p_hole_idx > p_top_index && compare(p_array[p_first + parent], p_value)) {
-
 			p_array[p_first + p_hole_idx] = p_array[p_first + parent];
 			p_hole_idx = parent;
 			parent = (p_hole_idx - 1) / 2;
@@ -102,22 +97,18 @@ public:
 	}
 
 	inline void pop_heap(int p_first, int p_last, int p_result, T p_value, T *p_array) const {
-
 		p_array[p_result] = p_array[p_first];
 		adjust_heap(p_first, 0, p_last - p_first, p_value, p_array);
 	}
 	inline void pop_heap(int p_first, int p_last, T *p_array) const {
-
 		pop_heap(p_first, p_last - 1, p_last - 1, p_array[p_last - 1], p_array);
 	}
 
 	inline void adjust_heap(int p_first, int p_hole_idx, int p_len, T p_value, T *p_array) const {
-
 		int top_index = p_hole_idx;
 		int second_child = 2 * p_hole_idx + 2;
 
 		while (second_child < p_len) {
-
 			if (compare(p_array[p_first + second_child], p_array[p_first + (second_child - 1)]))
 				second_child--;
 
@@ -134,9 +125,7 @@ public:
 	}
 
 	inline void sort_heap(int p_first, int p_last, T *p_array) const {
-
 		while (p_last - p_first > 1) {
-
 			pop_heap(p_first, p_last--, p_array);
 		}
 	}
@@ -156,7 +145,6 @@ public:
 	}
 
 	inline void partial_sort(int p_first, int p_last, int p_middle, T *p_array) const {
-
 		make_heap(p_first, p_middle, p_array);
 		for (int i = p_middle; i < p_last; i++)
 			if (compare(p_array[i], p_array[p_first]))
@@ -165,7 +153,6 @@ public:
 	}
 
 	inline void partial_select(int p_first, int p_last, int p_middle, T *p_array) const {
-
 		make_heap(p_first, p_middle, p_array);
 		for (int i = p_middle; i < p_last; i++)
 			if (compare(p_array[i], p_array[p_first]))
@@ -173,7 +160,6 @@ public:
 	}
 
 	inline int partitioner(int p_first, int p_last, T p_pivot, T *p_array) const {
-
 		const int unmodified_first = p_first;
 		const int unmodified_last = p_last;
 
@@ -201,9 +187,7 @@ public:
 	}
 
 	inline void introsort(int p_first, int p_last, T *p_array, int p_max_depth) const {
-
 		while (p_last - p_first > INTROSORT_THRESHOLD) {
-
 			if (p_max_depth == 0) {
 				partial_sort(p_first, p_last, p_last, p_array);
 				return;
@@ -226,9 +210,7 @@ public:
 	}
 
 	inline void introselect(int p_first, int p_nth, int p_last, T *p_array, int p_max_depth) const {
-
 		while (p_last - p_first > 3) {
-
 			if (p_max_depth == 0) {
 				partial_select(p_first, p_nth + 1, p_last, p_array);
 				SWAP(p_first, p_nth);
@@ -256,7 +238,6 @@ public:
 	}
 
 	inline void unguarded_linear_insert(int p_last, T p_value, T *p_array) const {
-
 		int next = p_last - 1;
 		while (compare(p_value, p_array[next])) {
 			if (Validate) {
@@ -270,10 +251,8 @@ public:
 	}
 
 	inline void linear_insert(int p_first, int p_last, T *p_array) const {
-
 		T val = p_array[p_last];
 		if (compare(val, p_array[p_first])) {
-
 			for (int i = p_last; i > p_first; i--)
 				p_array[i] = p_array[i - 1];
 
@@ -283,7 +262,6 @@ public:
 	}
 
 	inline void insertion_sort(int p_first, int p_last, T *p_array) const {
-
 		if (p_first == p_last)
 			return;
 		for (int i = p_first + 1; i != p_last; i++)
@@ -291,24 +269,20 @@ public:
 	}
 
 	inline void unguarded_insertion_sort(int p_first, int p_last, T *p_array) const {
-
 		for (int i = p_first; i != p_last; i++)
 			unguarded_linear_insert(i, p_array[i], p_array);
 	}
 
 	inline void final_insertion_sort(int p_first, int p_last, T *p_array) const {
-
 		if (p_last - p_first > INTROSORT_THRESHOLD) {
 			insertion_sort(p_first, p_first + INTROSORT_THRESHOLD, p_array);
 			unguarded_insertion_sort(p_first + INTROSORT_THRESHOLD, p_last, p_array);
 		} else {
-
 			insertion_sort(p_first, p_last, p_array);
 		}
 	}
 
 	inline void sort_range(int p_first, int p_last, T *p_array) const {
-
 		if (p_first != p_last) {
 			introsort(p_first, p_last, p_array, bitlog(p_last - p_first) * 2);
 			final_insertion_sort(p_first, p_last, p_array);
@@ -316,12 +290,10 @@ public:
 	}
 
 	inline void sort(T *p_array, int p_len) const {
-
 		sort_range(0, p_len, p_array);
 	}
 
 	inline void nth_element(int p_first, int p_last, int p_nth, T *p_array) const {
-
 		if (p_first == p_last || p_nth == p_last)
 			return;
 		introselect(p_first, p_nth, p_last, p_array, bitlog(p_last - p_first) * 2);