clang-format in preparation for changes

Reviewed By: shixiao

Differential Revision: D8333485

fbshipit-source-id: 02f74700272b663474c2f02535265ffb6f4bcd22

folly/SharedMutex.h

@@ -256,8 +256,8 @@ class SharedMutexImpl {
 
   SharedMutexImpl(const SharedMutexImpl&) = delete;
   SharedMutexImpl(SharedMutexImpl&&) = delete;
-  SharedMutexImpl& operator = (const SharedMutexImpl&) = delete;
-  SharedMutexImpl& operator = (SharedMutexImpl&&) = delete;
+  SharedMutexImpl& operator=(const SharedMutexImpl&) = delete;
+  SharedMutexImpl& operator=(SharedMutexImpl&&) = delete;
 
   // It is an error to destroy an SharedMutex that still has
   // any outstanding locks.  This is checked if NDEBUG isn't defined.
@@ -352,7 +352,8 @@ class SharedMutexImpl {
   }
 
   template <class Rep, class Period>
-  bool try_lock_shared_for(const std::chrono::duration<Rep, Period>& duration,
+  bool try_lock_shared_for(
+      const std::chrono::duration<Rep, Period>& duration,
       Token& token) {
     WaitForDuration<Rep, Period> ctx(duration);
     return lockSharedImpl(&token, ctx);
@@ -391,7 +392,8 @@ class SharedMutexImpl {
   }
 
   void unlock_shared(Token& token) {
-    assert(token.type_ == Token::Type::INLINE_SHARED ||
+    assert(
+        token.type_ == Token::Type::INLINE_SHARED ||
         token.type_ == Token::Type::DEFERRED_SHARED);
 
     if (token.type_ != Token::Type::DEFERRED_SHARED ||
@@ -500,9 +502,15 @@ class SharedMutexImpl {
   // before the wait context is invoked.
 
   struct WaitForever {
-    bool canBlock() { return true; }
-    bool canTimeOut() { return false; }
-    bool shouldTimeOut() { return false; }
+    bool canBlock() {
+      return true;
+    }
+    bool canTimeOut() {
+      return false;
+    }
+    bool shouldTimeOut() {
+      return false;
+    }
 
     bool doWait(Futex& futex, uint32_t expected, uint32_t waitMask) {
       futex.futexWait(expected, waitMask);
@@ -511,11 +519,18 @@ class SharedMutexImpl {
   };
 
   struct WaitNever {
-    bool canBlock() { return false; }
-    bool canTimeOut() { return true; }
-    bool shouldTimeOut() { return true; }
+    bool canBlock() {
+      return false;
+    }
+    bool canTimeOut() {
+      return true;
+    }
+    bool shouldTimeOut() {
+      return true;
+    }
 
-    bool doWait(Futex& /* futex */,
+    bool doWait(
+        Futex& /* futex */,
         uint32_t /* expected */,
         uint32_t /* waitMask */) {
       return false;
@@ -539,8 +554,12 @@ class SharedMutexImpl {
       return deadline_;
     }
 
-    bool canBlock() { return duration_.count() > 0; }
-    bool canTimeOut() { return true; }
+    bool canBlock() {
+      return duration_.count() > 0;
+    }
+    bool canTimeOut() {
+      return true;
+    }
 
     bool shouldTimeOut() {
       return std::chrono::steady_clock::now() > deadline();
@@ -556,9 +575,15 @@ class SharedMutexImpl {
   struct WaitUntilDeadline {
     std::chrono::time_point<Clock, Duration> absDeadline_;
 
-    bool canBlock() { return true; }
-    bool canTimeOut() { return true; }
-    bool shouldTimeOut() { return Clock::now() > absDeadline_; }
+    bool canBlock() {
+      return true;
+    }
+    bool canTimeOut() {
+      return true;
+    }
+    bool shouldTimeOut() {
+      return Clock::now() > absDeadline_;
+    }
 
     bool doWait(Futex& futex, uint32_t expected, uint32_t waitMask) {
       auto result = futex.futexWaitUntil(expected, absDeadline_, waitMask);
@@ -703,10 +728,11 @@ class SharedMutexImpl {
   static constexpr uint32_t kDeferredSeparationFactor = 4;
 
  private:
-
-  static_assert(!(kMaxDeferredReaders & (kMaxDeferredReaders - 1)),
+  static_assert(
+      !(kMaxDeferredReaders & (kMaxDeferredReaders - 1)),
       "kMaxDeferredReaders must be a power of 2");
-  static_assert(!(kDeferredSearchDistance & (kDeferredSearchDistance - 1)),
+  static_assert(
+      !(kDeferredSearchDistance & (kDeferredSearchDistance - 1)),
       "kDeferredSearchDistance must be a power of 2");
 
   // The number of deferred locks that can be simultaneously acquired
@@ -733,7 +759,6 @@ class SharedMutexImpl {
   // Last deferred reader slot used.
   static FOLLY_SHAREDMUTEX_TLS uint32_t tls_lastDeferredReaderSlot;
 
-
   // Only indexes divisible by kDeferredSeparationFactor are used.
   // If any of those elements points to a SharedMutexImpl, then it
   // should be considered that there is a shared lock on that instance.
@@ -760,7 +785,8 @@ class SharedMutexImpl {
   }
 
   template <class WaitContext>
-  bool lockExclusiveImpl(uint32_t& state,
+  bool lockExclusiveImpl(
+      uint32_t& state,
       uint32_t preconditionGoalMask,
       WaitContext& ctx) {
     while (true) {
@@ -814,8 +840,8 @@ class SharedMutexImpl {
 
           if (kReaderPriority && (state & kHasE) == 0) {
             assert((state & kBegunE) != 0);
-            if (!state_.compare_exchange_strong(state,
-                                                (state & ~kBegunE) | kHasE)) {
+            if (!state_.compare_exchange_strong(
+                    state, (state & ~kBegunE) | kHasE)) {
               continue;
             }
           }
@@ -827,7 +853,8 @@ class SharedMutexImpl {
   }
 
   template <class WaitContext>
-  bool waitForZeroBits(uint32_t& state,
+  bool waitForZeroBits(
+      uint32_t& state,
       uint32_t goal,
       uint32_t waitMask,
       WaitContext& ctx) {
@@ -847,7 +874,8 @@ class SharedMutexImpl {
   }
 
   template <class WaitContext>
-  bool yieldWaitForZeroBits(uint32_t& state,
+  bool yieldWaitForZeroBits(
+      uint32_t& state,
       uint32_t goal,
       uint32_t waitMask,
       WaitContext& ctx) {
@@ -887,11 +915,13 @@ class SharedMutexImpl {
   }
 
   template <class WaitContext>
-  bool futexWaitForZeroBits(uint32_t& state,
+  bool futexWaitForZeroBits(
+      uint32_t& state,
       uint32_t goal,
       uint32_t waitMask,
       WaitContext& ctx) {
-    assert(waitMask == kWaitingNotS || waitMask == kWaitingE ||
+    assert(
+        waitMask == kWaitingNotS || waitMask == kWaitingE ||
         waitMask == kWaitingU || waitMask == kWaitingS);
 
     while (true) {
@@ -949,8 +979,7 @@ class SharedMutexImpl {
     // wakeup, we just disable the optimization in the case that there
     // are waiting U or S that we are eligible to wake.
     if ((wakeMask & kWaitingE) == kWaitingE &&
-        (state & wakeMask) == kWaitingE &&
-        state_.futexWake(1, kWaitingE) > 0) {
+        (state & wakeMask) == kWaitingE && state_.futexWake(1, kWaitingE) > 0) {
       // somebody woke up, so leave state_ as is and clear it later
       return;
     }
@@ -972,9 +1001,13 @@ class SharedMutexImpl {
     return &deferredReaders[slot * kDeferredSeparationFactor];
   }
 
-  uintptr_t tokenfulSlotValue() { return reinterpret_cast<uintptr_t>(this); }
+  uintptr_t tokenfulSlotValue() {
+    return reinterpret_cast<uintptr_t>(this);
+  }
 
-  uintptr_t tokenlessSlotValue() { return tokenfulSlotValue() | kTokenless; }
+  uintptr_t tokenlessSlotValue() {
+    return tokenfulSlotValue() | kTokenless;
+  }
 
   bool slotValueIsThis(uintptr_t slotValue) {
     return (slotValue & ~kTokenless) == tokenfulSlotValue();
@@ -1006,7 +1039,6 @@ class SharedMutexImpl {
 
   template <class WaitContext>
   void applyDeferredReaders(uint32_t& state, WaitContext& ctx, uint32_t slot) {
-
 #ifdef RUSAGE_THREAD
     struct rusage usage;
     std::memset(&usage, 0, sizeof(usage));
@@ -1118,7 +1150,8 @@ class SharedMutexImpl {
 
   uint32_t unlockSharedInline() {
     uint32_t state = (state_ -= kIncrHasS);
-    assert((state & (kHasE | kBegunE | kMayDefer)) != 0 ||
+    assert(
+        (state & (kHasE | kBegunE | kMayDefer)) != 0 ||
         state < state + kIncrHasS);
     if ((state & kHasS) == 0) {
       // Only the second half of lock() can be blocked by a non-zero
@@ -1156,8 +1189,8 @@ class SharedMutexImpl {
       lock_->lock_shared(token_);
     }
 
-    ReadHolder(ReadHolder&& rhs) noexcept : lock_(rhs.lock_),
-                                            token_(rhs.token_) {
+    ReadHolder(ReadHolder&& rhs) noexcept
+        : lock_(rhs.lock_), token_(rhs.token_) {
       rhs.lock_ = nullptr;
     }
 
@@ -1327,10 +1360,18 @@ class SharedMutexImpl {
   };
 
   // Adapters for Synchronized<>
-  friend void acquireRead(SharedMutexImpl& lock) { lock.lock_shared(); }
-  friend void acquireReadWrite(SharedMutexImpl& lock) { lock.lock(); }
-  friend void releaseRead(SharedMutexImpl& lock) { lock.unlock_shared(); }
-  friend void releaseReadWrite(SharedMutexImpl& lock) { lock.unlock(); }
+  friend void acquireRead(SharedMutexImpl& lock) {
+    lock.lock_shared();
+  }
+  friend void acquireReadWrite(SharedMutexImpl& lock) {
+    lock.lock();
+  }
+  friend void releaseRead(SharedMutexImpl& lock) {
+    lock.unlock_shared();
+  }
+  friend void releaseReadWrite(SharedMutexImpl& lock) {
+    lock.unlock();
+  }
   friend bool acquireRead(SharedMutexImpl& lock, unsigned int ms) {
     return lock.try_lock_shared_for(std::chrono::milliseconds(ms));
   }