boost/libs/chrono/stopwatches/include/boost/chrono/stopwatches/reporters/stopclock.hpp

//  boost/chrono/stopwatches/reporters/stopclock.hpp
//  Copyright 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_REPORTERS_LAPS_STOPCLOCK_HPP
#define BOOST_CHRONO_STOPWATCHES_REPORTERS_LAPS_STOPCLOCK_HPP

#include <boost/chrono/config.hpp>

#if !defined(BOOST_ENABLE_WARNINGS) && !defined(BOOST_CHRONO_ENABLE_WARNINGS)
#if defined __GNUC__
#pragma GCC system_header
#elif defined __SUNPRO_CC
#pragma disable_warn
#elif defined _MSC_VER
#pragma warning(push, 1)
#endif
#endif

#include <boost/chrono/stopwatches/reporters/laps_accumulator_set_stopwatch_default_formatter.hpp>
#include <boost/chrono/stopwatches/reporters/stopwatch_reporter_default_formatter.hpp>
#include <boost/chrono/stopwatches/reporters/stopwatch_reporter.hpp>
#include <boost/chrono/stopwatches/stopwatch_scoped.hpp>
#include <boost/chrono/stopwatches/stopwatch.hpp>
#include <boost/chrono/stopwatches/dont_start.hpp>
#include <boost/chrono/chrono.hpp>
#include <boost/chrono/detail/system.hpp>
#include <boost/cstdint.hpp>
#include <cassert>

namespace boost
{
  namespace chrono
  {

    template<class CharT, typename Clock, typename LapsCollector, class Formatter>
    class basic_stopclock: public basic_stopwatch_reporter<CharT, stopwatch<Clock, LapsCollector>, Formatter>
    {
    public:
      typedef basic_stopwatch_reporter<CharT, stopwatch<Clock, LapsCollector>, Formatter> base_type;
      typedef Clock clock;
      typedef stopwatch<Clock, LapsCollector> stopwatch_type;
      typedef Formatter formatter_type;

      basic_stopclock()
      {
      }

#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
      explicit basic_stopclock(system::error_code & ec) :
        base_type(ec)
      {
      }
#endif
      explicit basic_stopclock(
          const dont_start_t& tag
      ) BOOST_NOEXCEPT :
      base_type(tag)
      {
      }

      explicit basic_stopclock(formatter_type const& fmt) :
        base_type(fmt)
      {
      }

      explicit basic_stopclock(const typename Formatter::char_type* fmt) :
        base_type(fmt)
      {
      }
      explicit basic_stopclock(typename Formatter::string_type const& fmt) :
        base_type(fmt)
      {
      }
      typedef stopwatch_runner<basic_stopclock<CharT,Clock, LapsCollector, Formatter> >
          scoped_run;
      typedef stopwatch_stopper<basic_stopclock<CharT,Clock, LapsCollector, Formatter> >
          scoped_stop;
      typedef stopwatch_suspender<basic_stopclock<CharT,Clock, LapsCollector, Formatter> >
          scoped_suspend;
      typedef stopwatch_resumer<basic_stopclock<CharT,Clock, LapsCollector, Formatter> >
          scoped_resume;

    protected:

      basic_stopclock(const basic_stopclock&); // = delete;
      basic_stopclock& operator=(const basic_stopclock&); // = delete;
    };


    template<typename Clock=high_resolution_clock, typename LapsCollector=no_memory<typename Clock::duration>,
        class Formatter = typename basic_stopwatch_reporter_default_formatter<char, stopwatch<Clock, LapsCollector> >::type>
    class stopclock;

    template<class Stopwatch, class Formatter>
    struct basic_stopwatch_reporter_default_formatter<char, stopclock<Stopwatch,
        Formatter> >
    {
      typedef Formatter type;
    };

    template<typename Clock, typename LapsCollector, class Formatter>
    class stopclock: public basic_stopclock<char, Clock, LapsCollector, Formatter>
    {
      typedef basic_stopclock<char, Clock, LapsCollector, Formatter> base_type;
    public:
      typedef Clock clock;
      typedef typename base_type::stopwatch_type stopwatch_type;
      typedef Formatter formatter_type;

      stopclock()
      {
      }

#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
      explicit stopclock(system::error_code & ec) :
        base_type(ec)
      {
      }
#endif
      explicit stopclock(
          const dont_start_t& tag
      ) BOOST_NOEXCEPT :
      base_type(tag)
      {
      }

      explicit stopclock(formatter_type const& fmt) :
        base_type(fmt)
      {
      }

      explicit stopclock(const typename Formatter::char_type* fmt) :
        base_type(fmt)
      {
      }
      explicit stopclock(typename Formatter::string_type const& fmt) :
        base_type(fmt)
      {
      }
      typedef stopwatch_runner<stopclock<Clock, LapsCollector, Formatter> >
          scoped_run;
      typedef stopwatch_stopper<stopclock<Clock, LapsCollector, Formatter> >
          scoped_stop;
      typedef stopwatch_suspender<stopclock<Clock, LapsCollector, Formatter> >
          scoped_suspend;
      typedef stopwatch_resumer<stopclock<Clock, LapsCollector, Formatter> >
          scoped_resume;

    protected:

      stopclock(const stopclock&); // = delete;
      stopclock& operator=(const stopclock&); // = delete;
    };



  } // namespace chrono
} // namespace boost


#if !defined(BOOST_ENABLE_WARNINGS) && !defined(BOOST_CHRONO_ENABLE_WARNINGS)
#if defined __SUNPRO_CC
#pragma enable_warn
#elif defined _MSC_VER
#pragma warning(pop)
#endif
#endif

#endif