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

//  boost/chrono/stopwatches/reporters/strict_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_STRICT_STOPCLOCK_HPP
#define BOOST_CHRONO_STOPWATCHES_REPORTERS_STRICT_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/stopwatch_reporter_default_formatter.hpp>
#include <boost/chrono/stopwatches/reporters/stopwatch_reporter.hpp>
#include <boost/chrono/stopwatches/strict_stopwatch.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, class Formatter>
    class basic_strict_stopclock: public basic_stopwatch_reporter<CharT, strict_stopwatch<Clock>, Formatter>
    {
    public:
      typedef basic_stopwatch_reporter<CharT, strict_stopwatch<Clock>, Formatter> base_type;
      typedef Clock clock;
      typedef strict_stopwatch<Clock> stopwatch;
      typedef Formatter formatter_type;

      basic_strict_stopclock()
      {
      }

#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
      explicit basic_strict_stopclock(system::error_code & ec) :
        base_type(ec)
      {
      }
#endif

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

      explicit basic_strict_stopclock(const typename Formatter::char_type* fmt) :
        base_type(fmt)
      {
      }
      explicit basic_strict_stopclock(typename Formatter::string_type const& fmt) :
        base_type(fmt)
      {
      }

    protected:

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


    template<typename Clock=high_resolution_clock,
        class Formatter = typename basic_stopwatch_reporter_default_formatter<char, strict_stopwatch<Clock> >::type>
    class strict_stopclock;

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

    template<typename Clock, class Formatter>
    class strict_stopclock: public basic_strict_stopclock<char, Clock, Formatter>
    {
      typedef basic_strict_stopclock<char, Clock, Formatter> base_type;
    public:
      typedef Clock clock;
      typedef typename base_type::stopwatch stopwatch;
      typedef Formatter formatter_type;

      strict_stopclock()
      {
      }

#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
      explicit strict_stopclock(system::error_code & ec) :
        base_type(ec)
      {
      }
#endif

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

      explicit strict_stopclock(const typename Formatter::char_type* fmt) :
        base_type(fmt)
      {
      }
      explicit strict_stopclock(typename Formatter::string_type const& fmt) :
        base_type(fmt)
      {
      }

    protected:

      strict_stopclock(const strict_stopclock&); // = delete;
      strict_stopclock& operator=(const strict_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