[WIP] ProcessorBase multi-threading

[WIP] Depends on !89 (merged) .

Add a ThreadedBaseClass that ProcessorBase inherit from.

It allows the computation of the ProcessorBase::process(...) to be performed in a separated thread. Threads aren't instantiated/killed but instead are put to sleep waiting for new CaptureBase.

ThreadedBaseClass API is rather simple :

• Constructor with argument max_frequency allowing the user to set guess what, a max frequency at which the processor operates.
• run() to start the thread and so the processor.
• stop() allows to stop the thread and so the processor.
• isRunning() let the user know if the processor is running or not.

Finally it has the pure virtual function :

• executeImpl() where the derived class do its job.

src/timer.h

+#ifndef WOLF_TIMER_H_
+#define WOLF_TIMER_H_
+
+#include <chrono>
+
+namespace wolf
+{
+namespace details
+{
+using std::chrono::hours;
+using std::chrono::minutes;
+using std::chrono::seconds;
+using std::chrono::milliseconds;
+using std::chrono::microseconds;
+using std::chrono::nanoseconds;
+
+template<typename _Clock, typename _Dur>
+using time_point = std::chrono::time_point<_Clock, _Dur>;
+
+using wolf_time_unit = nanoseconds;
+using wolf_clock_t   = std::chrono::_V2::high_resolution_clock;
+} // namespace details
+
+/**
+ * @brief Timer. A tic-toc timer.
+ *
+ * Mesure the elapsed time between construction - or tic() -
+ * and toc(). The elapsed time is expressed in unit.
+ *
+ * @param unit. The time unit.
+ * @see unit
+ */
+template <typename unit>
+class Timer
+{
+public:
+
+  /**
+   * @brief Timer. Launch the timer.
+   */
+  Timer(): start_(now()) { }
+
+  /**
+   * @brief ~Timer. Default desctructor.
+   */
+  ~Timer() = default;
+
+  /**
+   * @brief tic. Reset the timer.
+   */
+  void tic()
+  {
+    start_ = now();
+  }
+
+  /**
+   * @brief toc. Return this elapsed time since construction or last tic().
+   * @return double. The elapsed time.
+   * @see tic()
+   */
+  template <typename T = int64_t>
+  T toc()
+  {
+    return static_cast<T>(cast_d(now() - start_).count());
+  }
+
+protected:
+
+  details::time_point<details::wolf_clock_t, unit> start_;
+
+  template <typename... Args>
+  auto cast_d(Args&&... args) ->
+    decltype(std::chrono::duration_cast<unit>(std::forward<Args>(args)...))
+  {
+    return std::chrono::duration_cast<unit>(std::forward<Args>(args)...);
+  }
+
+  template <typename... Args>
+  auto cast(Args&&... args) ->
+    decltype(std::chrono::time_point_cast<unit>(std::forward<Args>(args)...))
+  {
+    return std::chrono::time_point_cast<unit>(std::forward<Args>(args)...);
+  }
+
+  auto now() ->
+  decltype(std::declval<Timer<unit>>().cast(details::wolf_clock_t::now()))
+  {
+    return cast(std::chrono::system_clock::now());
+  }
+};
+
+using timer_secs  = Timer<details::seconds>;
+using timer_msecs = Timer<details::milliseconds>;
+using timer_usecs = Timer<details::microseconds>;
+using timer_nsecs = Timer<details::microseconds>;
+
+} // namespace wolf
+#endif // WOLF_TIMER_H_