Revert "add a .clang-format file (#9154)" (#9172)

I thought git would be smart enough to understand all the whitespace changes but even with all the flags I know to make it ignore theses it still blows up if there are identical changes on both sides.

I have a solution but it require creating a new commit at the merge base for each conflicting PR and merging it into develop.

I don't think blowing up all PRs is worth for now, maybe if we can coordinate this for V3 let's say.

This reverts commit 0d11331d18.

src/concurrency/OSThread.cpp

@@ -3,7 +3,8 @@
 #include "memGet.h"
 #include <assert.h>
 
-namespace concurrency {
+namespace concurrency
+{
 
 /// Show debugging info for disabled threads
 bool OSThread::showDisabled;
@@ -19,85 +20,93 @@ const OSThread *OSThread::currentThread;
 ThreadController mainController, timerController;
 InterruptableDelay mainDelay;
 
-void OSThread::setup() {
-  mainController.ThreadName = "mainController";
-  timerController.ThreadName = "timerController";
+void OSThread::setup()
+{
+    mainController.ThreadName = "mainController";
+    timerController.ThreadName = "timerController";
 }
 
-OSThread::OSThread(const char *_name, uint32_t period, ThreadController *_controller) : Thread(NULL, period), controller(_controller) {
-  assertIsSetup();
+OSThread::OSThread(const char *_name, uint32_t period, ThreadController *_controller)
+    : Thread(NULL, period), controller(_controller)
+{
+    assertIsSetup();
 
-  ThreadName = _name;
+    ThreadName = _name;
 
-  if (controller) {
-    bool added = controller->add(this);
-    assert(added);
-  }
+    if (controller) {
+        bool added = controller->add(this);
+        assert(added);
+    }
 }
 
-OSThread::~OSThread() {
-  if (controller)
-    controller->remove(this);
+OSThread::~OSThread()
+{
+    if (controller)
+        controller->remove(this);
 }
 
 /**
  * Wait a specified number msecs starting from the current time (rather than the last time we were run)
  */
-void OSThread::setIntervalFromNow(unsigned long _interval) {
-  // Save interval
-  interval = _interval;
+void OSThread::setIntervalFromNow(unsigned long _interval)
+{
+    // Save interval
+    interval = _interval;
 
-  // Cache the next run based on the last_run
-  _cached_next_run = millis() + interval;
+    // Cache the next run based on the last_run
+    _cached_next_run = millis() + interval;
 }
 
-bool OSThread::shouldRun(unsigned long time) {
-  bool r = Thread::shouldRun(time);
+bool OSThread::shouldRun(unsigned long time)
+{
+    bool r = Thread::shouldRun(time);
 
-  if (showRun && r) {
-    LOG_DEBUG("Thread %s: run", ThreadName.c_str());
-  }
+    if (showRun && r) {
+        LOG_DEBUG("Thread %s: run", ThreadName.c_str());
+    }
 
-  if (showWaiting && enabled && !r) {
-    LOG_DEBUG("Thread %s: wait %lu", ThreadName.c_str(), interval);
-  }
+    if (showWaiting && enabled && !r) {
+        LOG_DEBUG("Thread %s: wait %lu", ThreadName.c_str(), interval);
+    }
 
-  if (showDisabled && !enabled) {
-    LOG_DEBUG("Thread %s: disabled", ThreadName.c_str());
-  }
+    if (showDisabled && !enabled) {
+        LOG_DEBUG("Thread %s: disabled", ThreadName.c_str());
+    }
 
-  return r;
+    return r;
 }
 
-void OSThread::run() {
+void OSThread::run()
+{
 #ifdef DEBUG_HEAP
-  auto heap = memGet.getFreeHeap();
+    auto heap = memGet.getFreeHeap();
 #endif
-  currentThread = this;
-  auto newDelay = runOnce();
+    currentThread = this;
+    auto newDelay = runOnce();
 #ifdef DEBUG_HEAP
-  auto newHeap = memGet.getFreeHeap();
-  if (newHeap < heap)
-    LOG_HEAP("------ Thread %s leaked heap %d -> %d (%d) ------", ThreadName.c_str(), heap, newHeap, newHeap - heap);
-  if (heap < newHeap)
-    LOG_HEAP("++++++ Thread %s freed heap %d -> %d (%d) ++++++", ThreadName.c_str(), heap, newHeap, newHeap - heap);
+    auto newHeap = memGet.getFreeHeap();
+    if (newHeap < heap)
+        LOG_HEAP("------ Thread %s leaked heap %d -> %d (%d) ------", ThreadName.c_str(), heap, newHeap, newHeap - heap);
+    if (heap < newHeap)
+        LOG_HEAP("++++++ Thread %s freed heap %d -> %d (%d) ++++++", ThreadName.c_str(), heap, newHeap, newHeap - heap);
 #endif
 #ifdef DEBUG_LOOP_TIMING
-  LOG_DEBUG("====== Thread next run in: %d", newDelay);
+    LOG_DEBUG("====== Thread next run in: %d", newDelay);
 #endif
-  runned();
+    runned();
 
-  if (newDelay >= 0)
-    setInterval(newDelay);
+    if (newDelay >= 0)
+        setInterval(newDelay);
 
-  currentThread = NULL;
+    currentThread = NULL;
 }
 
-int32_t OSThread::disable() {
-  enabled = false;
-  setInterval(INT32_MAX);
+int32_t OSThread::disable()
+{
+    enabled = false;
+    setInterval(INT32_MAX);
 
-  return INT32_MAX;
+    return INT32_MAX;
 }
 
 /**
@@ -113,22 +122,23 @@ int32_t OSThread::disable() {
  */
 bool hasBeenSetup;
 
-void assertIsSetup() {
+void assertIsSetup()
+{
 
-  /**
-   * Dear developer comrade - If this assert fails() that means you need to fix the following:
-   *
-   * This flag is set **only** when setup() starts, to provide a way for us to check for sloppy static constructor
-   * calls. Call assertIsSetup() to force a crash if someone tries to create an instance too early.
-   *
-   * it is super important to never allocate those object statically.  instead, you should explicitly
-   *  new them at a point where you are guaranteed that other objects that this instance
-   * depends on have already been created.
-   *
-   * in particular, for OSThread that means "all instances must be declared via new() in setup() or later" -
-   * this makes it guaranteed that the global mainController is fully constructed first.
-   */
-  assert(hasBeenSetup);
+    /**
+     * Dear developer comrade - If this assert fails() that means you need to fix the following:
+     *
+     * This flag is set **only** when setup() starts, to provide a way for us to check for sloppy static constructor calls.
+     * Call assertIsSetup() to force a crash if someone tries to create an instance too early.
+     *
+     * it is super important to never allocate those object statically.  instead, you should explicitly
+     *  new them at a point where you are guaranteed that other objects that this instance
+     * depends on have already been created.
+     *
+     * in particular, for OSThread that means "all instances must be declared via new() in setup() or later" -
+     * this makes it guaranteed that the global mainController is fully constructed first.
+     */
+    assert(hasBeenSetup);
 }
 
 } // namespace concurrency