[Boost-commit] svn:boost r59227 - sandbox/chrono/boost/chrono

Subject: [Boost-commit] svn:boost r59227 - sandbox/chrono/boost/chrono
From: vicente.botet_at_[hidden]
Date: 2010-01-22 13:33:46

Author: viboes
Date: 2010-01-22 13:33:45 EST (Fri, 22 Jan 2010)
New Revision: 59227
URL: http://svn.boost.org/trac/boost/changeset/59227

Log:
Boost.Chrono: Version 0.3.2, 
* added scoped_stopper
* add kind running or running_and_idle so stopwatch_accumulator can provide just run times or also idle times
*
Text files modified: 
   sandbox/chrono/boost/chrono/stopwatch.hpp             |     1                                         
   sandbox/chrono/boost/chrono/stopwatch_accumulator.hpp |   217 +++++++++++++++++++++++++++++---------- 
   sandbox/chrono/boost/chrono/stopwatch_reporter.hpp    |     1                                         
   sandbox/chrono/boost/chrono/stopwatch_scoped.hpp      |    26 ++++                                    
   4 files changed, 186 insertions(+), 59 deletions(-)

Modified: sandbox/chrono/boost/chrono/stopwatch.hpp
==============================================================================
--- sandbox/chrono/boost/chrono/stopwatch.hpp	(original)
+++ sandbox/chrono/boost/chrono/stopwatch.hpp	2010-01-22 13:33:45 EST (Fri, 22 Jan 2010)
@@ -161,6 +161,7 @@
         }
 
         typedef stopwatch_runner<stopwatch<Clock> > scoped_run;
+        typedef stopwatch_stopper<stopwatch<Clock> > scoped_stop;
         typedef stopwatch_suspender<stopwatch<Clock> > scoped_suspend;
         typedef stopwatch_resumer<stopwatch<Clock> > scoped_resume;
         typedef stopwatch_reporter<stopwatch<Clock> > reporter;

Modified: sandbox/chrono/boost/chrono/stopwatch_accumulator.hpp
==============================================================================
--- sandbox/chrono/boost/chrono/stopwatch_accumulator.hpp	(original)
+++ sandbox/chrono/boost/chrono/stopwatch_accumulator.hpp	2010-01-22 13:33:45 EST (Fri, 22 Jan 2010)
@@ -25,10 +25,7 @@
 
 #include <boost/config/abi_prefix.hpp> // must be the last #include
 
