[Boost-commit] svn:boost r74419 - in trunk/boost/chrono: . stopwatches stopwatches/formatters stopwatches/reporters

Subject: [Boost-commit] svn:boost r74419 - in trunk/boost/chrono: . stopwatches stopwatches/formatters stopwatches/reporters
From: vicente.botet_at_[hidden]
Date: 2011-09-16 12:55:10

Author: viboes
Date: 2011-09-16 12:55:09 EDT (Fri, 16 Sep 2011)
New Revision: 74419
URL: http://svn.boost.org/trac/boost/changeset/74419

Log:
Chrono: Added some i/o facilities + a simple stopwatch
Added:
   trunk/boost/chrono/duration_style.hpp   (contents, props changed)
   trunk/boost/chrono/stopwatches/
   trunk/boost/chrono/stopwatches/formatters/
   trunk/boost/chrono/stopwatches/reporters/
   trunk/boost/chrono/stopwatches/simple_stopwatch.hpp   (contents, props changed)
Text files modified: 
   trunk/boost/chrono/ceil.hpp      |     2                                         
   trunk/boost/chrono/chrono_io.hpp |   407 ++++++++++++++++++++++++++++++++++++++- 
   trunk/boost/chrono/config.hpp    |     6                                         
   trunk/boost/chrono/floor.hpp     |     2                                         
   trunk/boost/chrono/round.hpp     |     2                                         
   5 files changed, 404 insertions(+), 15 deletions(-)

Modified: trunk/boost/chrono/ceil.hpp
==============================================================================
--- trunk/boost/chrono/ceil.hpp	(original)
+++ trunk/boost/chrono/ceil.hpp	2011-09-16 12:55:09 EDT (Fri, 16 Sep 2011)
@@ -19,7 +19,7 @@
   {
 
     /**
-     * round up
+     * rounds up
      */
     template <class To, class Rep, class Period>
     To ceil(const duration<Rep, Period>& d)

Modified: trunk/boost/chrono/chrono_io.hpp
==============================================================================
--- trunk/boost/chrono/chrono_io.hpp	(original)
+++ trunk/boost/chrono/chrono_io.hpp	2011-09-16 12:55:09 EDT (Fri, 16 Sep 2011)
@@ -23,6 +23,7 @@
 #include <boost/mpl/if.hpp>
 #include <boost/math/common_factor_rt.hpp>
 #include <boost/chrono/detail/scan_keyword.hpp>
+#include <boost/chrono/round.hpp>
 
 namespace boost
 {
@@ -30,6 +31,13 @@
 namespace chrono
 {
 
+  struct timezone
+  {
+    enum type {
+      utc, local
+    };
+  };
+
 template <class CharT>
 class duration_punct
     : public std::locale::facet
@@ -67,15 +75,16 @@
 public:
     static std::locale::id id;
 
-    explicit duration_punct(int use = use_long)
-        : use_short_(use==use_short) {init_C();}
+    explicit duration_punct(int use = use_long, size_t refs = 0)
+        : std::locale::facet(refs),  use_short_(use==use_short) {init_C();}
 
     duration_punct(int use,
         const string_type& long_seconds, const string_type& long_minutes,
         const string_type& long_hours, const string_type& short_seconds,
-        const string_type& short_minutes, const string_type& short_hours);
+        const string_type& short_minutes, const string_type& short_hours,
+        size_t refs = 0);
 
-    duration_punct(int use, const duration_punct& d);
+    duration_punct(int use, const duration_punct& d, size_t refs = 0);
 
     template <class Period>
         string_type short_name() const
@@ -90,6 +99,11 @@
             if (use_short_) return short_name<Period>();
             else return long_name<Period>();
         }
+    template <class Rep, class Period>
+        string_type name(duration<Rep,Period> const& ) const {
+            if (use_short_) return short_name<Period>();
+            else return long_name<Period>();
+        }
 
     bool is_short_name() const {return use_short_;}
     bool is_long_name() const {return !use_short_;}
@@ -118,8 +132,10 @@
 duration_punct<CharT>::duration_punct(int use,
         const string_type& long_seconds, const string_type& long_minutes,
         const string_type& long_hours, const string_type& short_seconds,
-        const string_type& short_minutes, const string_type& short_hours)
-    : use_short_(use==use_short),
+        const string_type& short_minutes, const string_type& short_hours,
+        size_t refs)
+    : std::locale::facet(refs),
+      use_short_(use==use_short),
       long_seconds_(long_seconds),
       long_minutes_(long_minutes),
       long_hours_(long_hours),
