[Boost-commit] svn:boost r75334 - in trunk: boost/chrono boost/chrono/io boost/chrono/io_v1 libs/chrono/test/io

Subject: [Boost-commit] svn:boost r75334 - in trunk: boost/chrono boost/chrono/io boost/chrono/io_v1 libs/chrono/test/io
From: vicente.botet_at_[hidden]
Date: 2011-11-05 23:07:45

Author: viboes
Date: 2011-11-05 23:07:43 EDT (Sat, 05 Nov 2011)
New Revision: 75334
URL: http://svn.boost.org/trac/boost/changeset/75334

Log:
Chrono: Added time_point units, get and put facets and adapt time_point I/O
Added:
   trunk/boost/chrono/io/time_point_get.hpp   (contents, props changed)
   trunk/boost/chrono/io/time_point_put.hpp   (contents, props changed)
   trunk/boost/chrono/io/time_point_units.hpp   (contents, props changed)
Text files modified: 
   trunk/boost/chrono/config.hpp                   |     5 -                                       
   trunk/boost/chrono/io/time_point_io.hpp         |    96 ++++++++++++++++++++++++++++--          
   trunk/boost/chrono/io_v1/chrono_io.hpp          |     3                                         
   trunk/libs/chrono/test/io/time_point_input.cpp  |   123 ++++++++++++++++++++------------------- 
   trunk/libs/chrono/test/io/time_point_output.cpp |    74 ++++++++++++------------                
   5 files changed, 190 insertions(+), 111 deletions(-)

Modified: trunk/boost/chrono/config.hpp
==============================================================================
--- trunk/boost/chrono/config.hpp	(original)
+++ trunk/boost/chrono/config.hpp	2011-11-05 23:07:43 EDT (Sat, 05 Nov 2011)
@@ -91,10 +91,7 @@
 // deprecated i/o
 //#define BOOST_CHRONO_DONT_PROVIDE_DEPRECATED_IO_V1
 
-#define BOOST_CHRONO_IO_V1_DONT_PROVIDE_DEPRECATED
-#define BOOST_CHRONO_IO_USE_XALLOC
-#define BOOST_CHRONO_USES_DURATION_PUT
-#define BOOST_CHRONO_USES_DURATION_GET
+// this doesn't works yet in compilers other than clang-3.0
 //#define BOOST_CHRONO_USES_DURATION_UNITS_GLOBAL
 
 // unicode support  ------------------------------//

