Simpler communication with progress printer thread

include/ConsoleProgress.hpp

@@ -3,8 +3,7 @@
 
 #include "Progress.hpp"
 
-#include <condition_variable>
-#include <mutex>
+#include <future>
 #include <thread>
 
 /// Progress indicator which prints itself at regular time intervals
@@ -21,9 +20,7 @@ class ConsoleProgress : public Progress
 private:
     const std::chrono::milliseconds m_interval;
 
-    std::mutex              m_in_destructor_mutex;
-    std::condition_variable m_in_destructor_cv;
-    bool                    m_in_destructor;
+    std::promise<void> m_inDestructor;
 
     std::thread m_printer;
     void        printerFunction();

src/ConsoleProgress.cpp

@@ -5,34 +5,24 @@
 ConsoleProgress::ConsoleProgress(std::ostream& os, const std::chrono::milliseconds& interval)
 : Progress{os}
 , m_interval{interval}
-, m_in_destructor{false}
 , m_printer{&ConsoleProgress::printerFunction, this}
 {
 }
 
 ConsoleProgress::~ConsoleProgress()
 {
-    {
-        const auto lock = std::scoped_lock{m_in_destructor_mutex};
-        m_in_destructor = true;
-    }
-
-    m_in_destructor_cv.notify_all();
+    m_inDestructor.set_value();
     m_printer.join();
 }
 
 void ConsoleProgress::printerFunction()
 {
-    auto repeat = true;
+    const auto inDestructor = m_inDestructor.get_future();
 
     // Give a small delay before the first time progress is printed so that
     // the running operation is likely to have initialized the total number of steps.
-    {
-        auto lock = std::unique_lock{m_in_destructor_mutex};
-        repeat = !m_in_destructor_cv.wait_for(lock, std::chrono::milliseconds{1}, [this] { return m_in_destructor; });
-    }
-
-    while (repeat)
+    for (auto status = inDestructor.wait_for(std::chrono::milliseconds{1}); status != std::future_status::ready;
+         status      = inDestructor.wait_for(m_interval))
     {
         if (const auto total = this->total.load())
             log(
@@ -47,9 +37,6 @@ void ConsoleProgress::printerFunction()
                     os.precision(precisionBefore);
                     os.flags(flagsBefore);
                 });
-
-        auto lock = std::unique_lock{m_in_destructor_mutex};
-        repeat    = !m_in_destructor_cv.wait_for(lock, m_interval, [this] { return m_in_destructor; });
     }
 
     if (const auto total = this->total.load())