| // boost/chrono/stopwatches/stopwatch_scoped.hpp ------------------------------------------------------------// |
| // Copyright 2009-2011 Vicente J. Botet Escriba |
| // Distributed under the Boost Software License, Version 1.0. (See accompanying |
| // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| // See http://www.boost.org/libs/chrono/stopwatches for documentation. |
| |
| #ifndef BOOST_CHRONO_STOPWATCHES_STOPWATCH_SCOPED_HPP |
| #define BOOST_CHRONO_STOPWATCHES_STOPWATCH_SCOPED_HPP |
| |
| #include <boost/chrono/config.hpp> |
| |
| #include <boost/chrono/chrono.hpp> |
| #include <boost/chrono/detail/system.hpp> |
| |
| namespace boost |
| { |
| namespace chrono |
| { |
| |
| //--------------------------------------------------------------------------------------// |
| template<class Stopwatch> |
| class stopwatch_runner |
| { |
| public: |
| typedef Stopwatch stopwatch; |
| stopwatch_runner(stopwatch & a) : |
| stopwatch_(a) |
| { |
| stopwatch_.start(); |
| } |
| #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING |
| stopwatch_runner(stopwatch & a, system::error_code & ec) : |
| stopwatch_(a) |
| { |
| stopwatch_.start(ec); |
| } |
| #endif |
| ~stopwatch_runner() |
| { |
| stopwatch_.stop(); |
| } |
| private: |
| stopwatch& stopwatch_; |
| stopwatch_runner();//= delete; |
| stopwatch_runner(const stopwatch_runner&); // = delete; |
| stopwatch_runner& operator=(const stopwatch_runner&); // = delete; |
| |
| }; |
| |
| //--------------------------------------------------------------------------------------// |
| template<class Stopwatch> |
| class stopwatch_stopper |
| { |
| public: |
| typedef Stopwatch stopwatch; |
| stopwatch_stopper(stopwatch & a) : |
| stopwatch_(a) |
| { |
| stopwatch_.stop(); |
| } |
| #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING |
| stopwatch_stopper(stopwatch & a, system::error_code & ec) : |
| stopwatch_(a) |
| { |
| stopwatch_.stop(ec); |
| } |
| #endif |
| ~stopwatch_stopper() |
| { |
| stopwatch_.start(); |
| } |
| 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; |
| stopwatch_suspender(stopwatch & a) : |
| stopwatch_(a) |
| { |
| stopwatch_.suspend(); |
| } |
| #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING |
| stopwatch_suspender(stopwatch & a, system::error_code & ec) : |
| stopwatch_(a) |
| { |
| stopwatch_.suspend(ec); |
| } |
| #endif |
| |
| ~stopwatch_suspender() |
| { |
| stopwatch_.resume(); |
| } |
| private: |
| stopwatch& stopwatch_; |
| stopwatch_suspender(); // = delete; |
| stopwatch_suspender(const stopwatch_suspender&); // = delete; |
| stopwatch_suspender& operator=(const stopwatch_suspender&); // = delete; |
| }; |
| |
| //--------------------------------------------------------------------------------------// |
| template<class Stopwatch> |
| class stopwatch_resumer |
| { |
| public: |
| typedef Stopwatch stopwatch; |
| stopwatch_resumer(stopwatch & a) : |
| stopwatch_(a) |
| { |
| stopwatch_.resume(); |
| } |
| #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING |
| stopwatch_resumer(stopwatch & a, system::error_code & ec) : |
| stopwatch_(a) |
| { |
| stopwatch_.resume(ec); |
| } |
| #endif |
| ~stopwatch_resumer() |
| { |
| stopwatch_.suspend(); |
| } |
| private: |
| stopwatch& stopwatch_; |
| stopwatch_resumer(); // = delete; |
| stopwatch_resumer(const stopwatch_resumer&); // = delete; |
| stopwatch_resumer& operator=(const stopwatch_resumer&); // = delete; |
| }; |
| |
| } // namespace chrono |
| } // namespace boost |
| |
| #endif |