ceph/src/boost/libs/chrono/stopwatches/include/boost/chrono/stopwatches/stopwatch_scoped.hpp

   1 //  boost/chrono/stopwatches/stopwatch_scoped.hpp  ------------------------------------------------------------//
   2 //  Copyright 2009-2011 Vicente J. Botet Escriba
   3 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5 //  See http://www.boost.org/libs/chrono/stopwatches for documentation.
   6
   7 #ifndef BOOST_CHRONO_STOPWATCHES_STOPWATCH_SCOPED_HPP
   8 #define BOOST_CHRONO_STOPWATCHES_STOPWATCH_SCOPED_HPP
   9
  10 #include <boost/chrono/config.hpp>
  11
  12 #include <boost/chrono/chrono.hpp>
  13 #include <boost/chrono/detail/system.hpp>
  14
  15 namespace boost
  16 {
  17   namespace chrono
  18   {
  19
  20     //--------------------------------------------------------------------------------------//
  21     template<class Stopwatch>
  22     class stopwatch_runner
  23     {
  24     public:
  25       typedef Stopwatch stopwatch;
  26       stopwatch_runner(stopwatch & a) :
  27         stopwatch_(a)
  28       {
  29         stopwatch_.start();
  30       }
  31 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  32       stopwatch_runner(stopwatch & a, system::error_code & ec) :
  33         stopwatch_(a)
  34       {
  35         stopwatch_.start(ec);
  36       }
  37 #endif
  38       ~stopwatch_runner()
  39       {
  40         stopwatch_.stop();
  41       }
  42     private:
  43       stopwatch& stopwatch_;
  44       stopwatch_runner();//= delete;
  45       stopwatch_runner(const stopwatch_runner&); // = delete;
  46       stopwatch_runner& operator=(const stopwatch_runner&); // = delete;
  47
  48     };
  49
  50     //--------------------------------------------------------------------------------------//
  51     template<class Stopwatch>
  52     class stopwatch_stopper
  53     {
  54     public:
  55       typedef Stopwatch stopwatch;
  56       stopwatch_stopper(stopwatch & a) :
  57         stopwatch_(a)
  58       {
  59         stopwatch_.stop();
  60       }
  61 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  62       stopwatch_stopper(stopwatch & a, system::error_code & ec) :
  63         stopwatch_(a)
  64       {
  65         stopwatch_.stop(ec);
  66       }
  67 #endif
  68       ~stopwatch_stopper()
  69       {
  70         stopwatch_.start();
  71       }
  72     private:
  73       stopwatch& stopwatch_;
  74       stopwatch_stopper();//= delete;
  75       stopwatch_stopper(const stopwatch_stopper&); // = delete;
  76       stopwatch_stopper& operator=(const stopwatch_stopper&); // = delete;
  77
  78     };
  79
  80     //--------------------------------------------------------------------------------------//
  81     template<class Stopwatch>
  82     class stopwatch_suspender
  83     {
  84     public:
  85       typedef Stopwatch stopwatch;
  86       stopwatch_suspender(stopwatch & a) :
  87         stopwatch_(a)
  88       {
  89         stopwatch_.suspend();
  90       }
  91 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  92       stopwatch_suspender(stopwatch & a, system::error_code & ec) :
  93         stopwatch_(a)
  94       {
  95         stopwatch_.suspend(ec);
  96       }
  97 #endif
  98
  99       ~stopwatch_suspender()
 100       {
 101         stopwatch_.resume();
 102       }
 103     private:
 104       stopwatch& stopwatch_;
 105       stopwatch_suspender(); // = delete;
 106       stopwatch_suspender(const stopwatch_suspender&); // = delete;
 107       stopwatch_suspender& operator=(const stopwatch_suspender&); // = delete;
 108     };
 109
 110     //--------------------------------------------------------------------------------------//
 111     template<class Stopwatch>
 112     class stopwatch_resumer
 113     {
 114     public:
 115       typedef Stopwatch stopwatch;
 116       stopwatch_resumer(stopwatch & a) :
 117         stopwatch_(a)
 118       {
 119         stopwatch_.resume();
 120       }
 121 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
 122       stopwatch_resumer(stopwatch & a, system::error_code & ec) :
 123         stopwatch_(a)
 124       {
 125         stopwatch_.resume(ec);
 126       }
 127 #endif
 128       ~stopwatch_resumer()
 129       {
 130         stopwatch_.suspend();
 131       }
 132     private:
 133       stopwatch& stopwatch_;
 134       stopwatch_resumer(); // = delete;
 135       stopwatch_resumer(const stopwatch_resumer&); // = delete;
 136       stopwatch_resumer& operator=(const stopwatch_resumer&); // = delete;
 137     };
 138
 139   } // namespace chrono
 140 } // namespace boost
 141
 142 #endif