diff --git a/src/utils/scheduler.hpp b/src/utils/scheduler.hpp
index 0d90cc606..03fab98b6 100644
--- a/src/utils/scheduler.hpp
+++ b/src/utils/scheduler.hpp
@@ -1,13 +1,13 @@
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
-#include <thread>
 #include <ctime>
+#include <thread>
 
 /**
  * Class used to run given std::function<void()>. Function is ran and then sleep
  * is called with parameter given in class constructor. Class is templated with
- * mutex class TMutex which is used to synchronize threads. Default template 
+ * mutex class TMutex which is used to synchronize threads. Default template
  * value is std::mutex.
  */
 template <typename TMutex = std::mutex>
@@ -15,37 +15,36 @@ class Scheduler {
  public:
   /**
    * @param t - Time between executing function. If function is still running
-   *            when it should be ran again, it will not be ran and next 
-   *            start time will be increased current time plus t. If t equals 
+   *            when it should be ran again, it will not be ran and next
+   *            start time will be increased current time plus t. If t equals
    *            -1, scheduler will not run.
    * @param f - Function which will be executed.
    */
   Scheduler(const std::chrono::seconds &t, const std::function<void()> &f)
       : pause_(t), func_(f) {
-    thread_ = std::thread([this]() { 
-        // if pause_ equals -1, scheduler will not run
-        if (pause_ == std::chrono::seconds(-1)) return; 
-        auto start_time = std::chrono::system_clock::now();
-        for(;;) {
-          if (!is_working_.load()) break;
+    thread_ = std::thread([this]() {
+      // if pause_ equals -1, scheduler will not run
+      if (pause_ == std::chrono::seconds(-1)) return;
+      auto start_time = std::chrono::system_clock::now();
+      for (;;) {
+        if (!is_working_.load()) break;
 
-          func_(); 
+        func_();
 
-          std::unique_lock<std::mutex> lk(mutex_);
+        std::unique_lock<std::mutex> lk(mutex_);
 
-          auto now = std::chrono::system_clock::now();
-          while(now >= start_time) start_time += pause_;
+        auto now = std::chrono::system_clock::now();
+        while (now >= start_time) start_time += pause_;
 
-          condition_variable_.wait_for(lk, start_time - now, [&] {
-            return is_working_.load() == false;
-          });
-          lk.unlock();
-        }
+        condition_variable_.wait_for(
+            lk, start_time - now, [&] { return is_working_.load() == false; });
+        lk.unlock();
+      }
     });
   }
 
-  ~Scheduler() { 
-    is_working_.store(false); 
+  ~Scheduler() {
+    is_working_.store(false);
     {
       std::unique_lock<std::mutex> lk(mutex_);
       condition_variable_.notify_one();
@@ -65,15 +64,15 @@ class Scheduler {
   /**
    * Function which scheduler executes.
    */
-  const std::function <void()> &func_;
+  const std::function<void()> func_;
   /**
    * Mutex used to synchronize threads using condition variable.
    */
   TMutex mutex_;
 
   /**
-   * Condition variable is used to stop waiting until the end of the 
-   * time interval if destructor is  called. 
+   * Condition variable is used to stop waiting until the end of the
+   * time interval if destructor is  called.
    */
   std::condition_variable condition_variable_;
   /**