Added: trunk/boost/chrono/io/time_point_get.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/io/time_point_get.hpp	2011-11-05 23:07:43 EDT (Sat, 05 Nov 2011)
@@ -0,0 +1,310 @@
+//
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to 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).
+//
+
+#ifndef BOOST_CHRONO_IO_TIME_POINT_GET_HPP
+#define BOOST_CHRONO_IO_TIME_POINT_GET_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/detail/scan_keyword.hpp>
+#include <boost/chrono/io/time_point_units.hpp>
+#include <boost/chrono/io/duration_get.hpp>
+#include <boost/assert.hpp>
+#include <locale>
+#include <string>
+
+/**
+ * Duration formatting facet for input.
+ */
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * @c time_point_get is used to parse a character sequence, extracting
+     * components of a duration into a class duration.
+     * Each get member parses a format as produced by a corresponding format specifier to time_put<>::put.
+     * If the sequence being parsed matches the correct format, the
+     * corresponding member of the class duration argument are set to the
+     * value used to produce the sequence;
+     * otherwise either an error is reported or unspecified values are assigned.
+     * In other words, user confirmation is required for reliable parsing of
+     * user-entered durations, but machine-generated formats can be parsed
+     * reliably. This allows parsers to be aggressive about interpreting user
+     * variations on standard formats.
+     *
+     * If the end iterator is reached during parsing of the get() member
+     * function, the member sets std::ios_base::eofbit in err.
+     */
+    template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
+    class time_point_get: public std::locale::facet
+    {
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of iterator used to scan the character buffer.
+       */
+      typedef InputIterator iter_type;
+
+      /**
+       * Construct a @c time_point_get facet.
+       * @param refs
+       * @Effects Construct a @c time_point_get facet.
+       * If the @c refs argument is @c 0 then destruction of the object is
+       * delegated to the @c locale, or locales, containing it. This allows
+       * the user to ignore lifetime management issues. On the other had,
+       * if @c refs is @c 1 then the object must be explicitly deleted;
+       * the @c locale will not do so. In this case, the object can be
+       * maintained across the lifetime of multiple locales.
+       */
+
+      explicit time_point_get(size_t refs = 0) :
+        std::locale::facet(refs)
+      {
+      }
+
+      /**
+       * @param s start input stream iterator
+       * @param end end input stream iterator
+       * @param ios a reference to a ios_base
+       * @param err the ios_base state
+       * @param d the duration
+       * @param pattern begin of the formatting pattern
+       * @param pat_end end of the formatting pattern
+       *
+       * Requires: [pattern,pat_end) shall be a valid range.
+       *
+       * Effects: The function starts by evaluating err = std::ios_base::goodbit.
+       * It then enters a loop, reading zero or more characters from s at
+       * each iteration. Unless otherwise specified below, the loop
+       * terminates when the first of the following conditions holds:
+       * - The expression pattern == pat_end evaluates to true.
+       * - The expression err == std::ios_base::goodbit evaluates to false.
+       * - The expression s == end evaluates to true, in which case the
+       * function evaluates err = std::ios_base::eofbit | std::ios_base::failbit.
+       * - The next element of pattern is equal to Õ%Õ, followed by a conversion
+       * specifier character, format.
+       * If the number of elements in the range [pattern,pat_end) is not
+       * sufficient to unambiguously determine whether the conversion
+       * specification is complete and valid, the function evaluates
+       * err = std::ios_base::failbit. Otherwise, the function evaluates
+       * s = do_get(s, end, ios, err, d). If err == std::ios_base::goodbit holds after
+       * the evaluation of the expression, the function increments pattern to
+       * point just past the end of the conversion specification and continues
+       * looping.
+       * - The expression isspace(*pattern, ios.getloc()) evaluates to true, in
+       * which case the function first increments pattern until
+       * pattern == pat_end || !isspace(*pattern, ios.getloc()) evaluates to true,
+       * then advances s until s == end || !isspace(*s, ios.getloc()) is true,
+       * and finally resumes looping.
+       * - The next character read from s matches the element pointed to by
+       * pattern in a case-insensitive comparison, in which case the function
+       * evaluates ++pattern, ++s and continues looping. Otherwise, the function
+       * evaluates err = std::ios_base::failbit.
+       *
+       * Returns: s
+       */
+      template <class Clock, class Duration>
+      iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
+          time_point<Clock, Duration> &tp, const char_type *pattern, const char_type *pat_end) const
+      {
+        std::cerr << __FILE__ <<":"<< __LINE__ <<  " err "<< err << std::endl;
+
+        Duration d;
+        bool duration_found=false, epoch_found=false, loc_found=false;
+
+        const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
+        err = std::ios_base::goodbit;
+        while (pattern != pat_end && err == std::ios_base::goodbit)
+        {
+          std::cerr << __FILE__ <<":"<< __LINE__ <<  " err "<< err << std::endl;
+            if (s == end)
+            {
+                err |= std::ios_base::eofbit;
+                break;
+            }
+            if (ct.narrow(*pattern, 0) == '%')
+            {
+                if (++pattern == pat_end)
+                {
+                    err |= std::ios_base::failbit;
+                    return s;
+                }
+                char cmd = ct.narrow(*pattern, 0);
+                switch (cmd)
+                {
+                case 'd':
+                {
+                  if (duration_found || loc_found) {
+                    err |= std::ios_base::failbit;
+                    return s;
+                  }
+                  duration_found=true;
+                  s = get_duration(s, end, ios, err,  d);
+                  std::cerr << __FILE__ <<":"<< __LINE__ <<  " err "<< err << std::endl;
+                  if ( err & (std::ios_base::badbit |std::ios_base::failbit) )
+                  {
+                    return s;
+                  }
+                  break;
+                }
+                case 'e':
+                {
+                  if (epoch_found || loc_found) {
+                    err |= std::ios_base::failbit;
+                    return s;
+                  }
+                  epoch_found=true;
+                  s = get_epoch<Clock>(s, end, ios, err);
+                  std::cerr << __FILE__ <<":"<< __LINE__ <<  " err "<< err << std::endl;
+                  if ( err & (std::ios_base::badbit |std::ios_base::failbit) )
+                  {
+                    return s;
+                  }
+                  break;
+                }
+                case 'x':
+                {
+                  if (duration_found || epoch_found || loc_found) {
+                    err |= std::ios_base::failbit;
+                    return s;
+                  }
+                  loc_found=true;
+                  std::basic_string<CharT> pat = time_point_units<CharT>::imbue_if_has_not(ios).get_pattern();
+                  if (pattern+1 != pat_end)
+                  pat.append(pattern+1, pat_end);
+                  pattern = pat.data();
+                  pat_end = pattern + pat.size();
+                  break;
+                }
+                default:
+                  BOOST_ASSERT(false && "Boost::Chrono internal error.");
+                  break;
+                }
+
+                ++pattern;
+            }
+            else if (ct.is(std::ctype_base::space, *pattern))
+            {
+                for (++pattern; pattern != pat_end && ct.is(std::ctype_base::space, *pattern); ++pattern)
+                    ;
+                for (        ;    s != end    && ct.is(std::ctype_base::space, *s);    ++s)
+                    ;
+            }
+            else if (ct.toupper(*s) == ct.toupper(*pattern))
+            {
+                ++s;
+                ++pattern;
+            }
+            else {
+                err |= std::ios_base::failbit;
+            }
+        }
+
+        // Success!  Store it.
+        tp = time_point<Clock, Duration>(d);
+        std::cerr << __FILE__ <<":"<< __LINE__ <<  " err "<< err << std::endl;
+
+        return s;
+      }
+
+      /**
+       *
+       * @param s an input stream iterator
+       * @param ios a reference to a ios_base
+       * @param d the duration
+       * @Effects imbue in @c ios the @c time_point_units_default facet if not already present.
+       * Retrieves Stores the duration pattern from the @c duration_unit facet in let say @c str. Last as if
+       * @code
+       *   return get(s, end, ios, err, ios, d, str.data(), str.data() + str.size());
+       * @codeend
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid name
+       */
+      template <class Clock, class Duration>
+      iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
+          time_point<Clock, Duration> &tp) const
+      {
+        std::basic_string < CharT > str = time_point_units<CharT>::imbue_if_has_not(ios).get_pattern();
+        return get(s, end, ios, err, tp, str.data(), str.data() + str.size());
+      }
+
+      /**
+       *
+       * @param s an input stream iterator
+       * @param ios a reference to a ios_base
+       * @param d the duration
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid name
+       */
+      template <typename Rep, typename Period>
+      iter_type get_duration(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err, duration<Rep, Period>& d) const
+      {
+        if (!std::has_facet<duration_get<CharT> >(ios.getloc()))
+        {
+          ios.imbue(std::locale(ios.getloc(), new duration_get<CharT>()));
+        }
+        return std::use_facet<duration_get<CharT> >(ios.getloc())
+        .get(s, end, ios, err, d);
+      }
+
+      /**
+       *
+       * @param s an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param d the duration
+       * @param pattern
+       * @Effects Calls do_put_unit(s, ios, d).
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid name
+       */
+      template <class Clock>
+      iter_type get_epoch(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err) const
+      {
+        time_point_units<CharT> const &facet = time_point_units<CharT>::imbue_if_has_not(is);
+
+        const std::basic_string<CharT> units = facet.get_epoch<Clock>();
+        err = std::ios_base::goodbit;
+        std::ptrdiff_t k =
+            chrono_detail::scan_keyword(i, e, &units, &units + 1,
+            //~ std::use_facet<std::ctype<CharT> >(ios.getloc()),
+            err) - &units;
+        std::cerr << __FILE__ <<":"<< __LINE__ <<  " err "<< err << std::endl;
+        if (k == 1)
+        {
+          err |= std::ios_base::failbit;
+          return i;
+        }
+        std::cerr << __FILE__ <<":"<< __LINE__ <<  " err "<< err << std::endl;
+        return i;
+      }
+
+      /**
+       * Unique identifier for this type of facet.
+       */
+      static std::locale::id id;
+
+      /**
+       * @Effects Destroy the facet
+       */
+      ~time_point_get()
+      {
+      }
+    };
+
+    /**
+     * Unique identifier for this type of facet.
+     */
+    template <class CharT, class InputIterator>
+    std::locale::id time_point_get<CharT, InputIterator>::id;
+
+  } // chrono
+}
+// boost
+
+#endif  // BOOST_CHRONO_CHRONO_IO_HPP

