simplify progress handler code

Base/Progress/DelayedProgressCounter.cpp

@@ -14,12 +14,15 @@
 
 #include "Base/Progress/DelayedProgressCounter.h"
 #include "Base/Progress/ProgressHandler.h"
+#include <stdexcept>
 
-DelayedProgressCounter::DelayedProgressCounter(ProgressHandler* p_progress, size_t interval)
-    : m_progress(p_progress)
+DelayedProgressCounter::DelayedProgressCounter(ProgressHandler* progress, size_t interval)
+    : m_progress(progress)
     , m_interval(interval)
     , m_count(0)
 {
+    if (!progress->alive())
+        throw std::runtime_error("dead process (user interrupt?)");
 }
 
 void DelayedProgressCounter::stepProgress()

Base/Progress/DelayedProgressCounter.h

@@ -26,7 +26,7 @@ class ProgressHandler;
 
 class DelayedProgressCounter {
 public:
-    DelayedProgressCounter(ProgressHandler* p_progress, size_t interval);
+    DelayedProgressCounter(ProgressHandler* progress, size_t interval);
     ~DelayedProgressCounter() = default;
 
     //! Increments inner counter; at regular intervals updates progress handler.

Sim/Computation/DWBAComputation.cpp

@@ -43,8 +43,6 @@ DWBAComputation::~DWBAComputation() = default;
 void DWBAComputation::runProtected()
 {
     for (auto it = m_begin_it; it != m_end_it; ++it) {
-        if (!m_progress->alive())
-            break;
         DiffuseElement& ele = *it;
 
         const Fluxes fluxes_in = m_re_sample.fluxesIn(ele.getKi());

Sim/Computation/IComputation.cpp

@@ -21,29 +21,20 @@ IComputation::IComputation(const ReSample& re_sample, const SimulationOptions& o
                            ProgressHandler& progress)
     : m_re_sample(re_sample)
     , m_options(options)
-    , m_progress(&progress)
+    , m_progress_counter(std::make_unique<DelayedProgressCounter>(&progress, 100))
 {
 }
 
 IComputation::~IComputation() = default;
 
-void IComputation::setProgressHandler(ProgressHandler* progress) const
-{
-    m_progress_counter = std::make_unique<DelayedProgressCounter>(progress, 100);
-}
-
 void IComputation::stepProgress() const
 {
-    if (m_progress_counter)
-        m_progress_counter->stepProgress();
+    m_progress_counter->stepProgress();
 }
 
 void IComputation::compute()
 {
     try {
-        if (!m_progress->alive())
-            return;
-        setProgressHandler(m_progress);
 
         runProtected(); // <--- here the main work is done
 

Sim/Computation/IComputation.h

@@ -44,12 +44,10 @@ public:
     std::string errorMessage() const { return m_errorMessage; }
 
 protected:
-    void setProgressHandler(ProgressHandler* progress) const;
     void stepProgress() const;
 
     const ReSample& m_re_sample;
     const SimulationOptions& m_options;
-    ProgressHandler* m_progress;
 
 private:
     //! Runs computation. May throw. To be called from runProtected(), which catches exceptions.