Reformat

PowerDNS · Jun 26, 2024 · 6a27dba · 6a27dba
1 parent 3a7d243
commit 6a27dba
Show file tree

Hide file tree

Showing 3 changed files with 108 additions and 64 deletions.
diff --git a/.not-formatted b/.not-formatted
@@ -120,7 +120,6 @@
 ./pdns/kvresp.cc
 ./pdns/libssl.cc
 ./pdns/libssl.hh
-./pdns/lock.hh
 ./pdns/lua-auth4.cc
 ./pdns/lua-auth4.hh
 ./pdns/lua-base4.cc
@@ -170,7 +169,6 @@
 ./pdns/secpoll.cc
 ./pdns/secpoll.hh
 ./pdns/serialtweaker.cc
-./pdns/sholder.hh
 ./pdns/signingpipe.cc
 ./pdns/signingpipe.hh
 ./pdns/sillyrecords.cc

diff --git a/pdns/lock.hh b/pdns/lock.hh
@@ -99,11 +99,13 @@ private:
 class ReadLock
 {
 public:
-  ReadLock(ReadWriteLock& lock): ReadLock(lock.getLock())
+  ReadLock(ReadWriteLock& lock) :
+    ReadLock(lock.getLock())
   {
   }
 
-  ReadLock(ReadWriteLock* lock): ReadLock(lock->getLock())
+  ReadLock(ReadWriteLock* lock) :
+    ReadLock(lock->getLock())
   {
   }
 
@@ -115,7 +117,8 @@ public:
   }
 
 private:
-  ReadLock(std::shared_mutex& lock) : d_lock(lock)
+  ReadLock(std::shared_mutex& lock) :
+    d_lock(lock)
   {
   }
 
@@ -125,11 +128,13 @@ private:
 class WriteLock
 {
 public:
-  WriteLock(ReadWriteLock& lock): WriteLock(lock.getLock())
+  WriteLock(ReadWriteLock& lock) :
+    WriteLock(lock.getLock())
   {
   }
 
-  WriteLock(ReadWriteLock* lock): WriteLock(lock->getLock())
+  WriteLock(ReadWriteLock* lock) :
+    WriteLock(lock->getLock())
   {
   }
 
@@ -141,7 +146,8 @@ public:
   }
 
 private:
-  WriteLock(std::shared_mutex& lock) : d_lock(lock)
+  WriteLock(std::shared_mutex& lock) :
+    d_lock(lock)
   {
   }
 
@@ -151,11 +157,13 @@ private:
 class TryReadLock
 {
 public:
-  TryReadLock(ReadWriteLock& lock): TryReadLock(lock.getLock())
+  TryReadLock(ReadWriteLock& lock) :
+    TryReadLock(lock.getLock())
   {
   }
 
-  TryReadLock(ReadWriteLock* lock): TryReadLock(lock->getLock())
+  TryReadLock(ReadWriteLock* lock) :
+    TryReadLock(lock->getLock())
   {
   }
 
@@ -168,7 +176,8 @@ public:
   }
 
 private:
-  TryReadLock(std::shared_mutex& lock) : d_lock(lock, std::try_to_lock)
+  TryReadLock(std::shared_mutex& lock) :
+    d_lock(lock, std::try_to_lock)
   {
   }
 
@@ -178,11 +187,13 @@ private:
 class TryWriteLock
 {
 public:
-  TryWriteLock(ReadWriteLock& lock): TryWriteLock(lock.getLock())
+  TryWriteLock(ReadWriteLock& lock) :
+    TryWriteLock(lock.getLock())
   {
   }
 
-  TryWriteLock(ReadWriteLock* lock): TryWriteLock(lock->getLock())
+  TryWriteLock(ReadWriteLock* lock) :
+    TryWriteLock(lock->getLock())
   {
   }
 
@@ -195,7 +206,8 @@ public:
   }
 
 private:
-  TryWriteLock(std::shared_mutex& lock) : d_lock(lock, std::try_to_lock)
+  TryWriteLock(std::shared_mutex& lock) :
+    d_lock(lock, std::try_to_lock)
   {
   }
 