@@ -129,8 +145,10 @@
 {}
 
 template <class CharT>
-duration_punct<CharT>::duration_punct(int use, const duration_punct& d)
-    : use_short_(use==use_short),
+duration_punct<CharT>::duration_punct(int use, const duration_punct& d,
+    size_t refs)
+    : std::locale::facet(refs),
+      use_short_(use==use_short),
       long_seconds_(d.long_seconds_),
       long_minutes_(d.long_minutes_),
       long_hours_(d.long_hours_),
@@ -175,12 +193,31 @@
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d)
 {
+  typename std::basic_ostream<CharT, Traits>::sentry ok(os);
+  if (ok)
+  {
     typedef duration_punct<CharT> Facet;
-    std::locale loc = os.getloc();
-    if (!std::has_facet<Facet>(loc))
+    typedef std::basic_string<CharT, Traits> string_type;
+
+    bool failed = false;
+    try
+    {
+      std::locale loc = os.getloc();
+
+      if (!std::has_facet<Facet>(loc))
         os.imbue(std::locale(loc, new Facet));
-    const Facet& f = std::use_facet<Facet>(os.getloc());
-    return os << d.count() << ' ' << f.template name<Period>();
+      const Facet& f = std::use_facet<Facet>(os.getloc());
+      return os << d.count() << ' ' << f.template name<Rep,Period>(d);
+    }
+    catch (...)
+    {
+        failed = true;
+    }
+    if (failed)
+        os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+
+  }
+  return os;
 }
 
 namespace chrono_detail {
@@ -609,6 +646,102 @@
     }
 };
 
+template <class CharT>
+class time_punct
+    : public std::locale::facet
+{
+public:
+    typedef std::basic_string<CharT> string_type;
+
+private:
+    string_type           fmt_;
+    chrono::timezone::type tz_;
+
+public:
+    static std::locale::id id;
+
+    explicit time_punct(size_t refs = 0)
+        : std::locale::facet(refs), tz_(timezone::utc) {}
+
+    time_punct(timezone::type tz, string_type fmt, size_t refs = 0)
+    // todo use move semantic when available.
+        : std::locale::facet(refs), fmt_(fmt), tz_(tz) {}
+
+    const string_type& fmt() const BOOST_CHRONO_NOEXCEPT {return fmt_;}
+    chrono::timezone::type timezone() const BOOST_CHRONO_NOEXCEPT {return tz_;}
+};
+
+    template <class CharT>
+    std::locale::id
+    time_punct<CharT>::id;
+
+    namespace detail
+    {
+    template<class CharT>
+    struct time_manip
+    {
+        std::basic_string<CharT> fmt_;
+        timezone tz_;
+
+        time_manip(timezone tz, std::basic_string<CharT> fmt)
+        // todo move semantics
+            : fmt_(fmt),
+              tz_(tz) {}
+    };
+
+    // todo move semantics
+    template<class CharT, class Traits>
+    std::basic_ostream<CharT, Traits>&
+    operator <<(std::basic_ostream<CharT, Traits>& os, time_manip<CharT> m)
+    {
+      // todo move semantics
+        os.imbue(std::locale(os.getloc(), new time_punct<CharT>(m.tz_, m.fmt_)));
+        return os;
+    }
+
+    template<class CharT, class Traits>
+    std::basic_istream<CharT, Traits>&
+    operator >>(std::basic_istream<CharT, Traits>& is, time_manip<CharT> m)
+    {
+      // todo move semantics
+        is.imbue(std::locale(is.getloc(), new time_punct<CharT>(m.tz_, m.fmt_)));
+        return is;
+    }
+
+    class time_man
+    {
+        timezone::type form_;
+    public:
+        explicit time_man(timezone::type f) : form_(f) {}
+        // explicit
+            operator timezone::type() const {return form_;}
+    };
+
+    template<class CharT, class Traits>
+    std::basic_ostream<CharT, Traits>&
+    operator <<(std::basic_ostream<CharT, Traits>& os, time_man m)
+    {
+        os.imbue(std::locale(os.getloc(), new time_punct<CharT>(static_cast<timezone::type>(m), std::basic_string<CharT>())));
+        return os;
+    }
+
+    template<class CharT, class Traits>
+    std::basic_istream<CharT, Traits>&
+    operator >>(std::basic_istream<CharT, Traits>& is, time_man m)
+    {
+        is.imbue(std::locale(is.getloc(), new time_punct<CharT>(static_cast<timezone::type>(m), std::basic_string<CharT>())));
+        return is;
+    }
+
+    }
+
+    inline
+    detail::time_man
+    time_fmt(timezone::type f)
+    {
+        return detail::time_man(f);
+    }
+
 template <class CharT, class Traits, class Clock, class Duration>
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os,
@@ -647,8 +780,258 @@
         is.setstate(is.failbit);
     return is;
 }
