clang-format

1 files changed, 26 insertions, 46 deletions

diff --git a/common/nextpnr.h b/common/nextpnr.h
index c3fb913c..6228e653 100644
--- a/common/nextpnr.h
+++ b/common/nextpnr.h
@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <assert.h>
+#include <boost/thread/shared_mutex.hpp>
 #include <memory>
 #include <stdexcept>
 #include <stdint.h>
@@ -26,7 +27,6 @@
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
-#include <boost/thread/shared_mutex.hpp>
 
 #ifndef NEXTPNR_H
 #define NEXTPNR_H
@@ -261,7 +261,8 @@ class BaseCtx
     friend class MutateContext;
     friend class BaseReadCtx;
     friend class BaseMutateCtx;
-private:
+
+  private:
     mutable boost::shared_mutex mtx_;
 
     bool allUiReload = false;
@@ -271,7 +272,7 @@ private:
     std::unordered_set<PipId> pipUiReload;
     std::unordered_set<GroupId> groupUiReload;
 
-public:
+  public:
     IdString id(const std::string &s) const { return IdString(this, s); }
     IdString id(const char *s) const { return IdString(this, s); }
 
@@ -311,16 +312,16 @@ public:
     // locks can be taken while this one still exists. Ie., the UI can draw
     // elements while the PnR is going a RO operation.
     ReadContext rproxy(void) const;
-
 };
 
 // State-accessing read-only methods that every architecture object should
 // contain.
 class BaseReadCtx
 {
-protected:
+  protected:
     const BaseCtx *base_;
-public:
+
+  public:
     BaseReadCtx(const BaseCtx *base) : base_(base) {}
 };
 
@@ -328,41 +329,23 @@ public:
 // contain.
 class BaseMutateCtx
 {
-protected:
+  protected:
     BaseCtx *base_;
 
-public:
+  public:
     BaseMutateCtx(BaseCtx *base) : base_(base) {}
 
-    void refreshUi(void)
-    {
-        base_->allUiReload = true;
-    }
+    void refreshUi(void) { base_->allUiReload = true; }
 
-    void refreshUiFrame(void)
-    {
-        base_->frameUiReload = true;
-    }
+    void refreshUiFrame(void) { base_->frameUiReload = true; }
 
-    void refreshUiBel(BelId bel)
-    {
-        base_->belUiReload.insert(bel);
-    }
+    void refreshUiBel(BelId bel) { base_->belUiReload.insert(bel); }
 
-    void refreshUiWire(WireId wire)
-    {
-        base_->wireUiReload.insert(wire);
-    }
+    void refreshUiWire(WireId wire) { base_->wireUiReload.insert(wire); }
 
-    void refreshUiPip(PipId pip)
-    {
-        base_->pipUiReload.insert(pip);
-    }
+    void refreshUiPip(PipId pip) { base_->pipUiReload.insert(pip); }
 
-    void refreshUiGroup(GroupId group)
-    {
-        base_->groupUiReload.insert(group);
-    }
+    void refreshUiGroup(GroupId group) { base_->groupUiReload.insert(group); }
 
     UIUpdatesRequired getUIUpdatesRequired(void)
     {
@@ -394,49 +377,46 @@ NEXTPNR_NAMESPACE_BEGIN
 class ReadContext : public ArchReadMethods
 {
     friend class BaseCtx;
-private:
+
+  private:
     boost::shared_mutex *lock_;
-    ReadContext(const Arch *parent) : ArchReadMethods(parent), lock_(&parent->mtx_)
-    {
-        lock_->lock_shared();
-    }
-public:
+    ReadContext(const Arch *parent) : ArchReadMethods(parent), lock_(&parent->mtx_) { lock_->lock_shared(); }
+
+  public:
     ~ReadContext()
     {
         if (lock_ != nullptr) {
             lock_->unlock_shared();
         }
     }
-    ReadContext(ReadContext &&other): ArchReadMethods(other), lock_(other.lock_)
-    {
-        other.lock_ = nullptr;
-    }
+    ReadContext(ReadContext &&other) : ArchReadMethods(other), lock_(other.lock_) { other.lock_ = nullptr; }
 };
 
 // Read proxy to access MutateMethods while holding lock on underlying BaseCtx.
 class MutateContext : public ArchReadMethods, public ArchMutateMethods
 {
     friend class BaseCtx;
-private:
+
+  private:
     boost::shared_mutex *lock_;
     MutateContext(Arch *parent) : ArchReadMethods(parent), ArchMutateMethods(parent), lock_(&parent->mtx_)
     {
         lock_->lock();
     }
-public:
+
+  public:
     ~MutateContext()
     {
         if (lock_ != nullptr) {
             lock_->unlock();
         }
     }
-    MutateContext(MutateContext &&other): ArchReadMethods(other), ArchMutateMethods(other), lock_(other.lock_)
+    MutateContext(MutateContext &&other) : ArchReadMethods(other), ArchMutateMethods(other), lock_(other.lock_)
     {
         other.lock_ = nullptr;
     }
 };
 
-
 struct Context : Arch
 {
     bool verbose = false;