@@ -206,15 +218,18 @@ template <typename T>
 class LockGuardedHolder
 {
 public:
-  explicit LockGuardedHolder(T& value, std::mutex& mutex): d_lock(mutex), d_value(value)
+  explicit LockGuardedHolder(T& value, std::mutex& mutex) :
+    d_lock(mutex), d_value(value)
   {
   }
 
-  T& operator*() const noexcept {
+  T& operator*() const noexcept
+  {
     return d_value;
   }
 
-  T* operator->() const noexcept {
+  T* operator->() const noexcept
+  {
     return &d_value;
   }
 
@@ -227,29 +242,34 @@ template <typename T>
 class LockGuardedTryHolder
 {
 public:
-  explicit LockGuardedTryHolder(T& value, std::mutex& mutex): d_lock(mutex, std::try_to_lock), d_value(value)
+  explicit LockGuardedTryHolder(T& value, std::mutex& mutex) :
+    d_lock(mutex, std::try_to_lock), d_value(value)
   {
   }
 
-  T& operator*() const {
+  T& operator*() const
+  {
     if (!owns_lock()) {
       throw std::runtime_error("Trying to access data protected by a mutex while the lock has not been acquired");
     }
     return d_value;
   }
 
-  T* operator->() const {
+  T* operator->() const
+  {
     if (!owns_lock()) {
       throw std::runtime_error("Trying to access data protected by a mutex while the lock has not been acquired");
     }
     return &d_value;
   }
 
-  operator bool() const noexcept {
+  operator bool() const noexcept
+  {
     return d_lock.owns_lock();
   }
 
-  bool owns_lock() const noexcept {
+  bool owns_lock() const noexcept
+  {
     return d_lock.owns_lock();
   }
 
@@ -267,11 +287,13 @@ template <typename T>
 class LockGuarded
 {
 public:
-  explicit LockGuarded(const T& value): d_value(value)
+  explicit LockGuarded(const T& value) :
+    d_value(value)
   {
   }
 
-  explicit LockGuarded(T&& value): d_value(std::move(value))
+  explicit LockGuarded(T&& value) :
+    d_value(std::move(value))
   {
   }
 
@@ -301,15 +323,18 @@ template <typename T>
 class SharedLockGuardedHolder
 {
 public:
-  explicit SharedLockGuardedHolder(T& value, std::shared_mutex& mutex): d_lock(mutex), d_value(value)
+  explicit SharedLockGuardedHolder(T& value, std::shared_mutex& mutex) :
+    d_lock(mutex), d_value(value)
   {
   }
 
-  T& operator*() const noexcept {
+  T& operator*() const noexcept
+  {
     return d_value;
   }
 
-  T* operator->() const noexcept {
+  T* operator->() const noexcept
+  {
     return &d_value;
   }
 
@@ -322,29 +347,34 @@ template <typename T>
 class SharedLockGuardedTryHolder
 {
 public:
-  explicit SharedLockGuardedTryHolder(T& value, std::shared_mutex& mutex): d_lock(mutex, std::try_to_lock), d_value(value)
+  explicit SharedLockGuardedTryHolder(T& value, std::shared_mutex& mutex) :
+    d_lock(mutex, std::try_to_lock), d_value(value)
   {
   }
 
-  T& operator*() const {
+  T& operator*() const
+  {
     if (!owns_lock()) {
       throw std::runtime_error("Trying to access data protected by a mutex while the lock has not been acquired");
     }
     return d_value;
   }
 
-  T* operator->() const {
+  T* operator->() const
+  {
     if (!owns_lock()) {
       throw std::runtime_error("Trying to access data protected by a mutex while the lock has not been acquired");
     }
     return &d_value;
   }
 
-  operator bool() const noexcept {
+  operator bool() const noexcept
+  {
     return d_lock.owns_lock();
   }
 
-  bool owns_lock() const noexcept {
+  bool owns_lock() const noexcept
+  {
     return d_lock.owns_lock();
   }
 
@@ -357,15 +387,18 @@ template <typename T>
 class SharedLockGuardedNonExclusiveHolder
 {
 public:
-  explicit SharedLockGuardedNonExclusiveHolder(const T& value, std::shared_mutex& mutex): d_lock(mutex), d_value(value)
+  explicit SharedLockGuardedNonExclusiveHolder(const T& value, std::shared_mutex& mutex) :
+    d_lock(mutex), d_value(value)
   {
   }
 
-  const T& operator*() const noexcept {
+  const T& operator*() const noexcept
+  {
     return d_value;
   }
 
-  const T* operator->() const noexcept {
+  const T* operator->() const noexcept
+  {
     return &d_value;
   }
 
@@ -378,29 +411,34 @@ template <typename T>
 class SharedLockGuardedNonExclusiveTryHolder
 {
 public:
-  explicit SharedLockGuardedNonExclusiveTryHolder(const T& value, std::shared_mutex& mutex): d_lock(mutex, std::try_to_lock), d_value(value)
+  explicit SharedLockGuardedNonExclusiveTryHolder(const T& value, std::shared_mutex& mutex) :
+    d_lock(mutex, std::try_to_lock), d_value(value)
   {
   }
 
-  const T& operator*() const {
+  const T& operator*() const
+  {
     if (!owns_lock()) {
       throw std::runtime_error("Trying to access data protected by a mutex while the lock has not been acquired");
     }
     return d_value;
   }
 
-  const T* operator->() const {
+  const T* operator->() const
+  {
     if (!owns_lock()) {
       throw std::runtime_error("Trying to access data protected by a mutex while the lock has not been acquired");
     }
     return &d_value;
   }
 
-  operator bool() const noexcept {
+  operator bool() const noexcept
+  {
     return d_lock.owns_lock();
   }
 
-  bool owns_lock() const noexcept {
+  bool owns_lock() const noexcept
+  {
     return d_lock.owns_lock();
   }
 
@@ -413,11 +451,13 @@ template <typename T>
 class SharedLockGuarded
 {
 public:
-  explicit SharedLockGuarded(const T& value): d_value(value)
+  explicit SharedLockGuarded(const T& value) :
+    d_value(value)
   {
   }
 
-  explicit SharedLockGuarded(T&& value): d_value(std::move(value))
+  explicit SharedLockGuarded(T&& value) :
+    d_value(std::move(value))
   {
   }