+#if 0
+template <class _CharT, class _Traits, class _Duration>
+std::basic_ostream<_CharT, _Traits>&
+operator<<(std::basic_ostream<_CharT, _Traits>& os,
+           const time_point<system_clock, _Duration>& tp)
+{
+    typename std::basic_ostream<_CharT, _Traits>::sentry ok(os);
+    if (ok)
+    {
+        bool failed = false;
+        try
+        {
+            const _CharT* pb = 0; //nullptr;
+            const _CharT* pe = pb;
+            timezone::type tz = timezone::utc;
+            typedef time_punct<_CharT> F;
+            std::locale loc = os.getloc();
+            if (std::has_facet<F>(loc))
+            {
+                const F& f = std::use_facet<F>(loc);
+                pb = f.fmt().data();
+                pe = pb + f.fmt().size();
+                tz = f.timezone();
+            }
+            time_t t = system_clock::to_time_t(tp);
+            tm tm;
+            if (tz == timezone::local)
+            {
+                if (localtime_r(&t, &tm) == 0)
+                    failed = true;
+            }
+            else
+            {
+                if (gmtime_r(&t, &tm) == 0)
+                    failed = true;
+            }
+            if (!failed)
+            {
+                const std::time_put<_CharT>& tpf = std::use_facet<std::time_put<_CharT> >(loc);
+                if (pb == pe)
+                {
+                    _CharT pattern[] = {'%', 'F', ' ', '%', 'H', ':', '%', 'M', ':'};
+                    pb = pattern;
+                    pe = pb + sizeof(pattern) / sizeof(_CharT);
+                    failed = tpf.put(os, os, os.fill(), &tm, pb, pe).failed();
+                    if (!failed)
+                    {
+                        duration<double> d = tp - system_clock::from_time_t(t) +
+                                  seconds(tm.tm_sec);
+                        if (d.count() < 10)
+                            os << _CharT('0');
+                        std::ios::fmtflags flgs = os.flags();
+                        os.setf(std::ios::fixed, std::ios::floatfield);
+                        os << d.count();
+                        os.flags(flgs);
+                        if (tz == timezone::local)
+                        {
+                            _CharT sub_pattern[] = {' ', '%', 'z'};
+                            pb = sub_pattern;
+                            pe = pb + + sizeof(sub_pattern) / sizeof(_CharT);
+                            failed = tpf.put(os, os, os.fill(), &tm, pb, pe).failed();
+                        }
+                        else
+                        {
+                            _CharT sub_pattern[] = {' ', '+', '0', '0', '0', '0', 0};
+                            os << sub_pattern;
+                        }
+                    }
+                }
+                else
+                    failed = tpf.put(os, os, os.fill(), &tm, pb, pe).failed();
+            }
+        }
+        catch (...)
+        {
+            failed = true;
+        }
+        if (failed)
+            os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+    }
+    return os;
+}
+namespace detail {
+template <class _CharT, class _InputIterator>
+minutes
+extract_z(_InputIterator& b, _InputIterator e,
+    std::ios_base::iostate& err, const std::ctype<_CharT>& ct)
+{
+    int min = 0;
+    if (b != e)
+    {
+        char cn = ct.narrow(*b, 0);
+        if (cn != '+' && cn != '-')
+        {
+            err |= std::ios_base::failbit;
+            return minutes(0);
+        }
+        int sn = cn == '-' ? -1 : 1;
+        int hr = 0;
+        for (int i = 0; i < 2; ++i)
+        {
+            if (++b == e)
+            {
+                err |= std::ios_base::eofbit | std::ios_base::failbit;
+                return minutes(0);
+            }
+            cn = ct.narrow(*b, 0);
+            if (!('0' <= cn && cn <= '9'))
+            {
+                err |= std::ios_base::failbit;
+                return minutes(0);
+            }
+            hr = hr * 10 + cn - '0';
+        }
+        for (int i = 0; i < 2; ++i)
+        {
+            if (++b == e)
+            {
+                err |= std::ios_base::eofbit | std::ios_base::failbit;
+                return minutes(0);
+            }
+            cn = ct.narrow(*b, 0);
+            if (!('0' <= cn && cn <= '9'))
+            {
+                err |= std::ios_base::failbit;
+                return minutes(0);
+            }
+            min = min * 10 + cn - '0';
+        }
+        if (++b == e)
+            err |= std::ios_base::eofbit;
+        min += hr * 60;
+        min *= sn;
+    }
+    else
+        err |= std::ios_base::eofbit | std::ios_base::failbit;
+    return minutes(min);
+}
+}
+
+template <class _CharT, class _Traits, class _Duration>
+std::basic_istream<_CharT, _Traits>&
+operator>>(std::basic_istream<_CharT, _Traits>& is,
+           time_point<system_clock, _Duration>& tp)
+{
+    typename std::basic_istream<_CharT,_Traits>::sentry ok(is);
+    if (ok)
+    {
+      std::ios_base::iostate err = std::ios_base::goodbit;
+        try
+        {
+            const _CharT* pb = 0;//nullptr;
+            const _CharT* pe = pb;
+            typedef time_punct<_CharT> F;
+            std::locale loc = is.getloc();
+            timezone::type tz = timezone::utc;
+            if (std::has_facet<F>(loc))
+            {
+                const F& f = std::use_facet<F>(loc);
+                pb = f.fmt().data();
+                pe = pb + f.fmt().size();
+                tz = f.timezone::type();
+            }
+            const std::time_get<_CharT>& tg = std::use_facet<std::time_get<_CharT> >(loc);
+            const std::ctype<_CharT>& ct = std::use_facet<std::ctype<_CharT> >(loc);
+            tm tm = {0};
+            typedef std::istreambuf_iterator<_CharT, _Traits> _I;
+            if (pb == pe)
+            {
+                _CharT pattern[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd',
+                                    ' ', '%', 'H', ':', '%', 'M', ':'};
+                pb = pattern;
+                pe = pb + sizeof(pattern) / sizeof(_CharT);
+                tg.get(is, 0, is, err, &tm, pb, pe);
+                if (err & std::ios_base::failbit)
+                    goto exit;
+                double sec;
+                _CharT c = _CharT();
+                is >> sec;
+                if (is.fail())
+                {
+                    err |= std::ios_base::failbit;
+                    goto exit;
+                }
+                _I i(is);
+                _I eof;
+                c = *i;
+                if (++i == eof || c != ' ')
+                {
+                    err |= std::ios_base::failbit;
+                    goto exit;
+                }
+                minutes min = detail::extract_z(i, eof, err, ct);
+                if (err & std::ios_base::failbit)
+                    goto exit;
+                time_t t;
+                t = timegm(&tm);
+                tp = system_clock::from_time_t(t) - min
+                                 + round<microseconds>(duration<double>(sec));
+            }
+            else
+            {
+                const _CharT z[2] = {'%', 'z'};
+                const _CharT* fz = std::search(pb, pe, z, z+2);
+                tg.get(is, 0, is, err, &tm, pb, fz);
+                minutes min(0);
+                if (fz != pe)
+                {
+                    if (err != std::ios_base::goodbit)
+                    {
+                        err |= std::ios_base::failbit;
+                        goto exit;
+                    }
+                    _I i(is);
+                    _I eof;
+                    min = extract_z(i, eof, err, ct);
+                    if (err & std::ios_base::failbit)
+                        goto exit;
+                    if (fz+2 != pe)
+                    {
+                        if (err != std::ios_base::goodbit)
+                        {
+                            err |= std::ios_base::failbit;
+                            goto exit;
+                        }
+                        tg.get(is, 0, is, err, &tm, fz+2, pe);
+                        if (err & std::ios_base::failbit)
+                            goto exit;
+                    }
+                }
+                tm.tm_isdst = -1;
+                time_t t;
+                if (tz == timezone::utc || fz != pe)
+                    t = timegm(&tm);
+                else
+                    t = mktime(&tm);
+                tp = system_clock::from_time_t(t) - min;
+            }
+        }
+        catch (...)
+        {
+            err |= std::ios_base::badbit | std::ios_base::failbit;
+        }
+    exit:
+        is.setstate(err);
+    }
+    return is;
+}
+#endif
 }  // chrono
 
 }
