style(3p/nix): Reformat project in Google C++ style

Reformatted with:

    fd . -e hh -e cc | xargs clang-format -i

third_party/nix/src/libutil/sync.hh

@@ -1,9 +1,9 @@
 #pragma once
 
+#include <cassert>
+#include <condition_variable>
 #include <cstdlib>
 #include <mutex>
-#include <condition_variable>
-#include <cassert>
 
 namespace nix {
 
@@ -23,66 +23,62 @@ namespace nix {
    scope.
 */
 
-template<class T, class M = std::mutex>
-class Sync
-{
-private:
-    M mutex;
-    T data;
+template <class T, class M = std::mutex>
+class Sync {
+ private:
+  M mutex;
+  T data;
 
-public:
+ public:
+  Sync() {}
+  Sync(const T& data) : data(data) {}
+  Sync(T&& data) noexcept : data(std::move(data)) {}
 
-    Sync() { }
-    Sync(const T & data) : data(data) { }
-    Sync(T && data) noexcept : data(std::move(data)) { }
+  class Lock {
+   private:
+    Sync* s;
+    std::unique_lock<M> lk;
+    friend Sync;
+    Lock(Sync* s) : s(s), lk(s->mutex) {}
 
-    class Lock
-    {
-    private:
-        Sync * s;
-        std::unique_lock<M> lk;
-        friend Sync;
-        Lock(Sync * s) : s(s), lk(s->mutex) { }
-    public:
-        Lock(Lock && l) : s(l.s) { abort(); }
-        Lock(const Lock & l) = delete;
-        ~Lock() { }
-        T * operator -> () { return &s->data; }
-        T & operator * () { return s->data; }
+   public:
+    Lock(Lock&& l) : s(l.s) { abort(); }
+    Lock(const Lock& l) = delete;
+    ~Lock() {}
+    T* operator->() { return &s->data; }
+    T& operator*() { return s->data; }
 
-        void wait(std::condition_variable & cv)
-        {
-            assert(s);
-            cv.wait(lk);
-        }
+    void wait(std::condition_variable& cv) {
+      assert(s);
+      cv.wait(lk);
+    }
 
-        template<class Rep, class Period>
-        std::cv_status wait_for(std::condition_variable & cv,
-            const std::chrono::duration<Rep, Period> & duration)
-        {
-            assert(s);
-            return cv.wait_for(lk, duration);
-        }
+    template <class Rep, class Period>
+    std::cv_status wait_for(
+        std::condition_variable& cv,
+        const std::chrono::duration<Rep, Period>& duration) {
+      assert(s);
+      return cv.wait_for(lk, duration);
+    }
 
-        template<class Rep, class Period, class Predicate>
-        bool wait_for(std::condition_variable & cv,
-            const std::chrono::duration<Rep, Period> & duration,
-            Predicate pred)
-        {
-            assert(s);
-            return cv.wait_for(lk, duration, pred);
-        }
+    template <class Rep, class Period, class Predicate>
+    bool wait_for(std::condition_variable& cv,
+                  const std::chrono::duration<Rep, Period>& duration,
+                  Predicate pred) {
+      assert(s);
+      return cv.wait_for(lk, duration, pred);
+    }
 
-        template<class Clock, class Duration>
-        std::cv_status wait_until(std::condition_variable & cv,
-            const std::chrono::time_point<Clock, Duration> & duration)
-        {
-            assert(s);
-            return cv.wait_until(lk, duration);
-        }
-    };
+    template <class Clock, class Duration>
+    std::cv_status wait_until(
+        std::condition_variable& cv,
+        const std::chrono::time_point<Clock, Duration>& duration) {
+      assert(s);
+      return cv.wait_until(lk, duration);
+    }
+  };
 
-    Lock lock() { return Lock(this); }
+  Lock lock() { return Lock(this); }
 };
 
-}
+}  // namespace nix