Modified: trunk/boost/chrono/io/time_point_io.hpp
==============================================================================
--- trunk/boost/chrono/io/time_point_io.hpp	(original)
+++ trunk/boost/chrono/io/time_point_io.hpp	2011-11-05 23:07:43 EDT (Sat, 05 Nov 2011)
@@ -1,4 +1,4 @@
-//  chrono_io
+//  boost/chrono/io/time_point_io.hpp
 //
 //  (C) Copyright Howard Hinnant
 //  (C) Copyright 2010-2011 Vicente J. Botet Escriba
@@ -12,7 +12,8 @@
 #ifndef BOOST_CHRONO_IO_TIME_POINT_IO_HPP
 #define BOOST_CHRONO_IO_TIME_POINT_IO_HPP
 
-#include <boost/chrono/io/translate.hpp>
+#include <boost/chrono/io/time_point_put.hpp>
+#include <boost/chrono/io/time_point_get.hpp>
 #include <boost/chrono/io/duration_io.hpp>
 #include <boost/chrono/io/ios_base_state.hpp>
 #include <boost/chrono/io/utility/manip_base.hpp>
@@ -48,8 +49,7 @@
          * Change the timezone_type and time format ios state;
          */
         template <typename out_stream>
-        void operator()(out_stream &ios) const
-        //void operator()(std::ios_base &ios) const
+        void operator()(std::ios_base &ios) const
         {
           set_time_fmt<CharT>(ios, fmt_);
           set_timezone(ios, tz_);
@@ -217,8 +217,55 @@
     operator<<(std::basic_ostream<CharT, Traits>& os, const time_point<Clock,
         Duration>& tp)
     {
-      return os << tp.time_since_epoch() << epoch_translate(clock_string<Clock,
-          CharT>::since());
+
+#if 0
+      return os << tp.time_since_epoch() << clock_string<Clock,
+          CharT>::since();
+#else
+        typedef std::basic_string<CharT, Traits> string_type;
+        bool failed = false;
+        try
+        {
+          std::ios_base::iostate err = std::ios_base::goodbit;
+          try
+          {
+            typename std::basic_ostream<CharT, Traits>::sentry opfx(os);
+            if (opfx)
+            {
+              if (!std::has_facet<time_point_put<CharT> >(os.getloc()))
+              {
+                os.imbue(std::locale(os.getloc(), new time_point_put<CharT> ()));
+              }
+              if (std::use_facet<time_point_put<CharT> >(os.getloc()) .put(os, os, tp) .failed())
+              {
+                err = std::ios_base::badbit;
+              }
+              os.width(0);
+            }
+          }
+          catch (...)
+          {
+            bool flag = false;
+            try
+            {
+              os.setstate(std::ios_base::failbit);
+            }
+            catch (std::ios_base::failure )
+            {
+              flag = true;
+            }
+            if (flag) throw;
+          }
+          if (err) os.setstate(err);
+          return os;
+        }
+        catch (...)
+        {
+          failed = true;
+        }
+        if (failed) os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+        return os;
+#endif
     }
 
     template<class CharT, class Traits, class Clock, class Duration>
@@ -226,12 +273,13 @@
     operator>>(std::basic_istream<CharT, Traits>& is, time_point<Clock,
         Duration>& tp)
     {
+#if 0
       Duration d;
       is >> d;
       if (is.good())
       {
-        const std::basic_string<CharT> units = epoch_translate(clock_string<
-            Clock, CharT>::since());
+        const std::basic_string<CharT> units = clock_string<
+            Clock, CharT>::since();
         std::ios_base::iostate err = std::ios_base::goodbit;
         typedef std::istreambuf_iterator<CharT, Traits> in_iterator;
         in_iterator i(is);
@@ -251,6 +299,38 @@
       else
         is.setstate(is.failbit);
       return is;
+#else
+      std::ios_base::iostate err = std::ios_base::goodbit;
+
+      try
+      {
+        typename std::basic_istream<CharT, Traits>::sentry ipfx(is);
+        if(ipfx)
+        {
+          if (!std::has_facet<time_point_get<CharT> >(is.getloc()))
+          {
+            is.imbue(std::locale(is.getloc(), new time_point_get<CharT>()));
+          }
+          std::use_facet<time_point_get<CharT> >(is.getloc())
+          .get(is, std::istreambuf_iterator<CharT,Traits>() ,is, err, tp);
+        }
+      }
+      catch(...)
+      {
+        bool flag = false;
+        try
+        {
+          is.setstate(std::ios_base::failbit);
+        }
+        catch( std::ios_base::failure )
+        {
+          flag= true;
+        }
+        if ( flag ) throw;
+      }
+      if ( err ) is.setstate(err);
+      return is;
+#endif
     }
 
 #ifndef BOOST_CHRONO_NO_UTC_TIMEPOINT

Added: trunk/boost/chrono/io/time_point_put.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/io/time_point_put.hpp	2011-11-05 23:07:43 EDT (Sat, 05 Nov 2011)
@@ -0,0 +1,212 @@
+//
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to 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).
+//
+
+/**
+ * Duration formatting facet for output.
+ */
+#ifndef BOOST_CHRONO_IO_TIME_POINT_PUT_HPP
+#define BOOST_CHRONO_IO_TIME_POINT_PUT_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/io/time_point_units.hpp>
+#include <boost/chrono/io/duration_put.hpp>
+#include <boost/assert.hpp>
+#include <locale>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * @tparam ChatT a character type
+     * @tparam OutputIterator a model of @c OutputIterator
+     *
+     * The @c time_point_put facet provides facilities for formatted output of duration values.
+     * The member function of @c time_point_put take a duration and translate this into character string representation.
+     *
+     * FIXME As the facet doesn't have any data, I'm wondering if this should functions
+     * shouldn't be at the namespace level or static member functions.
+     * This will leverage the user to need to ensure that the facet is imbued on the ios_base.
+     */
+    template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
+    class time_point_put: public std::locale::facet
+    {
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of iterator used to write in the character buffer.
+       */
+      typedef OutputIterator iter_type;
+
+      /**
+       * Construct a time_point_put facet.
+       * @param refs
+       * @Effects Construct a time_point_put facet.
+       * If the @c refs argument is @c 0 then destruction of the object is
+       * delegated to the @c locale, or locales, containing it. This allows
+       * the user to ignore lifetime management issues. On the other had,
+       * if @c refs is @c 1 then the object must be explicitly deleted;
+       * the @c locale will not do so. In this case, the object can be
+       * maintained across the lifetime of multiple locales.
+       */
+      explicit time_point_put(size_t refs = 0) :
+        std::locale::facet(refs)
+      {
+      }
+
+      /**
+       *
+       * @param s an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param d the duration
+       * @param pattern begin of the formatting pattern
+       * @param pat_end end of the formatting pattern
+       *
+       * @Effects Steps through the sequence from @c pattern to @c pat_end,
+       * identifying characters that are part of a pattern sequence. Each character
+       * that is not part of a pattern sequence is written to @c s immediately, and
+       * each pattern sequence, as it is identified, results in a call to
+       * @c put_value or @c put_unit;
+       * thus, pattern elements and other characters are interleaved in the output
+       * in the order in which they appear in the pattern. Pattern sequences are
+       * identified by converting each character @c c to a @c char value as if by
+       * @c ct.narrow(c,0), where @c ct is a reference to @c ctype<charT> obtained from
+       * @c ios.getloc(). The first character of each sequence is equal to @c Õ%Õ,
+       * followed by a pattern specifier character @c spec, which can be @c 'v' for
+       * the duration value or @c 'u' for the duration unit. .
+       * For each valid pattern sequence identified, calls
+       * <c>put_value(s, ios, d)</c> or <c>put_unit(s, ios, d)</c>.
+       *
+       * @Returns An iterator pointing immediately after the last character produced.
+       */
+      template <class Clock, class Duration>
+      iter_type put(iter_type s, std::ios_base& ios, time_point<Clock, Duration> const& tp, const CharT* pattern,
+          const CharT* pat_end) const
+      {
+        time_point_units<CharT,OutputIterator> const& units_facet = time_point_units<CharT,OutputIterator>::imbue_if_has_not(ios);
+
+        const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
+        for (; pattern != pat_end; ++pattern)
+        {
+            if (ct.narrow(*pattern, 0) == '%')
+            {
+                if (++pattern == pat_end)
+                {
+                    *s++ = pattern[-1];
+                    break;
+                }
+                char fmt = ct.narrow(*pattern, 0);
+                switch (fmt)
+                {
+                case 'd':
+                {
+                  s = put_duration(s, ios, tp.time_since_epoch());
+                  break;
+                }
+                case 'e':
+                {
+                  s = put_epoch<Clock>(s, ios);
+                  break;
+                }
+                case 'x':
+                {
+                  std::basic_string<CharT> pat = units_facet.get_pattern();
+                  pattern = pat.data();
+                  pat_end = pattern + pat.size();
+                  break;
+                }
+                default:
+                  BOOST_ASSERT(false && "Boost::Chrono internal error.");
+                  break;
+                }
+            }
+            else
+                *s++ = *pattern;
+        }
+        return s;
+      }
+
+      /**
+       *
+       * @param s an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param d the duration
+       * @Effects imbue in @c ios the @c time_point_units_default facet if not already present.
+       * Retrieves Stores the duration pattern from the @c duration_unit facet in let say @c str. Last as if
+       * @code
+       *   return put(s, ios, d, str.data(), str.data() + str.size());
+       * @codeend
+       * @Returns An iterator pointing immediately after the last character produced.
+       */
+      template <class Clock, class Duration>
+      iter_type put(iter_type s, std::ios_base& ios, time_point<Clock, Duration> const& tp) const
+      {
+        std::basic_string<CharT> str = time_point_units<CharT,OutputIterator>::imbue_if_has_not(ios).get_pattern();
+        return put(s, ios, tp, str.data(), str.data() + str.size());
+      }
+
+      /**
+       *
+       * @param s an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param d the duration
+       * @Effects As if std::use_facet<std::num_put<CharT, iter_type> >(ios.getloc()).put(s, ios, ' ', static_cast<long int> (d.count())).
+       * @Returns An iterator pointing immediately after the last character produced.
+       */
+      template <typename Rep, typename Period>
+      iter_type put_duration(iter_type s, std::ios_base& ios, duration<Rep, Period> const& d) const
+      {
+        if (!std::has_facet<duration_put<CharT> >(ios.getloc()))
+        {
+          ios.imbue(std::locale(ios.getloc(), new duration_put<CharT>()));
+        }
+        return std::use_facet<duration_put<CharT> >(ios.getloc())
+        .put(s, ios, d);
+      }
+
+      /**
+       *
+       * @param s an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param d the duration
+       * @param pattern
+       * @Effects imbue in @c ios the @c time_point_units_default facet if not already present.
+       * @Effects Calls std::use_facet<time_point_units<CharT,OutputIterator> >(ios.getloc()).put(s, ios, d).
+       * @Returns An iterator pointing immediately after the last character produced.
+       */
+      template <typename Clock>
+      iter_type put_epoch(iter_type s, std::ios_base& ios) const
+      {
+        return time_point_units<CharT,OutputIterator>::imbue_if_has_not(ios).template put<Clock>(s, ios);
+      }
+
+      /**
+       * Unique identifier for this type of facet.
+       */
+      static std::locale::id id;
+
+      /**
+       * @Effects Destroy the facet
+       */
+      ~time_point_put()
+      {
+      }
+
+    };
+
+    template <class CharT, class OutputIterator>
+    std::locale::id time_point_put<CharT, OutputIterator>::id;
+
+  } // chrono
+} // boost
+
+#endif  // BOOST_CHRONO_CHRONO_IO_HPP