+#include <boost/chrono/duration_style.hpp>
 
 #endif  // BOOST_CHRONO_CHRONO_IO_HPP

Modified: trunk/boost/chrono/config.hpp
==============================================================================
--- trunk/boost/chrono/config.hpp	(original)
+++ trunk/boost/chrono/config.hpp	2011-09-16 12:55:09 EDT (Fri, 16 Sep 2011)
@@ -93,6 +93,12 @@
 #define BOOST_CHRONO_CONST_REF
 #endif
 
+#if defined(BOOST_NO_NOEXCEPT)
+#define BOOST_CHRONO_NOEXCEPT
+#else
+#define BOOST_CHRONO_NOEXCEPT noexcept
+#endif
+
 #define BOOST_CHRONO_STATIC_CONSTEXPR  static BOOST_CHRONO_CONSTEXPR_OR_CONST
 
 

Added: trunk/boost/chrono/duration_style.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/duration_style.hpp	2011-09-16 12:55:09 EDT (Fri, 16 Sep 2011)
@@ -0,0 +1,160 @@
+//  boost/chrono/duration_style.hpp  ------------------------------------------------------------//
+//  Copyright 2011 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+//  See http://www.boost.org/libs/chrono/stopwatches for documentation.
+
+#ifndef BOOST_CHRONO_DURATION_STYLE_HPP
+#define BOOST_CHRONO_DURATION_STYLE_HPP
+
+#include <boost/chrono/chrono_io.hpp>
+#include <boost/chrono/config.hpp>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * Scoped enumeration emulation stating whether the duration I/O style is long or short.
+     * prefix_text means duration::rep with whatever stream/locale settings are set for it followed by a long name representing the unit
+     * symbol means duration::rep with whatever stream/locale settings are set for it followed by a SI unit abbreviation
+     */
+    struct duration_style
+    {
+      enum type {
+        prefix_text, symbol
+      };
+    };
+
+
+    /**
+     * duration parameterized manipulator.
+     */
+    class duration_fmt
+    {
+      duration_style::type style_;
+    public:
+
+      /**
+       * explicit manipulator constructor from a @c duration_style
+       */
+      explicit duration_fmt(duration_style::type style) BOOST_CHRONO_NOEXCEPT
+      : style_(style)
+      {}
+
+#ifndef BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+      /**
+       * explicit conversion to the @c duration_style scoped enum.
+       */
+      explicit
+      operator duration_style::type() const BOOST_CHRONO_NOEXCEPT
+      { return style_;}
+#endif
+
+      /**
+       * gets the @c duration_style scoped enum.
+       */
+      duration_style::type get_duration_style() const BOOST_CHRONO_NOEXCEPT
+      { return style_;}
+    };
+
+    /**
+     * Change the duration_punc facet associated to the output stream depending on the duration_format style parameter.
+     */
+    template<class charT, class traits>
+    std::basic_ostream<charT, traits>&
+    operator <<(std::basic_ostream<charT, traits>& os, duration_fmt d)
+    {
+      if (d.get_duration_style() == duration_style::symbol)
+        os << duration_short;
+      else if (d.get_duration_style() == duration_style::prefix_text)
+        os << duration_long;
+      return os;
+    }
+
+    /**
+     * Change the duration_punc facet associated to the input stream depending on the duration_format style parameter.
+     */
+    template<class charT, class traits>
+    std::basic_istream<charT, traits>&
+    operator >>(std::basic_istream<charT, traits>& is, duration_fmt d)
+    {
+      if (d.get_duration_style() == duration_style::symbol)
+        is >> duration_short;
+      else if (d.get_duration_style() == duration_style::prefix_text)
+        is >> duration_long;
+      return is;
+    }
+
+    /**
+     * duration_style i/o saver.
+     *
+     * See Boost.IO i/o state savers for a motivating compression.
+     */
+    template<typename CharT = char, typename Traits = std::char_traits<CharT> >
+    struct duration_style_io_saver
+    {
+
+      //! the type of the state to restore
+      typedef std::basic_ios<CharT, Traits> state_type;
+      //! the type of aspect to save
+      typedef duration_style::type aspect_type;
+
+      /**
+       * Explicit construction from an i/o stream.
+       *
+       * Store a reference to the i/o stream and the value of the associated @c duration_style.
+       */
+      explicit duration_style_io_saver(state_type &s) :
+        s_save_(s)
+      {
+        typedef duration_punct<CharT> Facet;
+        std::locale loc = s_save_.getloc();
+        if (!std::has_facet<Facet>(loc))
+          s_save_.imbue(std::locale(loc, new Facet()));
+
+        const Facet& f = std::use_facet<Facet>(loc);
+        if (f.is_long_name())
+          a_save_ = duration_style::prefix_text;
+        else
+          a_save_ = duration_style::symbol;
+      }
+
+      /**
+       * Construction from an i/o stream and a @c duration_style to restore.
+       *
+       * Stores a reference to the i/o stream and the value @c duration_style to restore given as parameter.
+       */
+      duration_style_io_saver(state_type &s, aspect_type new_value) :
+        s_save_(s), a_save_(new_value)
+      {
+      }
+
+      /**
+       * Destructor.
+       *
+       * Restores the i/o stream with the duration_style to be restored.
+       */
+      ~duration_style_io_saver()
+      {
+        this->restore();
+      }
+
+      /**
+       * Restores the i/o stream with the duration_style to be restored.
+       */
+      void restore()
+      {
+        s_save_ << duration_fmt(a_save_);
+      }
+    private:
+      state_type& s_save_;
+      aspect_type a_save_;
+    };
+
+  } // namespace chrono
+} // namespace boost
+
+
+#endif