-namespace boost
-{
-  namespace chrono
-  {
+namespace boost {  namespace chrono {
 
 //--------------------------------------------------------------------------------------//
 //                                    stopwatch
@@ -45,8 +42,106 @@
 //~ but the watch mechanism continues running to record total elapsed time.
 //--------------------------------------------------------------------------------------//
 
+namespace kind {
+struct idle {};
+struct running {};
+struct running_and_idle {};
+}
+namespace detail {
+template <
+    class Clock,
+    class RunningIdleKind,
+    class Accumulator
+>
+struct basic_stopwatch_accumulator;
+    
+template <
+    class Clock,
+    class Accumulator
+>
+class basic_stopwatch_accumulator<Clock, kind::running, Accumulator> {
+public:
+    typedef Clock                       clock;
+    typedef typename Clock::duration    duration;
+    typedef typename Clock::time_point  time_point;
+    typedef Accumulator accumulator;
+
+    accumulator& accumulated( ) { return accumulated_; }   
+  
+protected:
+    basic_stopwatch_accumulator( )
+    : running_(false), suspended_(false), accumulated_(), 
+      partial_(duration::zero()), start_((duration::zero())), level_(0), suspend_level_(0)
+    {}
+
+    void idle_on_start(time_point &) {}
+    void idle_on_stop(time_point &) {}
+    
+    bool running_;
+    bool suspended_;
+    accumulator accumulated_;
+    duration partial_;
+    time_point start_;
+    std::size_t level_;
+    std::size_t suspend_level_;
+    
+};
+
+        
+template <
+    class Clock,
+    class Accumulator
+>
+class basic_stopwatch_accumulator<Clock, kind::running_and_idle, Accumulator> 
+    : public basic_stopwatch_accumulator<Clock, kind::running, Accumulator>
+{
+        typedef basic_stopwatch_accumulator<Clock, kind::running, Accumulator> base_type;
+public:
+    typedef Clock                       clock;
+    typedef typename Clock::duration    duration;
+    typedef typename Clock::time_point  time_point;
+    typedef Accumulator accumulator;
+
+    accumulator& idle_accumulated( ) { return idle_accumulated_; }   
+    
+protected:
+    basic_stopwatch_accumulator( )
+    : base_type(),
+      stopped_(false), idle_accumulated_(), idle_partial_(duration::zero()), stop_(duration::zero()) 
+    {}
+
+    void idle_on_start(time_point &tmp) {
+        if (stopped_) {
+            idle_partial_ += tmp - this->start_;
+            idle_accumulated_(idle_partial_.count());
+            idle_partial_=duration::zero();
+        }
+    }
+
+    void idle_on_stop(time_point &tmp) {
+        stop_ = tmp;
+        stopped_=true;
+    }
+
+    void idle_on_reset() {
+        stopped_=false;
+        idle_accumulated_ = accumulator();
+        idle_partial_=duration::zero();
+        stop_  = time_point(duration::zero());
+    }
+    
+    bool stopped_;
+    accumulator idle_accumulated_;
+    duration idle_partial_;
+    time_point stop_;
+};
+
+}        
+
+
     // forward declaration
     template <class Clock=high_resolution_clock,
+        class RunningIdleKind=kind::running,
         class Accumulator=accumulators::accumulator_set<typename Clock::duration::rep,
                     accumulators::features<
                         accumulators::tag::count,
@@ -64,71 +159,79 @@
     };
 
 //--------------------------------------------------------------------------------------//
-    template <class Clock, class Accumulator>
-    class stopwatch_accumulator
+    template <class Clock, class RunningIdleKind, class Accumulator >
+    class stopwatch_accumulator 
+        : public detail::basic_stopwatch_accumulator<Clock, RunningIdleKind, Accumulator>
     {
+        typedef detail::basic_stopwatch_accumulator<Clock, RunningIdleKind, Accumulator> base_type;
     public:
         typedef Clock                       clock;
         typedef typename Clock::duration    duration;
         typedef typename Clock::time_point  time_point;
         typedef Accumulator accumulator;
 
-        stopwatch_accumulator( )
-        : running_(false), suspended_(false), accumulated_(), 
-          partial_(), start_(duration::zero()), level_(0), suspend_level_(0)
-        {}
+        stopwatch_accumulator( ) : base_type() {}
 
         std::pair<duration, time_point>  restart( system::error_code & ec = system::throws ) {
             time_point tmp=clock::now( ec );
             if (ec) return time_point();
-            if (running_&&(--level_==0)) {
-                partial_ += tmp - start_;
-                accumulated_(partial_.count());
-                partial_=duration::zero();
+            if (this->running_&&(--this->level_==0)) {
+                this->partial_ += tmp - this->start_;
+                this->accumulated_(this->partial_.count());
+                this->partial_=duration::zero();
             } else {
-                running_=true;
+                this->running_=true;
             }
-            start_=tmp;
-            ++level_;
-            return std::make_pair(duration(accumulators::sum(accumulated_)),start_);
+            this->start_=tmp;
+            ++this->level_;
+            return std::make_pair(duration(accumulators::sum(this->accumulated_)),this->start_);
         }
 
         time_point start( system::error_code & ec = system::throws ) {
-            ++level_;
-            if (!running_) {
+            if (!this->running_) {
                 time_point tmp = clock::now( ec );
                 if (ec) return time_point();
-                start_ = tmp;
-                running_ = true;
-                return start_;
+                ++this->level_;
+                this->start_ = tmp;
+                this->running_ = true;
+                this->idle_on_start(tmp);
+                return this->start_;
             }  else {
+                ++this->level_;
                 return time_point();
             }
         }
 
         duration stop( system::error_code & ec = system::throws ) {
-            if (running_&&(--level_==0)) {
-                time_point tmp=clock::now( ec );
-                if (ec) return duration::zero();
-                partial_ += tmp - start_;
-                accumulated_(partial_.count());
-                partial_=duration::zero();
-                running_=false;
-                return duration(accumulators::extract::sum(accumulated_));
+            if (this->running_) {
+                if (this->level_==1) {
+                    time_point tmp=clock::now( ec );
+                    if (ec) return duration::zero();
+                    --this->level_;
+                    this->partial_ += tmp - this->start_;
+                    this->accumulated_(this->partial_.count());
+                    this->partial_=duration::zero();
+                    this->running_=false;
+                    this->idle_on_stop(tmp);
+                    return duration(accumulators::extract::sum(this->accumulated_));
+                } else {
+                   --this->level_; 
+                   return duration::zero();
+                }
             } else {
                 return duration::zero();
             }
         }
 
         duration suspend( system::error_code & ec = system::throws ) {
-            if (running_) {
-                ++suspend_level_;
-                if (!suspended_) {
+            if (this->running_) {
+                ++this->suspend_level_;
+                if (!this->suspended_) {
                     time_point tmp=clock::now( ec );
                     if (ec) return duration::zero();
-                    partial_ += tmp - start_;
-                    suspended_=true;
-                    return duration(accumulators::sum(accumulated_));
+                    this->partial_ += tmp - this->start_;
+                    this->suspended_=true;
+                    return duration(accumulators::sum(this->accumulated_));
                 } else {
                     return duration::zero();
                 }
@@ -137,51 +240,47 @@
             }
         }
         time_point resume( system::error_code & ec = system::throws ) {
-            if (suspended_&&(--suspend_level_==0)) {
+            if (this->suspended_&&(--this->suspend_level_==0)) {
                 time_point tmp = clock::now( ec );
                 if (ec) return time_point();
-                start_ = tmp;
-                suspended_=false;
-                return start_;
+                this->start_ = tmp;
+                this->suspended_=false;
+                return this->start_;
             } else {
                 return time_point();
             }
         }
         duration elapsed( system::error_code & ec = system::throws )
         {
-            if (running_) {
-                if (suspended_)
-                    return duration(accumulators::sum(accumulated_));
+            if (this->running_) {
+                if (this->suspended_)
+                    return duration(accumulators::sum(this->accumulated_));
                 else {
                     time_point tmp = clock::now( ec );
                     if (ec) return duration::zero();
-                    return duration(accumulators::sum(accumulated_))+tmp - start_;
+                    return duration(accumulators::sum(this->accumulated_))+tmp - this->start_;
                 }
             } else {
-                return duration(accumulators::sum(accumulated_));
+                return duration(accumulators::sum(this->accumulated_));
             }
         }
 
         void reset( ) {
-            time_point tmp = time_point();
-            start_  = tmp;
-            accumulator tmp2;
-            accumulated_ = tmp2;
+            this->running_=false;
+            this->suspended_=false;
+            this->accumulated_ = accumulator();
+            this->partial_=duration::zero();
+            this->start_  = time_point(duration::zero());
+            this->level_=0;
+            this->suspend_level_=0;
+            this->idle_on_reset();
         }
-        accumulator& accumulated( ) { return accumulated_; }
 
         typedef stopwatch_runner<stopwatch_accumulator<Clock> > scoped_run;
+        typedef stopwatch_stopper<stopwatch_accumulator<Clock> > scoped_stop;
         typedef stopwatch_suspender<stopwatch_accumulator<Clock> > scoped_suspend;
         typedef stopwatch_resumer<stopwatch_accumulator<Clock> > scoped_resume;
         typedef stopwatch_reporter<stopwatch_accumulator<Clock> > reporter;
-    private:
-        bool running_;
-        bool suspended_;
-        accumulator accumulated_;
-        duration partial_;
-        time_point start_;
-        std::size_t level_;
-        std::size_t suspend_level_;
     };
 
 //--------------------------------------------------------------------------------------//

Modified: sandbox/chrono/boost/chrono/stopwatch_reporter.hpp
==============================================================================
--- sandbox/chrono/boost/chrono/stopwatch_reporter.hpp	(original)
+++ sandbox/chrono/boost/chrono/stopwatch_reporter.hpp	2010-01-22 13:33:45 EST (Fri, 22 Jan 2010)
@@ -142,6 +142,7 @@
 
 
         typedef stopwatch_runner<stopwatch_reporter<Stopwatch> > scoped_run;
+        typedef stopwatch_stopper<stopwatch_reporter<Stopwatch> > scoped_stop;
         typedef stopwatch_suspender<stopwatch_reporter<Stopwatch> > scoped_suspend;
         typedef stopwatch_resumer<stopwatch_reporter<Stopwatch> > scoped_resume;
 

Modified: sandbox/chrono/boost/chrono/stopwatch_scoped.hpp
==============================================================================
--- sandbox/chrono/boost/chrono/stopwatch_scoped.hpp	(original)
+++ sandbox/chrono/boost/chrono/stopwatch_scoped.hpp	2010-01-22 13:33:45 EST (Fri, 22 Jan 2010)
@@ -47,6 +47,32 @@
     };
 
 //--------------------------------------------------------------------------------------//
+    template <class Stopwatch> class stopwatch_stopper {
+    public:
+        typedef Stopwatch stopwatch;
+        stopwatch_stopper(stopwatch & a, system::error_code & ec = system::throws)
+        : stopwatch_(a) {
+            stopwatch_.stop(ec);
+        }
+        ~stopwatch_stopper() {
+            system::error_code ec;
+            stopwatch_.start(ec);
+        }
+#if 0
+        typename Stopwatch::duration elapsed(system::error_code & ec = system::throws)
+        {
+            return stopwatch_.elapsed(ec)-stopwatch_.accumulated();
+        }
+#endif
+    private:
+        stopwatch& stopwatch_;
+        stopwatch_stopper();//= delete;
+        stopwatch_stopper(const stopwatch_stopper&); // = delete;
+        stopwatch_stopper& operator=(const stopwatch_stopper&); // = delete;
+
+    };
+
+//--------------------------------------------------------------------------------------//
     template <class Stopwatch> class stopwatch_suspender {
     public:
         typedef Stopwatch stopwatch;