Chrono uses synchronized_value

Author: Klaim

libmamba/src/core/progress_bar_impl.cpp

@@ -239,32 +239,32 @@ namespace mamba
 
     bool Chrono::started() const
     {
-        return m_state == ChronoState::started;
+        return m_data->state == ChronoState::started;
     }
 
     bool Chrono::paused() const
     {
-        return m_state == ChronoState::paused;
+        return m_data->state == ChronoState::paused;
     }
 
     bool Chrono::stopped() const
     {
-        return m_state == ChronoState::stopped;
+        return m_data->state == ChronoState::stopped;
     }
 
     bool Chrono::terminated() const
     {
-        return m_state == ChronoState::terminated;
+        return m_data->state == ChronoState::terminated;
     }
 
     bool Chrono::unset() const
     {
-        return m_state == ChronoState::unset;
+        return m_data->state == ChronoState::unset;
     }
 
     ChronoState Chrono::status() const
     {
-        return m_state;
+        return m_data->state;
     }
 
     void Chrono::start()
@@ -274,25 +274,24 @@ namespace mamba
 
     void Chrono::start(const time_point_t& time_point)
     {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_start = time_point;
-        m_state = ChronoState::started;
+        auto synched_data = m_data.synchronize();
+        synched_data->start = time_point;
+        synched_data->state = ChronoState::started;
     }
 
     void Chrono::pause()
     {
         compute_elapsed();
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_state = ChronoState::paused;
+        m_data->state = ChronoState::paused;
     }
 
     void Chrono::resume()
     {
-        if (m_state != ChronoState::started)
+        auto synched_data = m_data.synchronize();
+        if (synched_data->state != ChronoState::started)
         {
-            std::lock_guard<std::mutex> lock(m_mutex);
-            m_state = ChronoState::started;
-            m_start = now() - m_elapsed_ns;
+            synched_data->state = ChronoState::started;
+            synched_data->start = now() - synched_data->elapsed_ns;
         }
     }
 

libmamba/src/core/progress_bar_impl.hpp

@@ -75,12 +75,21 @@ namespace mamba
 
         std::unique_lock<std::mutex> chrono_lock();
 
+
     private:
 
-        time_point_t m_start;
-        duration_t m_elapsed_ns = duration_t::zero();
-        ChronoState m_state = ChronoState::unset;
-        std::mutex m_mutex;
+        struct Data
+        {
+            Data()  // workaround for CWG2335
+            {
+            }
+
+            time_point_t start;
+            duration_t elapsed_ns = duration_t::zero();
+            ChronoState state = ChronoState::unset;
+        };
+
+        util::synchronized_value<Data> m_data;
 
         void compute_elapsed();