From 2e4d666eec1a372d4b64c527d6c4945ad98d2b58 Mon Sep 17 00:00:00 2001
From: David Robillard <d@drobilla.net>
Date: Fri, 16 Sep 2022 21:19:57 -0400
Subject: Update clang-format configuration

---
 include/chilbert/detail/operations.hpp | 92 ++++++++++++++++++----------------
 1 file changed, 48 insertions(+), 44 deletions(-)

(limited to 'include/chilbert/detail/operations.hpp')

diff --git a/include/chilbert/detail/operations.hpp b/include/chilbert/detail/operations.hpp
index a196ba4..ed9dfac 100644
--- a/include/chilbert/detail/operations.hpp
+++ b/include/chilbert/detail/operations.hpp
@@ -32,135 +32,139 @@ namespace chilbert {
 namespace detail {
 
 /// Reset all bits in `field`
-template <typename T>
+template<typename T>
 std::enable_if_t<std::is_integral<T>::value>
 reset_bits(T& field)
 {
-	field = static_cast<T>(0);
+  field = static_cast<T>(0);
 }
 
 /// Reset all bits in `field`
-template <typename T>
+template<typename T>
 std::enable_if_t<is_bitvec_v<T>>
 reset_bits(T& field)
 {
-	field.reset();
+  field.reset();
 }
 
 /// Return the `index`th bit in `field`
-template <typename T>
+template<typename T>
 std::enable_if_t<std::is_integral<T>::value, bool>
 test_bit(const T& field, const size_t index)
 {
-	assert(size_t(index) < sizeof(field) * CHAR_BIT);
-	return field & (T{1} << index);
+  assert(size_t(index) < sizeof(field) * CHAR_BIT);
+  return field & (T{1} << index);
 }
 
 /// Return the `index`th bit in `field`
-template <typename T>
+template<typename T>
 std::enable_if_t<is_bitvec_v<T>, bool>
 test_bit(const T& field, const size_t index)
 {
-	return field.test(index);
+  return field.test(index);
 }
 
 /// Set the `index`th bit in `field`
-template <typename T>
+template<typename T>
 std::enable_if_t<std::is_integral<T>::value>
 set_bit(T& field, const size_t index)
 {
-	assert(size_t(index) < sizeof(field) * CHAR_BIT);
-	field |= (T{1} << index);
-	assert(test_bit(field, index));
+  assert(size_t(index) < sizeof(field) * CHAR_BIT);
+  field |= (T{1} << index);
+  assert(test_bit(field, index));
 }
 
 /// Set the `index`th bit in `field` to `value`
-template <typename T>
+template<typename T>
 std::enable_if_t<std::is_integral<T>::value>
 set_bit(T& field, const size_t index, const bool value)
 {
-	assert(size_t(index) < sizeof(field) * CHAR_BIT);
-	field ^= (-T{value} ^ field) & (T{1U} << index);
-	assert(test_bit(field, index) == value);
+  assert(size_t(index) < sizeof(field) * CHAR_BIT);
+  field ^= (-T{value} ^ field) & (T{1U} << index);
+  assert(test_bit(field, index) == value);
 }
 
 /// Set the `index`th bit in `field`
-template <typename T>
+template<typename T>
 std::enable_if_t<is_bitvec_v<T>>
 set_bit(T& field, const size_t index)
 {
-	field.set(index);
+  field.set(index);
 }
 
 /// Set the `index`th bit in `field` to `value`
-template <typename T>
+template<typename T>
 std::enable_if_t<is_bitvec_v<T>>
 set_bit(T& field, const size_t index, const bool value)
 {
-	field.set(index, value);
+  field.set(index, value);
 }
 
 /// Return 1 + the index of the least significant 1-bit of `field`, or zero
-template <typename T>
-inline int pop_count(const T& field);
+template<typename T>
+inline int
+pop_count(const T& field);
 
-template <>
+template<>
 inline int
 pop_count<unsigned long>(const unsigned long& field)
 {
-	return __builtin_popcountl(field);
+  return __builtin_popcountl(field);
 }
 
-template <>
+template<>
 inline int
 pop_count<unsigned long long>(const unsigned long long& field)
 {
-	return __builtin_popcountll(field);
+  return __builtin_popcountll(field);
 }
 
 /// Return 1 + the index of the least significant 1-bit of `field`, or zero
-template <typename T>
-inline int find_first(const T field);
+template<typename T>
+inline int
+find_first(const T field);
 
-template <>
+template<>
 inline int
 find_first<unsigned long>(const unsigned long field)
 {
-	return __builtin_ffsl(static_cast<long>(field));
+  return __builtin_ffsl(static_cast<long>(field));
 }
 
-template <>
+template<>
 inline int
 find_first<unsigned long long>(const unsigned long long field)
 {
-	return __builtin_ffsll(static_cast<long long>(field));
+  return __builtin_ffsll(static_cast<long long>(field));
 }
 
 /// Calculates the Gray Code of `value` in place
-template <typename T>
-std::enable_if_t<is_bitvec_v<T>> gray_code(T& value);
+template<typename T>
+std::enable_if_t<is_bitvec_v<T>>
+gray_code(T& value);
 
 /// Implementation of grayCode for any integral type
-template <typename T>
+template<typename T>
 std::enable_if_t<std::is_integral<T>::value>
 gray_code(T& value)
 {
-	value ^= (value >> 1U);
+  value ^= (value >> 1U);
 }
 
 /// Calculates the inverse Gray Code of `value` in place
-template <typename T>
-std::enable_if_t<is_bitvec_v<T>> gray_code_inv(T& value);
+template<typename T>
+std::enable_if_t<is_bitvec_v<T>>
+gray_code_inv(T& value);
 
 /// Implementation of gray_code_inv for any integral type
-template <typename T>
+template<typename T>
 std::enable_if_t<std::is_integral<T>::value>
 gray_code_inv(T& value)
 {
-	constexpr T shift_end = sizeof(T) * CHAR_BIT;
-	for (T shift = 1U; shift < shift_end; shift <<= 1U) {
-		value ^= (value >> shift);
-	}
+  constexpr T shift_end = sizeof(T) * CHAR_BIT;
+  for (T shift = 1U; shift < shift_end; shift <<= 1U) {
+    value ^= (value >> shift);
+  }
 }
 
 } // namespace detail
-- 
cgit v1.2.1