Added: trunk/boost/chrono/io/time_point_units.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/io/time_point_units.hpp	2011-11-05 23:07:43 EDT (Sat, 05 Nov 2011)
@@ -0,0 +1,275 @@
+//
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to 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).
+//
+
+#ifndef BOOST_CHRONO_IO_TIME_POINT_UNITS_HPP
+#define BOOST_CHRONO_IO_TIME_POINT_UNITS_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/process_cpu_clocks.hpp>
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/thread_clock.hpp>
+#include <boost/chrono/io/ios_base_state.hpp>
+#include <string>
+#include <iostream>
+#include <ios>
+#include <locale>
+#include <algorithm>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * @c time_point_units facet gives useful information about the duration units,
+     * as the number of plural forms, the plural form associated to a duration,
+     * the text associated to a plural form and a duration's period,
+     */
+    template <typename CharT=char, class OutputIterator = std::ostreambuf_iterator<CharT> >
+    class time_point_units: public std::locale::facet
+    {
+      static time_point_units* global_;
+    public:
+      typedef CharT char_type;
+      typedef OutputIterator iter_type;
+
+      static std::locale::id id;
+
+      explicit time_point_units(size_t refs = 0) :
+        std::locale::facet(refs)
+      {
+      }
+
+      /**
+       * @Return Gets the global time_point_units,
+       * used when the stream has no associated time_point_units facet.
+       * @Throws an exception if the global is 0.
+      Ê
+      */
+      static time_point_units* global()
+      {
+        return global_;
+      }
+
+      /**
+      If the facet is not 0, sets the new global time_point_units, after deleting the preceding one. This is used when the stream has no associated time_point_units facet.
+      Otherwise throw an exception.
+      */
+      static void global(time_point_units* ptr)
+      {
+        global_ = ptr;
+      }
+
+      /**
+       * Factory cloning a the global instance.
+       * @return a clone of the global instance.
+       */
+      static time_point_units* make()
+      {
+        return global_->clone();;
+      }
+
+      /**
+       * imbue a clone of this facet in @c ios.
+       * @param ios the ios to imbue.
+       */
+#if defined BOOST_CHRONO_USES_DURATION_UNITS_GLOBAL
+      // FIXME: This cause a linker problem on compilers other than clang-3.0 c++03 or c++0x
+      static time_point_units<CharT,OutputIterator> const& imbue_if_has_not(std::ios_base& ios)
+      {
+        if (!std::has_facet<time_point_units<CharT,OutputIterator> >(ios.getloc()))
+          ios.imbue(std::locale(ios.getloc(), make()));
+        return std::use_facet<time_point_units<CharT,OutputIterator> >(ios.getloc());
+      }
+#else
+      static inline time_point_units<CharT,OutputIterator> const& imbue_if_has_not(std::ios_base& ios);
+#endif
+
+      template <typename Clock>
+      iter_type put(iter_type s, std::ios_base& ios) const
+      {
+        return do_put(s, ios, Clock());
+      }
+
+      /**
+       *
+       * @return the pattern to be used by default.
+       */
+      std::basic_string<CharT> get_pattern() const
+      {
+        return do_get_pattern();
+      }
+
+      /**
+       *
+       * @return the pattern to be used by default.
+       */
+      template <typename Clock>
+      std::basic_string<CharT> get_epoch() const
+      {
+        return do_get_epoch(Clock());
+      }
+
+    protected:
+      virtual ~time_point_units() {};
+      virtual time_point_units<CharT, OutputIterator>* clone() const = 0;
+
+      virtual std::basic_string<CharT> do_get_pattern() const=0;
+
+      virtual iter_type
+      do_put(iter_type s, std::ios_base& ios, system_clock) const = 0;
+      virtual std::basic_string<CharT> do_get_epoch(system_clock) const=0;
+
+      virtual iter_type
+      do_put(iter_type s, std::ios_base& ios, steady_clock) const = 0;
+      virtual std::basic_string<CharT> do_get_epoch(steady_clock) const=0;
+
+//#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
+      virtual iter_type do_put(iter_type s, std::ios_base& ios, process_real_cpu_clock c) const =0;
+      virtual std::basic_string<CharT> do_get_epoch(process_real_cpu_clock) const=0;
+      virtual iter_type do_put(iter_type s, std::ios_base& ios, process_user_cpu_clock c) const =0;
+      virtual std::basic_string<CharT> do_get_epoch(process_user_cpu_clock) const=0;
+      virtual iter_type do_put(iter_type s, std::ios_base& ios, process_system_cpu_clock c) const =0;
+      virtual std::basic_string<CharT> do_get_epoch(process_system_cpu_clock) const=0;
+      virtual iter_type do_put(iter_type s, std::ios_base& ios, process_cpu_clock c) const =0;
+      virtual std::basic_string<CharT> do_get_epoch(process_cpu_clock) const=0;
+//#endif
+#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
+      virtual iter_type do_put(iter_type s, std::ios_base& ios, thread_clock c) const =0;
+      virtual std::basic_string<CharT> do_get_epoch(thread_clock) const=0;
+#endif
+
+    };
+
+    template <typename CharT, class OutputIterator>
+    std::locale::id time_point_units<CharT, OutputIterator>::id;
+
+
+    // This class is used to define the strings for the default English
+    template <typename CharT=char, class OutputIterator = std::ostreambuf_iterator<CharT> >
+    class time_point_units_default: public time_point_units<CharT, OutputIterator>
+    {
+    public:
+      typedef CharT char_type;
+      typedef OutputIterator iter_type;
+
+      explicit time_point_units_default(size_t refs = 0) :
+        time_point_units<CharT, OutputIterator> (refs)
+      {
+      }
+      ~time_point_units_default() {}
+
+
+    protected:
+      time_point_units<CharT, OutputIterator>* clone() const
+      {
+        return new time_point_units_default<CharT, OutputIterator>();
+      }
+
+      std::basic_string<CharT> do_get_pattern() const
+      {
+        static const CharT t[] =
+        { '%', 'd', '%', 'e' };
+        static const std::basic_string<CharT> pattern(t, t + sizeof (t) / sizeof (t[0]));
+
+        return pattern;
+      }
+
+      iter_type do_put(iter_type s, std::ios_base& , system_clock c) const
+      {
+        std::basic_string<CharT> str = do_get_epoch(c);
+        return std::copy(str.begin(), str.end(), s);
+      }
+      std::basic_string<CharT> do_get_epoch(system_clock ) const
+      {
+        return clock_string<system_clock,CharT>::since();
+      }
+      iter_type do_put(iter_type s, std::ios_base& , steady_clock c) const
+      {
+        std::basic_string<CharT> str = do_get_epoch(c);
+        return std::copy(str.begin(), str.end(), s);
+      }
+      std::basic_string<CharT> do_get_epoch(steady_clock ) const
+      {
+        return clock_string<steady_clock,CharT>::since();
+      }
+
+//#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
+      iter_type do_put(iter_type s, std::ios_base& , process_real_cpu_clock c) const
+      {
+        std::basic_string<CharT> str = do_get_epoch(c);
+        return std::copy(str.begin(), str.end(), s);
+      }
+      std::basic_string<CharT> do_get_epoch(process_real_cpu_clock ) const
+      {
+        return clock_string<process_real_cpu_clock,CharT>::since();
+      }
+      iter_type do_put(iter_type s, std::ios_base& , process_user_cpu_clock c) const
+      {
+        std::basic_string<CharT> str = do_get_epoch(c);
+        return std::copy(str.begin(), str.end(), s);
+      }
+      std::basic_string<CharT> do_get_epoch(process_user_cpu_clock ) const
+      {
+        return clock_string<process_user_cpu_clock,CharT>::since();
+      }
+      iter_type do_put(iter_type s, std::ios_base& , process_system_cpu_clock c) const
+      {
+        std::basic_string<CharT> str = do_get_epoch(c);
+        return std::copy(str.begin(), str.end(), s);
+      }
+      std::basic_string<CharT> do_get_epoch(process_system_cpu_clock ) const
+      {
+        return clock_string<process_system_cpu_clock,CharT>::since();
+      }
+      iter_type do_put(iter_type s, std::ios_base& , process_cpu_clock c) const
+      {
+        std::basic_string<CharT> str = do_get_epoch(c);
+        return std::copy(str.begin(), str.end(), s);
+      }
+      std::basic_string<CharT> do_get_epoch(process_cpu_clock ) const
+      {
+        return clock_string<process_cpu_clock,CharT>::since();
+      }
+
+//#endif
+#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
+      iter_type do_put(iter_type s, std::ios_base& , thread_clock c) const
+      {
+        std::basic_string<CharT> str = do_get_epoch(c);
+        return std::copy(str.begin(), str.end(), s);
+      }
+      std::basic_string<CharT> do_get_epoch(thread_clock ) const
+      {
+        return clock_string<thread_clock,CharT>::since();
+      }
+#endif
+
+    };
+
+    template <typename CharT, class OutputIterator>
+    time_point_units<CharT, OutputIterator>* time_point_units<CharT, OutputIterator>::global_=new time_point_units_default<CharT, OutputIterator>();
+
+#if ! defined BOOST_CHRONO_USES_DURATION_UNITS_GLOBAL
+    template <typename CharT, class OutputIterator>
+    time_point_units<CharT,OutputIterator> const&
+    time_point_units<CharT, OutputIterator>::imbue_if_has_not(std::ios_base& ios)
+    {
+        if (!std::has_facet<time_point_units<CharT,OutputIterator> >(ios.getloc())) ios.imbue(
+            std::locale(ios.getloc(), new time_point_units_default<CharT,OutputIterator>()));
+        return std::use_facet<time_point_units<CharT,OutputIterator> >(ios.getloc());
+    }
+
+#endif
+
+
+  } // chrono
+
+} // boost
+
+#endif  // header

