formatting

Author: tanneberger

include/reactor-cpp/connection.hh

@@ -142,8 +142,8 @@ public:
     };
   }
 
-  auto acquire_tag(const Tag& tag, std::unique_lock<std::mutex>& lock,
-                   const std::function<bool(void)>& abort_waiting) -> bool override {
+  auto acquire_tag(const Tag& tag, std::unique_lock<std::mutex>& lock, const std::function<bool(void)>& abort_waiting)
+      -> bool override {
     reactor_assert(lock.owns_lock());
     log_.debug() << "downstream tries to acquire tag " << tag;
 
@@ -209,8 +209,8 @@ public:
     };
   }
 
-  auto acquire_tag(const Tag& tag, std::unique_lock<std::mutex>& lock,
-                   const std::function<bool(void)>& abort_waiting) -> bool override {
+  auto acquire_tag(const Tag& tag, std::unique_lock<std::mutex>& lock, const std::function<bool(void)>& abort_waiting)
+      -> bool override {
     // Since this is a delayed connection, we can go back in time and need to
     // acquire the latest upstream tag that can create an event at the given
     // tag. We also need to consider that given a delay d and a tag g=(t, n),
@@ -239,8 +239,8 @@ public:
     };
   }
 
-  auto acquire_tag(const Tag& tag, std::unique_lock<std::mutex>& lock,
-                   const std::function<bool(void)>& abort_waiting) -> bool override {
+  auto acquire_tag(const Tag& tag, std::unique_lock<std::mutex>& lock, const std::function<bool(void)>& abort_waiting)
+      -> bool override {
     this->log_.debug() << "downstream tries to acquire tag " << tag;
     return PhysicalTimeBarrier::acquire_tag(tag, lock, this->environment()->scheduler(), abort_waiting);
   }

include/reactor-cpp/time_barrier.hh

@@ -79,8 +79,8 @@ public:
   // The caller must hold a lock on the scheduler mutex
   auto try_acquire_tag(const Tag& tag) { return tag <= released_time_; }
 
-  auto acquire_tag(const Tag& tag, std::unique_lock<std::mutex>& lock,
-                   const std::function<bool(void)>& abort_waiting) -> bool {
+  auto acquire_tag(const Tag& tag, std::unique_lock<std::mutex>& lock, const std::function<bool(void)>& abort_waiting)
+      -> bool {
     if (try_acquire_tag(tag)) {
       return true;
     }

include/reactor-cpp/value_ptr.hh

@@ -514,23 +514,23 @@ public:
 // Comparison operators
 
 template <class T, class U, bool is_trivial>
-auto operator==(const MutableValuePtr<T, is_trivial>& ptr1,
-                const MutableValuePtr<U, is_trivial>& ptr2) noexcept -> bool {
+auto operator==(const MutableValuePtr<T, is_trivial>& ptr1, const MutableValuePtr<U, is_trivial>& ptr2) noexcept
+    -> bool {
   return ptr1.get() == ptr2.get();
 }
 template <class T, class U, bool is_trivial>
-auto operator==(const ImmutableValuePtr<T, is_trivial>& ptr1,
-                const ImmutableValuePtr<U, is_trivial>& ptr2) noexcept -> bool {
+auto operator==(const ImmutableValuePtr<T, is_trivial>& ptr1, const ImmutableValuePtr<U, is_trivial>& ptr2) noexcept
+    -> bool {
   return ptr1.get() == ptr2.get();
 }
 template <class T, class U, bool is_trivial>
-auto operator==(const ImmutableValuePtr<T, is_trivial>& ptr1,
-                const MutableValuePtr<U, is_trivial>& ptr2) noexcept -> bool {
+auto operator==(const ImmutableValuePtr<T, is_trivial>& ptr1, const MutableValuePtr<U, is_trivial>& ptr2) noexcept
+    -> bool {
   return ptr1.get() == ptr2.get();
 }
 template <class T, class U, bool is_trivial>
-auto operator==(const MutableValuePtr<T, is_trivial>& ptr1,
-                const ImmutableValuePtr<U, is_trivial>& ptr2) noexcept -> bool {
+auto operator==(const MutableValuePtr<T, is_trivial>& ptr1, const ImmutableValuePtr<U, is_trivial>& ptr2) noexcept
+    -> bool {
   return ptr1.get() == ptr2.get();
 }
 template <class T, bool is_trivial>
@@ -551,8 +551,8 @@ auto operator==(std::nullptr_t, const ImmutableValuePtr<T, is_trivial>& ptr1) no
 }
 
 template <class T, class U, bool is_trivial>
-auto operator!=(const MutableValuePtr<T, is_trivial>& ptr1,
-                const MutableValuePtr<U, is_trivial>& ptr2) noexcept -> bool {
+auto operator!=(const MutableValuePtr<T, is_trivial>& ptr1, const MutableValuePtr<U, is_trivial>& ptr2) noexcept
+    -> bool {
   return ptr1.get() != ptr2.get();
 }