add clang-format version print

Author: tanneberger

.github/workflows/clang-format.yml

@@ -10,5 +10,6 @@ jobs:
       - uses: actions/checkout@v4
       - name: Analyze
         run: |
+          clang-format --version
           clang-format --dry-run --Werror -style=file $(find ./ -name '*.cc' -print)
           clang-format --dry-run --Werror -style=file $(find ./ -name '*.hh' -print)

include/reactor-cpp/connection.hh

@@ -143,8 +143,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;
 
@@ -210,8 +210,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),
@@ -240,8 +240,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/multiport.hh

@@ -51,7 +51,7 @@ protected:
 
 public:
   explicit BaseMultiport(std::string name)
-      : multiport_name_(std::move(name)){};
+      : multiport_name_(std::move(name)) {}
   ~BaseMultiport() = default;
   [[nodiscard]] auto name() const -> std::string { return multiport_name_; }
 };
@@ -73,7 +73,7 @@ public:
   using const_iterator = typename std::vector<T>::const_iterator;
 
   explicit Multiport(const std::string& name) noexcept
-      : BaseMultiport(name){};
+      : BaseMultiport(name) {}
   ~Multiport() noexcept = default;
 
   auto operator==(const Multiport& other) const noexcept -> bool {

include/reactor-cpp/mutations/bank.hh

@@ -30,13 +30,13 @@ public:
       , desired_size_(other.desired_size_)
       , size_before_application_(other.size_before_application_)
       , reactor_(other.reactor_)
-      , create_lambda_(other.create_lambda_){};
+      , create_lambda_(other.create_lambda_) {}
   MutationChangeBankSize(MutationChangeBankSize&& other) noexcept
       : bank_(other.bank_)
       , desired_size_(other.desired_size_)
       , size_before_application_(other.size_before_application_)
       , reactor_(other.reactor_)
-      , create_lambda_(other.create_lambda_){};
+      , create_lambda_(other.create_lambda_) {}
   explicit MutationChangeBankSize(std::vector<T>* bank, Reactor* reactor, std::size_t size,
                                   std::function<T(Reactor* parent_reactor, std::size_t index)> create_lambda);
   ~MutationChangeBankSize() override = default;

include/reactor-cpp/port.hh

@@ -76,8 +76,7 @@ public:
   void register_antidependency(Reaction* reaction) noexcept;
   void set_inward_binding(BasePort* port) noexcept {
     if (port != nullptr) {
-      std::cout << port->fqn() << "(" << port << ")"
-                << " --> " << this->fqn() << "(" << this << ")" << '\n';
+      std::cout << port->fqn() << "(" << port << ")" << " --> " << this->fqn() << "(" << this << ")" << '\n';
     }
 
     inward_binding_ = port;

include/reactor-cpp/time_barrier.hh

@@ -80,8 +80,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

@@ -517,23 +517,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>
@@ -554,8 +554,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();
 }