Modified: trunk/boost/chrono/io_v1/chrono_io.hpp
==============================================================================
--- trunk/boost/chrono/io_v1/chrono_io.hpp	(original)
+++ trunk/boost/chrono/io_v1/chrono_io.hpp	2011-11-05 23:07:43 EDT (Sat, 05 Nov 2011)
@@ -576,10 +576,11 @@
                       &units, &units + 1,
                       //~ std::use_facet<std::ctype<CharT> >(is.getloc()),
                       err) - &units;
+        is.setstate(err);
         if (k == 1)
         {
+          is.setstate(err | is.failbit);
             // failed to read epoch string
-            is.setstate(err);
             return is;
         }
         tp = time_point<Clock, Duration>(d);

Modified: trunk/libs/chrono/test/io/time_point_input.cpp
==============================================================================
--- trunk/libs/chrono/test/io/time_point_input.cpp	(original)
+++ trunk/libs/chrono/test/io/time_point_input.cpp	2011-11-05 23:07:43 EDT (Sat, 05 Nov 2011)
@@ -9,94 +9,95 @@
 #include <boost/chrono/thread_clock.hpp>
 #include <boost/chrono/process_cpu_clocks.hpp>
 
-template<typename Clock, typename D>
+template <typename Clock, typename D>
 void test_good(std::string str, D res)
 {
-  std::istringstream in(str+boost::chrono::clock_string<Clock,char>::since());
-  boost::chrono::time_point<Clock,D> tp;
+  std::istringstream in(str + boost::chrono::clock_string<Clock, char>::since());
+  boost::chrono::time_point<Clock, D> tp;
   in >> tp;
-  BOOST_TEST(in.good());
-  BOOST_TEST((tp == boost::chrono::time_point<Clock,D>(res)));
+  BOOST_TEST(in.eof());
+  BOOST_TEST(!in.fail());
+  BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>(res)));
 }
 