Modified: trunk/boost/chrono/floor.hpp
==============================================================================
--- trunk/boost/chrono/floor.hpp	(original)
+++ trunk/boost/chrono/floor.hpp	2011-09-16 12:55:09 EDT (Fri, 16 Sep 2011)
@@ -19,7 +19,7 @@
   {
 
     /**
-     * round down
+     * rounds down
      */
     template <class To, class Rep, class Period>
     To floor(const duration<Rep, Period>& d)

Modified: trunk/boost/chrono/round.hpp
==============================================================================
--- trunk/boost/chrono/round.hpp	(original)
+++ trunk/boost/chrono/round.hpp	2011-09-16 12:55:09 EDT (Fri, 16 Sep 2011)
@@ -20,7 +20,7 @@
   {
 
     /**
-     * round to nearest, to even on tie
+     * rounds to nearest, to even on tie
      */
     template <class To, class Rep, class Period>
     To round(const duration<Rep, Period>& d)

Added: trunk/boost/chrono/stopwatches/simple_stopwatch.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/stopwatches/simple_stopwatch.hpp	2011-09-16 12:55:09 EDT (Fri, 16 Sep 2011)
@@ -0,0 +1,75 @@
+//  boost/chrono/stopwatches/simple_stopwatch.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/libs/chrono/stopwatches for documentation.
+
+#ifndef BOOST_CHRONO_STOPWATCHES_SIMPLE_STOPWATCH__HPP
+#define BOOST_CHRONO_STOPWATCHES_SIMPLE_STOPWATCH__HPP
+
+#include <utility>
+
+#include <boost/chrono/chrono.hpp>
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * This class provides the simpler stopwath which is just able to give the elapsed time since its creation.
+     */
+    template<typename Clock=high_resolution_clock>
+    class simple_stopwatch
+    {
+    public:
+      typedef Clock clock;
+      typedef typename Clock::duration duration;
+      typedef typename Clock::time_point time_point;
+      typedef typename Clock::rep rep;
+      typedef typename Clock::period period;
+      BOOST_CHRONO_STATIC_CONSTEXPR bool is_steady =             Clock::is_steady;
+
+
+      simple_stopwatch() :
+        start_(clock::now())
+      {
+      }
+      explicit simple_stopwatch(system::error_code & ec) :
+        start_(duration::zero())
+      {
+        time_point tmp = clock::now(ec);
+        if (!BOOST_CHRONO_IS_THROWS(ec))
+        {
+          if (ec)
+          {
+            return;
+          }
+        }
+        start_ = tmp;
+      }
+
+      duration elapsed()
+      {
+        return clock::now() - start_;
+      }
+      duration elapsed(system::error_code & ec)
+      {
+        time_point tmp = clock::now(ec);
+        if (!BOOST_CHRONO_IS_THROWS(ec))
+        {
+          if (ec)
+            return duration::zero();
+        }
+        return tmp - start_;
+      }
+
+    private:
+      time_point start_;
+    };
+
+  } // namespace chrono
+} // namespace boost
+
+#endif