-template<typename Clock, typename D>
-void test_fail(const char* str, D )
+template <typename Clock, typename D>
+void test_fail(const char* str, D)
 {
-  std::istringstream in(str+boost::chrono::clock_string<Clock,char>::since());
-  boost::chrono::time_point<Clock,D> tp;
-    in >> tp;
-    BOOST_TEST(in.fail());
-    BOOST_TEST((tp == boost::chrono::time_point<Clock,D>()));
+  std::istringstream in(str + boost::chrono::clock_string<Clock, char>::since());
+  boost::chrono::time_point<Clock, D> tp;
+  in >> tp;
+  BOOST_TEST(in.fail());
+  BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>()));
 }
 
-template<typename Clock, typename D>
+template <typename Clock, typename D>
 void test_fail_no_epoch(const char* str, D r)
 {
   std::istringstream in(str);
-  boost::chrono::time_point<Clock,D> tp;
-    in >> tp;
-    BOOST_TEST(in.fail());
-    BOOST_TEST((tp == boost::chrono::time_point<Clock,D>()));
+  boost::chrono::time_point<Clock, D> tp;
+  in >> tp;
+  BOOST_TEST(in.fail());
+  BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>()));
 }
 
-template<typename Clock, typename D>
+template <typename Clock, typename D>
 void test_fail_epoch(const char* str, D)
 {
   std::istringstream in(str);
-  boost::chrono::time_point<Clock,D> tp;
-    in >> tp;
-    BOOST_TEST(in.fail());
-    BOOST_TEST((tp == boost::chrono::time_point<Clock,D>()));
+  boost::chrono::time_point<Clock, D> tp;
+  in >> tp;
+  BOOST_TEST(in.fail());
+  BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>()));
 }
 
-template<typename Clock>
+template <typename Clock>
 void check_all()
 {
   using namespace boost::chrono;
   using namespace boost;
 
-  test_good<Clock>("5000 hours", hours(5000));
-  test_good<Clock>("5000 minutes", minutes(5000));
-  test_good<Clock>("5000 seconds", seconds(5000));
-  test_good<Clock>("1 seconds", seconds(1));
-  test_good<Clock>("1 second", seconds(1));
-  test_good<Clock>("-1 seconds", seconds(-1));
-  test_good<Clock>("0 second", seconds(0));
-  test_good<Clock>("0 seconds", seconds(0));
-  test_good<Clock>("5000 milliseconds", milliseconds(5000));
-  test_good<Clock>("5000 microseconds", microseconds(5000));
-  test_good<Clock>("5000 nanoseconds", nanoseconds(5000));
-  test_good<Clock>("5000 deciseconds", duration<boost::int_least64_t, deci> (5000));
-  test_good<Clock>("5000 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (5000));
+  test_good<Clock> ("5000 hours", hours(5000));
+  test_good<Clock> ("5000 minutes", minutes(5000));
+  test_good<Clock> ("5000 seconds", seconds(5000));
+  test_good<Clock> ("1 seconds", seconds(1));
+  test_good<Clock> ("1 second", seconds(1));
+  test_good<Clock> ("-1 seconds", seconds(-1));
+  test_good<Clock> ("0 second", seconds(0));
+  test_good<Clock> ("0 seconds", seconds(0));
+  test_good<Clock> ("5000 milliseconds", milliseconds(5000));
+  test_good<Clock> ("5000 microseconds", microseconds(5000));
+  test_good<Clock> ("5000 nanoseconds", nanoseconds(5000));
+  test_good<Clock> ("5000 deciseconds", duration<boost::int_least64_t, deci> (5000));
+  test_good<Clock> ("5000 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (5000));
 
-  test_good<Clock>("5000 h", hours(5000));
+  test_good<Clock> ("5000 h", hours(5000));
 #if defined BOOST_CHRONO_DONT_PROVIDE_DEPRECATED_IO_V1
   test_good<Clock>("5000 min", minutes(5000));
 #else
-  test_good<Clock>("5000 m", minutes(5000));
+  test_good<Clock> ("5000 m", minutes(5000));
 #endif
-  test_good<Clock>("5000 s", seconds(5000));
-  test_good<Clock>("5000 ms", milliseconds(5000));
-  test_good<Clock>("5000 ns", nanoseconds(5000));
-  test_good<Clock>("5000 ds", duration<boost::int_least64_t, deci> (5000));
-  test_good<Clock>("5000 [1/30]s", duration<boost::int_least64_t, ratio<1, 30> > (5000));
-
-  test_good<Clock>("5000 milliseconds", seconds(5));
-  test_good<Clock>("5 milliseconds", nanoseconds(5000000));
-  test_good<Clock>("4000 ms", seconds(4));
-  test_fail<Clock>("3001 ms", seconds(3));
-  test_fail_epoch<Clock>("3001 ms", seconds(3));
-  test_fail_epoch<Clock>("3001 ms since", seconds(3));
+  test_good<Clock> ("5000 s", seconds(5000));
+  test_good<Clock> ("5000 ms", milliseconds(5000));
+  test_good<Clock> ("5000 ns", nanoseconds(5000));
+  test_good<Clock> ("5000 ds", duration<boost::int_least64_t, deci> (5000));
+  test_good<Clock> ("5000 [1/30]s", duration<boost::int_least64_t, ratio<1, 30> > (5000));
+
+  test_good<Clock> ("5000 milliseconds", seconds(5));
+  test_good<Clock> ("5 milliseconds", nanoseconds(5000000));
+  test_good<Clock> ("4000 ms", seconds(4));
+  test_fail<Clock> ("3001 ms", seconds(3));
+  test_fail_epoch<Clock> ("3001 ms", seconds(3));
+  test_fail_epoch<Clock> ("3001 ms since", seconds(3));
 
 }
 
 int main()
 {
   std::cout << "high_resolution_clock=" << std::endl;
-  check_all<boost::chrono::high_resolution_clock>();
+  check_all<boost::chrono::high_resolution_clock> ();
 #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
-  std::cout << "steady_clock="<< std::endl;
-  check_all<boost::chrono::steady_clock>();
+  std::cout << "steady_clock=" << std::endl;
+  check_all<boost::chrono::steady_clock> ();
 #endif
   //std::cout << "system_clock=";
   //check_all<boost::chrono::system_clock>();
@@ -107,14 +108,14 @@
 #endif
 
 #if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
-  std::cout << "process_real_cpu_clock="<< std::endl;
-  check_all<boost::chrono::process_real_cpu_clock>();
-  std::cout << "process_user_cpu_clock="<< std::endl;
-  check_all<boost::chrono::process_user_cpu_clock>();
-  std::cout << "process_system_cpu_clock="<< std::endl;
-  check_all<boost::chrono::process_system_cpu_clock>();
-  std::cout << "process_cpu_clock="<< std::endl;
-  check_all<boost::chrono::process_cpu_clock>();
+  std::cout << "process_real_cpu_clock=" << std::endl;
+  check_all<boost::chrono::process_real_cpu_clock> ();
+  std::cout << "process_user_cpu_clock=" << std::endl;
+  check_all<boost::chrono::process_user_cpu_clock> ();
+  std::cout << "process_system_cpu_clock=" << std::endl;
+  check_all<boost::chrono::process_system_cpu_clock> ();
+  std::cout << "process_cpu_clock=" << std::endl;
+  check_all<boost::chrono::process_cpu_clock> ();
 #endif
 
   return boost::report_errors();

Modified: trunk/libs/chrono/test/io/time_point_output.cpp
==============================================================================
--- trunk/libs/chrono/test/io/time_point_output.cpp	(original)
+++ trunk/libs/chrono/test/io/time_point_output.cpp	2011-11-05 23:07:43 EDT (Sat, 05 Nov 2011)
@@ -9,28 +9,28 @@
 #include <boost/chrono/thread_clock.hpp>
 #include <boost/chrono/process_cpu_clocks.hpp>
 
-template<typename Clock, typename D>
+template <typename Clock, typename D>
 void test_good_prefix(const char* str, D d)
 {
   std::ostringstream out;
-  boost::chrono::time_point<Clock,D> tp(d);
+  boost::chrono::time_point<Clock, D> tp(d);
   out << tp;
   BOOST_TEST(out.good());
-  BOOST_TEST((out.str() == std::string(str)+boost::chrono::clock_string<Clock,char>::since()));
+  BOOST_TEST( (out.str() == std::string(str) + boost::chrono::clock_string<Clock, char>::since()));
 }
 
-template<typename Clock, typename D>
+template <typename Clock, typename D>
 void test_good_symbol(const char* str, D d)
 {
   std::ostringstream out;
-  boost::chrono::time_point<Clock,D> tp(d);
+  boost::chrono::time_point<Clock, D> tp(d);
 #if defined BOOST_CHRONO_DONT_PROVIDE_DEPRECATED_IO_V1
   out << boost::chrono::duration_fmt(boost::chrono::duration_style::symbol) << tp;
 #else
   out << boost::chrono::duration_short << tp;
 #endif
   BOOST_TEST(out.good());
-  BOOST_TEST((out.str() == std::string(str)+boost::chrono::clock_string<Clock,char>::since()));
+  BOOST_TEST( (out.str() == std::string(str) + boost::chrono::clock_string<Clock, char>::since()));
 }
 
 #if defined BOOST_CHRONO_DONT_PROVIDE_DEPRECATED_IO_V1
@@ -45,7 +45,7 @@
 }
 #endif
 
-template<typename Clock>
+template <typename Clock>
 void check_all()
 {
   using namespace boost::chrono;
@@ -56,39 +56,39 @@
   test_good<Clock>("2 h", hours(2), duration_style::symbol);
 #endif
 
-  test_good_prefix<Clock>("2 hours", hours(2));
-  test_good_prefix<Clock>("2 minutes", minutes(2));
-  test_good_prefix<Clock>("2 seconds", seconds(2));
-  test_good_prefix<Clock>("1 second", seconds(1));
-  test_good_prefix<Clock>("-1 second", seconds(-1));
-  test_good_prefix<Clock>("0 seconds", seconds(0));
-  test_good_prefix<Clock>("2 milliseconds", milliseconds(2));
-  test_good_prefix<Clock>("2 microseconds", microseconds(2));
-  test_good_prefix<Clock>("2 nanoseconds", nanoseconds(2));
-  test_good_prefix<Clock>("2 deciseconds", duration<boost::int_least64_t, deci> (2));
-  test_good_prefix<Clock>("2 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (2));
+  test_good_prefix<Clock> ("2 hours", hours(2));
+  test_good_prefix<Clock> ("2 minutes", minutes(2));
+  test_good_prefix<Clock> ("2 seconds", seconds(2));
+  test_good_prefix<Clock> ("1 second", seconds(1));
+  test_good_prefix<Clock> ("-1 second", seconds(-1));
+  test_good_prefix<Clock> ("0 seconds", seconds(0));
+  test_good_prefix<Clock> ("2 milliseconds", milliseconds(2));
+  test_good_prefix<Clock> ("2 microseconds", microseconds(2));
+  test_good_prefix<Clock> ("2 nanoseconds", nanoseconds(2));
+  test_good_prefix<Clock> ("2 deciseconds", duration<boost::int_least64_t, deci> (2));
+  test_good_prefix<Clock> ("2 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (2));
 
-  test_good_symbol<Clock>("2 h", hours(2));
+  test_good_symbol<Clock> ("2 h", hours(2));
 #if defined BOOST_CHRONO_DONT_PROVIDE_DEPRECATED_IO_V1
   test_good_symbol<Clock>("2 min", minutes(2));
 #else
-  test_good_symbol<Clock>("2 m", minutes(2));
+  test_good_symbol<Clock> ("2 m", minutes(2));
 #endif
-  test_good_symbol<Clock>("2 s", seconds(2));
-  test_good_symbol<Clock>("2 ms", milliseconds(2));
-  test_good_symbol<Clock>("2 ns", nanoseconds(2));
-  test_good_symbol<Clock>("2 ds", duration<boost::int_least64_t, deci> (2));
-  test_good_symbol<Clock>("2 [1/30]s", duration<boost::int_least64_t, ratio<1, 30> > (2));
+  test_good_symbol<Clock> ("2 s", seconds(2));
+  test_good_symbol<Clock> ("2 ms", milliseconds(2));
+  test_good_symbol<Clock> ("2 ns", nanoseconds(2));
+  test_good_symbol<Clock> ("2 ds", duration<boost::int_least64_t, deci> (2));
+  test_good_symbol<Clock> ("2 [1/30]s", duration<boost::int_least64_t, ratio<1, 30> > (2));
 }
 
 int main()
 {
 
-  std::cout << "high_resolution_clock="<< std::endl;
-  check_all<boost::chrono::high_resolution_clock>();
+  std::cout << "high_resolution_clock=" << std::endl;
+  check_all<boost::chrono::high_resolution_clock> ();
 #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
-  std::cout << "steady_clock="<< std::endl;
-  check_all<boost::chrono::steady_clock>();
+  std::cout << "steady_clock=" << std::endl;
+  check_all<boost::chrono::steady_clock> ();
 #endif
   //std::cout << "system_clock=";
   //check_all<boost::chrono::system_clock>();
@@ -99,14 +99,14 @@
 #endif
 
 #if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
-  std::cout << "process_real_cpu_clock="<< std::endl;
-  check_all<boost::chrono::process_real_cpu_clock>();
-  std::cout << "process_user_cpu_clock="<< std::endl;
-  check_all<boost::chrono::process_user_cpu_clock>();
-  std::cout << "process_system_cpu_clock="<< std::endl;
-  check_all<boost::chrono::process_system_cpu_clock>();
-  std::cout << "process_cpu_clock="<< std::endl;
-  check_all<boost::chrono::process_cpu_clock>();
+  std::cout << "process_real_cpu_clock=" << std::endl;
+  check_all<boost::chrono::process_real_cpu_clock> ();
+  std::cout << "process_user_cpu_clock=" << std::endl;
+  check_all<boost::chrono::process_user_cpu_clock> ();
+  std::cout << "process_system_cpu_clock=" << std::endl;
+  check_all<boost::chrono::process_system_cpu_clock> ();
+  std::cout << "process_cpu_clock=" << std::endl;
+  check_all<boost::chrono::process_cpu_clock> ();
 #endif
 
   return boost::report_errors();