[Boost-commit] svn:boost r74508 - in trunk/boost/chrono: . io

Subject: [Boost-commit] svn:boost r74508 - in trunk/boost/chrono: . io
From: vicente.botet_at_[hidden]
Date: 2011-09-21 18:26:57

Author: viboes
Date: 2011-09-21 18:26:56 EDT (Wed, 21 Sep 2011)
New Revision: 74508
URL: http://svn.boost.org/trac/boost/changeset/74508

Log:
Chrono: Split chrono_io.hpp
Added:
   trunk/boost/chrono/io/
   trunk/boost/chrono/io/clock_string.hpp   (contents, props changed)
   trunk/boost/chrono/io/duration_io.hpp   (contents, props changed)
   trunk/boost/chrono/io/time_point_io.hpp   (contents, props changed)
Text files modified: 
   trunk/boost/chrono/chrono_io.hpp |  1108 --------------------------------------- 
   1 files changed, 2 insertions(+), 1106 deletions(-)

Modified: trunk/boost/chrono/chrono_io.hpp
==============================================================================
--- trunk/boost/chrono/chrono_io.hpp	(original)
+++ trunk/boost/chrono/chrono_io.hpp	2011-09-21 18:26:56 EDT (Wed, 21 Sep 2011)
@@ -13,1111 +13,7 @@
 #ifndef BOOST_CHRONO_CHRONO_IO_HPP
 #define BOOST_CHRONO_CHRONO_IO_HPP
 
-#include <boost/chrono/chrono.hpp>
-#include <boost/chrono/process_cpu_clocks.hpp>
-#include <boost/chrono/thread_clock.hpp>
-#include <boost/ratio/ratio_io.hpp>
-#include <locale>
-#include <boost/type_traits/is_scalar.hpp>
-#include <boost/type_traits/is_signed.hpp>
-#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
-{
-
-namespace chrono
-{
-
-  struct timezone
-  {
-    enum type {
-      utc, local
-    };
-  };
-
-template <class CharT>
-class duration_punct
-    : public std::locale::facet
-{
-public:
-    typedef std::basic_string<CharT> string_type;
-    enum {use_long, use_short};
-
-private:
-    bool use_short_;
-    string_type long_seconds_;
-    string_type long_minutes_;
-    string_type long_hours_;
-    string_type short_seconds_;
-    string_type short_minutes_;
-    string_type short_hours_;
-
-    template <class Period>
-        string_type short_name(Period) const
-            {return ::boost::ratio_string<Period, CharT>::short_name() + short_seconds_;}
-
-    string_type short_name(ratio<1>) const    {return short_seconds_;}
-    string_type short_name(ratio<60>) const   {return short_minutes_;}
-    string_type short_name(ratio<3600>) const {return short_hours_;}
-
-    template <class Period>
-        string_type long_name(Period) const
-            {return ::boost::ratio_string<Period, CharT>::long_name() + long_seconds_;}
-
-    string_type long_name(ratio<1>) const    {return long_seconds_;}
-    string_type long_name(ratio<60>) const   {return long_minutes_;}
-    string_type long_name(ratio<3600>) const {return long_hours_;}
-
-    void init_C();
-public:
-    static std::locale::id id;
-
-    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,
-        size_t refs = 0);
-
-    duration_punct(int use, const duration_punct& d, size_t refs = 0);
-
-    template <class Period>
-        string_type short_name() const
-            {return short_name(typename Period::type());}
-
-    template <class Period>
-        string_type long_name() const
-            {return long_name(typename Period::type());}
-
-    template <class Period>
-        string_type name() const {
-            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_;}
-};
-
-template <class CharT>
-std::locale::id
-duration_punct<CharT>::id;
-
-template <class CharT>
-void
-duration_punct<CharT>::init_C()
-{
-    short_seconds_ = CharT('s');
-    short_minutes_ = CharT('m');
-    short_hours_ = CharT('h');
-    const CharT s[] = {'s', 'e', 'c', 'o', 'n', 'd', 's'};
-    const CharT m[] = {'m', 'i', 'n', 'u', 't', 'e', 's'};
-    const CharT h[] = {'h', 'o', 'u', 'r', 's'};
-    long_seconds_.assign(s, s + sizeof(s)/sizeof(s[0]));
-    long_minutes_.assign(m, m + sizeof(m)/sizeof(m[0]));
-    long_hours_.assign(h, h + sizeof(h)/sizeof(h[0]));
-}
-
-template <class CharT>
-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,
-        size_t refs)
-    : std::locale::facet(refs),
-      use_short_(use==use_short),
-      long_seconds_(long_seconds),
-      long_minutes_(long_minutes),
-      long_hours_(long_hours),
-      short_seconds_(short_seconds),
-      short_minutes_(short_minutes),
-      short_hours_(short_hours)
-{}
-
-template <class CharT>
-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_),
-      short_seconds_(d.short_seconds_),
-      short_minutes_(d.short_minutes_),
-      short_hours_(d.short_hours_)
-{}
-
-template <class CharT, class Traits>
-std::basic_ostream<CharT, Traits>&
-duration_short(std::basic_ostream<CharT, Traits>& os)
-{
-    typedef duration_punct<CharT> Facet;
-    std::locale loc = os.getloc();
-    if (std::has_facet<Facet>(loc))
-    {
-        const Facet& f = std::use_facet<Facet>(loc);
-        if (f.is_long_name())
-            os.imbue(std::locale(loc, new Facet(Facet::use_short, f)));
-    }
-    else
-        os.imbue(std::locale(loc, new Facet(Facet::use_short)));
-    return os;
-}
-
-template <class CharT, class Traits>
-std::basic_ostream<CharT, Traits>&
-duration_long(std::basic_ostream<CharT, Traits>& os)
-{
-    typedef duration_punct<CharT> Facet;
-    std::locale loc = os.getloc();
-    if (std::has_facet<Facet>(loc))
-    {
-        const Facet& f = std::use_facet<Facet>(loc);
-        if (f.is_short_name())
-            os.imbue(std::locale(loc, new Facet(Facet::use_long, f)));
-    }
-    return os;
-}
-
-template <class CharT, class Traits, class Rep, class Period>
-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;
-    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<Rep,Period>(d);
-    }
-    catch (...)
-    {
-        failed = true;
-    }
-    if (failed)
-        os.setstate(std::ios_base::failbit | std::ios_base::badbit);
-
-  }
-  return os;
-}
-
-namespace chrono_detail {
-template <class Rep, bool = is_scalar<Rep>::value>
-struct duration_io_intermediate
-{
-    typedef Rep type;
-};
-
-template <class Rep>
-struct duration_io_intermediate<Rep, true>
-{
-    typedef typename mpl::if_c
-    <
-        is_floating_point<Rep>::value,
-            long double,
-            typename mpl::if_c
-            <
-                is_signed<Rep>::value,
-                    long long,
-                    unsigned long long
-            >::type
-    >::type type;
-};
-
-}
-
-template <class CharT, class Traits, class Rep, class Period>
-std::basic_istream<CharT, Traits>&
-operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
-{
-    typedef duration_punct<CharT> Facet;
-    std::locale loc = is.getloc();
-    if (!std::has_facet<Facet>(loc))
-        is.imbue(std::locale(loc, new Facet));
-    loc = is.getloc();
-    const Facet& f = std::use_facet<Facet>(loc);
-    typedef typename chrono_detail::duration_io_intermediate<Rep>::type intermediate_type;
-    intermediate_type r;
-    // read value into r
-    is >> r;
-    if (is.good())
-    {
-        // now determine unit
-        typedef std::istreambuf_iterator<CharT, Traits> in_iterator;
-        in_iterator i(is);
-        in_iterator e;
-        if (i != e && *i == ' ')  // mandatory ' ' after value
-        {
-            ++i;
-            if (i != e)
-            {
-                // unit is num / den (yet to be determined)
-                unsigned long long num = 0;
-                unsigned long long den = 0;
-                if (*i == '[')
-                {
-                    // parse [N/D]s or [N/D]seconds format
-                    ++i;
-                    CharT x;
-                    is >> num >> x >> den;
-                    if (!is.good() || (x != '/'))
-                    {
-                        is.setstate(is.failbit);
-                        return is;
-                    }
-                    i = in_iterator(is);
-                    if (*i != ']')
-                    {
-                        is.setstate(is.failbit);
-                        return is;
-                    }
-                    ++i;
-                    const std::basic_string<CharT> units[] =
-                    {
-                        f.template long_name<ratio<1> >(),
-                        f.template short_name<ratio<1> >()
-                    };
-                    std::ios_base::iostate err = std::ios_base::goodbit;
-                    const std::basic_string<CharT>* k = chrono_detail::scan_keyword(i, e,
-                                  units, units + sizeof(units)/sizeof(units[0]),
-                                  //~ std::use_facet<std::ctype<CharT> >(loc),
-                                  err);
-                    switch ((k - units) / 2)
-                    {
-                    case 0:
-                        break;
-                    default:
-                        is.setstate(err);
-                        return is;
-                    }
-                }
-                else
-                {
-                    // parse SI name, short or long
-                    const std::basic_string<CharT> units[] =
-                    {
-                        f.template long_name<atto>(),
-                        f.template short_name<atto>(),
-                        f.template long_name<femto>(),
-                        f.template short_name<femto>(),
-                        f.template long_name<pico>(),
-                        f.template short_name<pico>(),
-                        f.template long_name<nano>(),
-                        f.template short_name<nano>(),
-                        f.template long_name<micro>(),
-                        f.template short_name<micro>(),
-                        f.template long_name<milli>(),
-                        f.template short_name<milli>(),
-                        f.template long_name<centi>(),
-                        f.template short_name<centi>(),
-                        f.template long_name<deci>(),
-                        f.template short_name<deci>(),
-                        f.template long_name<deca>(),
-                        f.template short_name<deca>(),
-                        f.template long_name<hecto>(),
-                        f.template short_name<hecto>(),
-                        f.template long_name<kilo>(),
-                        f.template short_name<kilo>(),
-                        f.template long_name<mega>(),
-                        f.template short_name<mega>(),
-                        f.template long_name<giga>(),
-                        f.template short_name<giga>(),
-                        f.template long_name<tera>(),
-                        f.template short_name<tera>(),
-                        f.template long_name<peta>(),
-                        f.template short_name<peta>(),
-                        f.template long_name<exa>(),
-                        f.template short_name<exa>(),
-                        f.template long_name<ratio<1> >(),
-                        f.template short_name<ratio<1> >(),
-                        f.template long_name<ratio<60> >(),
-                        f.template short_name<ratio<60> >(),
-                        f.template long_name<ratio<3600> >(),
-                        f.template short_name<ratio<3600> >()
-                    };
-                    std::ios_base::iostate err = std::ios_base::goodbit;
-                    const std::basic_string<CharT>* k = chrono_detail::scan_keyword(i, e,
-                                  units, units + sizeof(units)/sizeof(units[0]),
-                                  //~ std::use_facet<std::ctype<CharT> >(loc),
-                                  err);
-                    switch ((k - units) / 2)
-                    {
-                    case 0:
-                        num = 1ULL;
-                        den = 1000000000000000000ULL;
-                        break;
-                    case 1:
-                        num = 1ULL;
-                        den = 1000000000000000ULL;
-                        break;
-                    case 2:
-                        num = 1ULL;
-                        den = 1000000000000ULL;
-                        break;
-                    case 3:
-                        num = 1ULL;
-                        den = 1000000000ULL;
-                        break;
-                    case 4:
-                        num = 1ULL;
-                        den = 1000000ULL;
-                        break;
-                    case 5:
-                        num = 1ULL;
-                        den = 1000ULL;
-                        break;
-                    case 6:
-                        num = 1ULL;
-                        den = 100ULL;
-                        break;
-                    case 7:
-                        num = 1ULL;
-                        den = 10ULL;
-                        break;
-                    case 8:
-                        num = 10ULL;
-                        den = 1ULL;
-                        break;
-                    case 9:
-                        num = 100ULL;
-                        den = 1ULL;
-                        break;
-                    case 10:
-                        num = 1000ULL;
-                        den = 1ULL;
-                        break;
-                    case 11:
-                        num = 1000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 12:
-                        num = 1000000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 13:
-                        num = 1000000000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 14:
-                        num = 1000000000000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 15:
-                        num = 1000000000000000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 16:
-                        num = 1;
-                        den = 1;
-                        break;
-                    case 17:
-                        num = 60;
-                        den = 1;
-                        break;
-                    case 18:
-                        num = 3600;
-                        den = 1;
-                        break;
-                    default:
-                        is.setstate(err);
-                        return is;
-                    }
-                }
-                // unit is num/den
-                // r should be multiplied by (num/den) / Period
-                // Reduce (num/den) / Period to lowest terms
-                unsigned long long gcd_n1_n2 = math::gcd<unsigned long long>(num, Period::num);
-                unsigned long long gcd_d1_d2 = math::gcd<unsigned long long>(den, Period::den);
-                num /= gcd_n1_n2;
-                den /= gcd_d1_d2;
-                unsigned long long n2 = Period::num / gcd_n1_n2;
-                unsigned long long d2 = Period::den / gcd_d1_d2;
-                if (num > (std::numeric_limits<unsigned long long>::max)() / d2 ||
-                    den > (std::numeric_limits<unsigned long long>::max)() / n2)
-                {
-                    // (num/den) / Period overflows
-                    is.setstate(is.failbit);
-                    return is;
-                }
-                num *= d2;
-                den *= n2;
-                // num / den is now factor to multiply by r
-                typedef typename common_type<intermediate_type, unsigned long long>::type common_type_t;
-                if (is_integral<intermediate_type>::value)
-                {
-                    // Reduce r * num / den
-                    common_type_t t = math::gcd<common_type_t>(r, den);
-                    r /= t;
-                    den /= t;
-                    if (den != 1)
-                    {
-                        // Conversion to Period is integral and not exact
-                        is.setstate(is.failbit);
-                        return is;
-                    }
-                }
-                if (r > ((duration_values<common_type_t>::max)() / num))
-                {
-                    // Conversion to Period overflowed
-                    is.setstate(is.failbit);
-                    return is;
-                }
-                common_type_t t = r * num;
-                t /= den;
-                if ((duration_values<Rep>::max)() < t)
-                {
-                    // Conversion to Period overflowed
-                    is.setstate(is.failbit);
-                    return is;
-                }
-                // Success!  Store it.
-                r = Rep(t);
-                d = duration<Rep, Period>(r);
-            }
-            else
-                is.setstate(is.failbit | is.eofbit);
-        }
-        else
-        {
-            if (i == e)
-                is.setstate(is.eofbit);
-            is.setstate(is.failbit);
-        }
-    }
-    else
-        is.setstate(is.failbit);
-    return is;
-}
-
-template <class Clock, class CharT>
-struct clock_string;
-
-template <class CharT>
-struct clock_string<system_clock, CharT>
-{
-    static std::basic_string<CharT> name()
-    {
-        static const CharT u[] = {'s', 'y', 's', 't', 'e', 'm', '_',
-                                'c', 'l','o', 'c', 'k'};
-        static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-    static std::basic_string<CharT> since()
-    {
-        static const CharT u[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 'J', 'a',
-                              'n', ' ', '1', ',', ' ', '1', '9', '7', '0'};
-        static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-};
-#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
-
-template <class CharT>
-struct clock_string<steady_clock, CharT>
-{
-    static std::basic_string<CharT> name()
-    {
-        static const CharT u[] = {'m', 'o', 'n', 'o', 't', 'o', 'n', 'i', 'c', '_',
-                                'c', 'l','o', 'c', 'k'};
-        static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-    static std::basic_string<CharT> since()
-    {
-        const CharT u[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 'b', 'o', 'o', 't'};
-        const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-};
-
-
-#endif
-
-#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
-
-template <class CharT>
-struct clock_string<thread_clock, CharT>
-{
-    static std::basic_string<CharT> name()
-    {
-        static const CharT u[] = {'t', 'h', 'r', 'e', 'd', '_',
-                                'c', 'l','o', 'c', 'k'};
-        static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-    static std::basic_string<CharT> since()
-    {
-        const CharT u[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 't', 'r', 'e', 'a', 'd', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p'};
-        const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-};
-
-#endif
-
-template <class CharT>
-struct clock_string<process_real_cpu_clock, CharT>
-{
-    static std::basic_string<CharT> name()
-    {
-        static const CharT u[] = {'p', 'r', 'o', 'c', 'e', 's', 's', '_', 'r', 'e', 'a', 'l','_',
-                                'c', 'l','o', 'c', 'k'};
-        static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-    static std::basic_string<CharT> since()
-    {
-        const CharT u[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 'p', 'r', 'o', 'c', 'e', 's', 's', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p'};
-        const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-};
-
-template <class CharT>
-struct clock_string<process_user_cpu_clock, CharT>
-{
-    static std::basic_string<CharT> name()
-    {
-        static const CharT u[] = {'p', 'r', 'o', 'c', 'e', 's', 's', '_', 'u', 's', 'e', 'r','_',
-                                'c', 'l','o', 'c', 'k'};
-        static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-    static std::basic_string<CharT> since()
-    {
-        const CharT u[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 'p', 'r', 'o', 'c', 'e', 's', 's', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p'};
-        const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-};
-
-template <class CharT>
-struct clock_string<process_system_cpu_clock, CharT>
-{
-    static std::basic_string<CharT> name()
-    {
-        static const CharT u[] = {'p', 'r', 'o', 'c', 'e', 's', 's', '_', 's', 'y', 's', 't', 't', 'e', 'm', '_',
-                                'c', 'l','o', 'c', 'k'};
-        static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-    static std::basic_string<CharT> since()
-    {
-        const CharT u[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 'p', 'r', 'o', 'c', 'e', 's', 's', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p'};
-        const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-};
-
-template <class CharT>
-struct clock_string<process_cpu_clock, CharT>
-{
-    static std::basic_string<CharT> name()
-    {
-        static const CharT u[] = {'p', 'r', 'o', 'c', 'e', 's', 's', '_',
-                                'c', 'l','o', 'c', 'k'};
-        static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-    static std::basic_string<CharT> since()
-    {
-        const CharT u[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 'p', 'r', 'o', 'c', 'e', 's', 's', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p'};
-        const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
-        return str;
-    }
-};
-
-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 get_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,
-           const time_point<Clock, Duration>& tp)
-{
-    return os << tp.time_since_epoch() << clock_string<Clock, CharT>::since();
-}
-
-template <class CharT, class Traits, class Clock, class Duration>
-std::basic_istream<CharT, Traits>&
-operator>>(std::basic_istream<CharT, Traits>& is,
-           time_point<Clock, Duration>& tp)
-{
-    Duration d;
-    is >> d;
-    if (is.good())
-    {
-        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);
-        in_iterator e;
-        std::ptrdiff_t k = chrono_detail::scan_keyword(i, e,
-                      &units, &units + 1,
-                      //~ std::use_facet<std::ctype<CharT> >(is.getloc()),
-                      err) - &units;
-        if (k == 1)
-        {
-            // failed to read epoch string
-            is.setstate(err);
-            return is;
-        }
-        tp = time_point<Clock, Duration>(d);
-    }
-    else
-        is.setstate(is.failbit);
-    return is;
-}
-
-#ifndef BOOST_CHRONO_NO_UTC_TIMEPOINT
-
-namespace detail
-{
-        #if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
-        int is_leap(int year)
-        {
-            if(year % 400 == 0)
-                return 1;
-            if(year % 100 == 0)
-                return 0;
-            if(year % 4 == 0)
-                return 1;
-            return 0;
-        }
-        inline int days_from_0(int year)
-        {
-            year--;
-            return 365 * year + (year / 400) - (year/100) + (year / 4);
-        }
-        int days_from_1970(int year)
-        {
-            static const int days_from_0_to_1970 = days_from_0(1970);
-            return days_from_0(year) - days_from_0_to_1970;
-        }
-        int days_from_1jan(int year,int month,int day)
-        {
-            static const int days[2][12] = {
-                { 0,31,59,90,120,151,181,212,243,273,304,334 },
-                { 0,31,60,91,121,152,182,213,244,274,305,335 }
-            };
-            return days[is_leap(year)][month-1] + day - 1;
-        }
-
-        time_t internal_timegm(std::tm  const *t)
-        {
-            int year = t->tm_year + 1900;
-            int month = t->tm_mon;
-            if(month > 11) {
-                year += month/12;
-                month %= 12;
-            }
-            else if(month < 0) {
-                int years_diff = (-month + 11)/12;
-                year -= years_diff;
-                month+=12 * years_diff;
-            }
-            month++;
-            int day = t->tm_mday;
-            int day_of_year = days_from_1jan(year,month,day);
-            int days_since_epoch = days_from_1970(year) + day_of_year;
-
-            time_t seconds_in_day = 3600 * 24;
-            time_t result =  seconds_in_day * days_since_epoch + 3600 * t->tm_hour + 60 * t->tm_min + t->tm_sec;
-
-            return result;
-        }
-        #endif
-} // detail
-
-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.get_timezone();
-            }
-            time_t t = system_clock::to_time_t(tp);
-            tm tm;
-            if (tz == timezone::local)
-            {
-                #if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
-                std::tm *tmp = 0;
-                if ((tmp=localtime(&t)) == 0)
-                  failed = true;
-                tm =*tmp;
-                #else
-                if (localtime_r(&t, &tm) == 0)
-                    failed = true;
-                #endif
-            }
-            else
-            {
-                #if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
-                std::tm *tmp = 0;
-                if((tmp = gmtime(&t)) == 0)
-                    failed = true;
-                tm = *tmp;
-                #else
-                if (gmtime_r(&t, &tm) == 0)
-                    failed = true;
-                #endif
-
-            }
-            if (!failed)
-            {
-                const std::time_put<_CharT>& tpf = std::use_facet<std::time_put<_CharT> >(loc);
-                if (pb == pe)
-                {
-                    _CharT pattern[] = {'%', 'Y', '-', '%', 'm', ' ', '%', 'd', ' ', '%', '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);
-}
-
-} // detail
-
-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;
-                #if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
-                t = detail::internal_timegm(&tm);
-                #else
-                t = timegm(&tm);
-                #endif
-                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 minu(0);
-                if (fz != pe)
-                {
-                    if (err != std::ios_base::goodbit)
-                    {
-                        err |= std::ios_base::failbit;
-                        goto exit;
-                    }
-                    _I i(is);
-                    _I eof;
-                    minu = 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)
-                #if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
-                t = detail::internal_timegm(&tm);
-                #else
-                t = timegm(&tm);
-                #endif
-                else
-                    t = mktime(&tm);
-                tp = system_clock::from_time_t(t) - minu;
-            }
-        }
-        catch (...)
-        {
-            err |= std::ios_base::badbit | std::ios_base::failbit;
-        }
-    exit:
-        is.setstate(err);
-    }
-    return is;
-}
-#endif //UTC
-}  // chrono
-
-}
-#include <boost/chrono/duration_style.hpp>
+#include <boost/chrono/io/time_point_io.hpp>
+#include <boost/chrono/io/duration_io.hpp>
 
 #endif  // BOOST_CHRONO_CHRONO_IO_HPP

Added: trunk/boost/chrono/io/clock_string.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/io/clock_string.hpp	2011-09-21 18:26:56 EDT (Wed, 21 Sep 2011)
@@ -0,0 +1,190 @@
+//
+//  (C) Copyright 2010 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_CLOCK_STRING_HPP
+#define BOOST_CHRONO_IO_CLOCK_STRING_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/chrono.hpp>
+#include <boost/chrono/process_cpu_clocks.hpp>
+#include <boost/chrono/thread_clock.hpp>
+#include <string>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    template<class Clock, class CharT>
+    struct clock_string;
+
+    template<class CharT>
+    struct clock_string<system_clock, CharT>
+    {
+      static std::basic_string<CharT> name()
+      {
+        static const CharT u[] =
+        { 's', 'y', 's', 't', 'e', 'm', '_', 'c', 'l', 'o', 'c', 'k' };
+        static const std::basic_string<CharT> str(u, u + sizeof(u)
+            / sizeof(u[0]));
+        return str;
+      }
+      static std::basic_string<CharT> since()
+      {
+        static const CharT
+            u[] =
+                { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'J', 'a', 'n', ' ', '1', ',', ' ', '1', '9', '7', '0' };
+        static const std::basic_string<CharT> str(u, u + sizeof(u)
+            / sizeof(u[0]));
+        return str;
+      }
+    };
+
+#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
+
+    template<class CharT>
+    struct clock_string<steady_clock, CharT>
+    {
+      static std::basic_string<CharT> name()
+      {
+        static const CharT
+            u[] =
+                { 'm', 'o', 'n', 'o', 't', 'o', 'n', 'i', 'c', '_', 'c', 'l', 'o', 'c', 'k' };
+        static const std::basic_string<CharT> str(u, u + sizeof(u)
+            / sizeof(u[0]));
+        return str;
+      }
+      static std::basic_string<CharT> since()
+      {
+        const CharT u[] =
+        { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'b', 'o', 'o', 't' };
+        const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
+        return str;
+      }
+    };
+
+#endif
+
+#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
+
+    template <class CharT>
+    struct clock_string<thread_clock, CharT>
+    {
+      static std::basic_string<CharT> name()
+      {
+        static const CharT u[] =
+        { 't', 'h', 'r', 'e', 'd', '_',
+          'c', 'l','o', 'c', 'k'};
+        static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
+        return str;
+      }
+      static std::basic_string<CharT> since()
+      {
+        const CharT u[] =
+        { ' ', 's', 'i', 'n', 'c', 'e', ' ', 't', 'r', 'e', 'a', 'd', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p'};
+        const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
+        return str;
+      }
+    };
+
+#endif
+
+#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
+
+    template<class CharT>
+    struct clock_string<process_real_cpu_clock, CharT>
+    {
+      static std::basic_string<CharT> name()
+      {
+        static const CharT
+            u[] =
+                { 'p', 'r', 'o', 'c', 'e', 's', 's', '_', 'r', 'e', 'a', 'l', '_', 'c', 'l', 'o', 'c', 'k' };
+        static const std::basic_string<CharT> str(u, u + sizeof(u)
+            / sizeof(u[0]));
+        return str;
+      }
+      static std::basic_string<CharT> since()
+      {
+        const CharT
+            u[] =
+                { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'p', 'r', 'o', 'c', 'e', 's', 's', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p' };
+        const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
+        return str;
+      }
+    };
+
+    template<class CharT>
+    struct clock_string<process_user_cpu_clock, CharT>
+    {
+      static std::basic_string<CharT> name()
+      {
+        static const CharT
+            u[] =
+                { 'p', 'r', 'o', 'c', 'e', 's', 's', '_', 'u', 's', 'e', 'r', '_', 'c', 'l', 'o', 'c', 'k' };
+        static const std::basic_string<CharT> str(u, u + sizeof(u)
+            / sizeof(u[0]));
+        return str;
+      }
+      static std::basic_string<CharT> since()
+      {
+        const CharT
+            u[] =
+                { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'p', 'r', 'o', 'c', 'e', 's', 's', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p' };
+        const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
+        return str;
+      }
+    };
+
+    template<class CharT>
+    struct clock_string<process_system_cpu_clock, CharT>
+    {
+      static std::basic_string<CharT> name()
+      {
+        static const CharT
+            u[] =
+                { 'p', 'r', 'o', 'c', 'e', 's', 's', '_', 's', 'y', 's', 't', 't', 'e', 'm', '_', 'c', 'l', 'o', 'c', 'k' };
+        static const std::basic_string<CharT> str(u, u + sizeof(u)
+            / sizeof(u[0]));
+        return str;
+      }
+      static std::basic_string<CharT> since()
+      {
+        const CharT
+            u[] =
+                { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'p', 'r', 'o', 'c', 'e', 's', 's', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p' };
+        const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
+        return str;
+      }
+    };
+
+    template<class CharT>
+    struct clock_string<process_cpu_clock, CharT>
+    {
+      static std::basic_string<CharT> name()
+      {
+        static const CharT u[] =
+        { 'p', 'r', 'o', 'c', 'e', 's', 's', '_', 'c', 'l', 'o', 'c', 'k' };
+        static const std::basic_string<CharT> str(u, u + sizeof(u)
+            / sizeof(u[0]));
+        return str;
+      }
+      static std::basic_string<CharT> since()
+      {
+        const CharT
+            u[] =
+                { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'p', 'r', 'o', 'c', 'e', 's', 's', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p' };
+        const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
+        return str;
+      }
+    };
+#endif
+
+  } // chrono
+
+}
+
+#endif  // BOOST_CHRONO_CHRONO_IO_HPP

Added: trunk/boost/chrono/io/duration_io.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/io/duration_io.hpp	2011-09-21 18:26:56 EDT (Wed, 21 Sep 2011)
@@ -0,0 +1,676 @@
+//  chrono_io
+//
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2010 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).
+//
+// This code was adapted by Vicente from Howard Hinnant's experimental work
+// on chrono i/o  to Boost
+
+#ifndef BOOST_CHRONO_IO_DURATION_IO_HPP
+#define BOOST_CHRONO_IO_DURATION_IO_HPP
+
+#include <boost/chrono/chrono.hpp>
+#include <boost/ratio/ratio_io.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/math/common_factor_rt.hpp>
+#include <boost/chrono/detail/scan_keyword.hpp>
+#include <locale>
+
+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
+      };
+    };
+
+    template<class CharT>
+    class duration_punct: public std::locale::facet
+    {
+    public:
+      typedef std::basic_string<CharT> string_type;
+      enum
+      {
+        use_long, use_short
+      };
+
+    private:
+      bool use_short_;
+      string_type long_seconds_;
+      string_type long_minutes_;
+      string_type long_hours_;
+      string_type short_seconds_;
+      string_type short_minutes_;
+      string_type short_hours_;
+
+      template<class Period>
+      string_type short_name(Period) const
+      {
+        return ::boost::ratio_string<Period, CharT>::short_name()
+            + short_seconds_;
+      }
+
+      string_type short_name(ratio<1> ) const
+      {
+        return short_seconds_;
+      }
+      string_type short_name(ratio<60> ) const
+      {
+        return short_minutes_;
+      }
+      string_type short_name(ratio<3600> ) const
+      {
+        return short_hours_;
+      }
+
+      template<class Period>
+      string_type long_name(Period) const
+      {
+        return ::boost::ratio_string<Period, CharT>::long_name()
+            + long_seconds_;
+      }
+
+      string_type long_name(ratio<1> ) const
+      {
+        return long_seconds_;
+      }
+      string_type long_name(ratio<60> ) const
+      {
+        return long_minutes_;
+      }
+      string_type long_name(ratio<3600> ) const
+      {
+        return long_hours_;
+      }
+
+      void init_C();
+    public:
+      static std::locale::id id;
+
+      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, size_t refs =
+              0);
+
+      duration_punct(int use, const duration_punct& d, size_t refs = 0);
+
+      template<class Period>
+      string_type short_name() const
+      {
+        return short_name(typename Period::type());
+      }
+
+      template<class Period>
+      string_type long_name() const
+      {
+        return long_name(typename Period::type());
+      }
+
+      template<class Period>
+      string_type name() const
+      {
+        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_;
+      }
+    };
+
+    template<class CharT>
+    std::locale::id duration_punct<CharT>::id;
+
+    template<class CharT>
+    void duration_punct<CharT>::init_C()
+    {
+      short_seconds_ = CharT('s');
+      short_minutes_ = CharT('m');
+      short_hours_ = CharT('h');
+      const CharT s[] =
+      { 's', 'e', 'c', 'o', 'n', 'd', 's' };
+      const CharT m[] =
+      { 'm', 'i', 'n', 'u', 't', 'e', 's' };
+      const CharT h[] =
+      { 'h', 'o', 'u', 'r', 's' };
+      long_seconds_.assign(s, s + sizeof(s) / sizeof(s[0]));
+      long_minutes_.assign(m, m + sizeof(m) / sizeof(m[0]));
+      long_hours_.assign(h, h + sizeof(h) / sizeof(h[0]));
+    }
+
+    template<class CharT>
+    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, size_t refs) :
+      std::locale::facet(refs), use_short_(use == use_short),
+          long_seconds_(long_seconds), long_minutes_(long_minutes),
+          long_hours_(long_hours), short_seconds_(short_seconds),
+          short_minutes_(short_minutes), short_hours_(short_hours)
+    {
+    }
+
+    template<class CharT>
+    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_), short_seconds_(d.short_seconds_),
+          short_minutes_(d.short_minutes_), short_hours_(d.short_hours_)
+    {
+    }
+
+    template<class CharT, class Traits>
+    std::basic_ostream<CharT, Traits>&
+    duration_short(std::basic_ostream<CharT, Traits>& os)
+    {
+      typedef duration_punct<CharT> Facet;
+      std::locale loc = os.getloc();
+      if (std::has_facet<Facet>(loc))
+      {
+        const Facet& f = std::use_facet<Facet>(loc);
+        if (f.is_long_name())
+          os.imbue(std::locale(loc, new Facet(Facet::use_short, f)));
+      } else
+        os.imbue(std::locale(loc, new Facet(Facet::use_short)));
+      return os;
+    }
+
+    template<class CharT, class Traits>
+    std::basic_ostream<CharT, Traits>&
+    duration_long(std::basic_ostream<CharT, Traits>& os)
+    {
+      typedef duration_punct<CharT> Facet;
+      std::locale loc = os.getloc();
+      if (std::has_facet<Facet>(loc))
+      {
+        const Facet& f = std::use_facet<Facet>(loc);
+        if (f.is_short_name())
+          os.imbue(std::locale(loc, new Facet(Facet::use_long, f)));
+      }
+      return os;
+    }
+
+
+    /**
+     * 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_;
+    };
+
+    template <class CharT, class Traits, class Rep, class Period>
+    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;
+        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<Rep,Period>(d);
+        }
+        catch (...)
+        {
+          failed = true;
+        }
+        if (failed)
+        os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+
+      }
+      return os;
+    }
+
+    namespace chrono_detail
+    {
+      template <class Rep, bool = is_scalar<Rep>::value>
+      struct duration_io_intermediate
+      {
+        typedef Rep type;
+      };
+
+      template <class Rep>
+      struct duration_io_intermediate<Rep, true>
+      {
+        typedef typename mpl::if_c
+        <
+        is_floating_point<Rep>::value,
+        long double,
+        typename mpl::if_c
+        <
+        is_signed<Rep>::value,
+        long long,
+        unsigned long long
+        >::type
+        >::type type;
+      };
+
+    }
+
+    template <class CharT, class Traits, class Rep, class Period>
+    std::basic_istream<CharT, Traits>&
+    operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
+    {
+      typedef duration_punct<CharT> Facet;
+      std::locale loc = is.getloc();
+      if (!std::has_facet<Facet>(loc))
+      is.imbue(std::locale(loc, new Facet));
+      loc = is.getloc();
+      const Facet& f = std::use_facet<Facet>(loc);
+      typedef typename chrono_detail::duration_io_intermediate<Rep>::type intermediate_type;
+      intermediate_type r;
+      // read value into r
+      is >> r;
+      if (is.good())
+      {
+        // now determine unit
+        typedef std::istreambuf_iterator<CharT, Traits> in_iterator;
+        in_iterator i(is);
+        in_iterator e;
+        if (i != e && *i == ' ') // mandatory ' ' after value
+
+        {
+          ++i;
+          if (i != e)
+          {
+            // unit is num / den (yet to be determined)
+            unsigned long long num = 0;
+            unsigned long long den = 0;
+            if (*i == '[')
+            {
+              // parse [N/D]s or [N/D]seconds format
+              ++i;
+              CharT x;
+              is >> num >> x >> den;
+              if (!is.good() || (x != '/'))
+              {
+                is.setstate(is.failbit);
+                return is;
+              }
+              i = in_iterator(is);
+              if (*i != ']')
+              {
+                is.setstate(is.failbit);
+                return is;
+              }
+              ++i;
+              const std::basic_string<CharT> units[] =
+              {
+                f.template long_name<ratio<1> >(),
+                f.template short_name<ratio<1> >()
+              };
+              std::ios_base::iostate err = std::ios_base::goodbit;
+              const std::basic_string<CharT>* k = chrono_detail::scan_keyword(i, e,
+                  units, units + sizeof(units)/sizeof(units[0]),
+                  //~ std::use_facet<std::ctype<CharT> >(loc),
+                  err);
+              switch ((k - units) / 2)
+              {
+                case 0:
+                break;
+                default:
+                is.setstate(err);
+                return is;
+              }
+            }
+            else
+            {
+              // parse SI name, short or long
+              const std::basic_string<CharT> units[] =
+              {
+                f.template long_name<atto>(),
+                f.template short_name<atto>(),
+                f.template long_name<femto>(),
+                f.template short_name<femto>(),
+                f.template long_name<pico>(),
+                f.template short_name<pico>(),
+                f.template long_name<nano>(),
+                f.template short_name<nano>(),
+                f.template long_name<micro>(),
+                f.template short_name<micro>(),
+                f.template long_name<milli>(),
+                f.template short_name<milli>(),
+                f.template long_name<centi>(),
+                f.template short_name<centi>(),
+                f.template long_name<deci>(),
+                f.template short_name<deci>(),
+                f.template long_name<deca>(),
+                f.template short_name<deca>(),
+                f.template long_name<hecto>(),
+                f.template short_name<hecto>(),
+                f.template long_name<kilo>(),
+                f.template short_name<kilo>(),
+                f.template long_name<mega>(),
+                f.template short_name<mega>(),
+                f.template long_name<giga>(),
+                f.template short_name<giga>(),
+                f.template long_name<tera>(),
+                f.template short_name<tera>(),
+                f.template long_name<peta>(),
+                f.template short_name<peta>(),
+                f.template long_name<exa>(),
+                f.template short_name<exa>(),
+                f.template long_name<ratio<1> >(),
+                f.template short_name<ratio<1> >(),
+                f.template long_name<ratio<60> >(),
+                f.template short_name<ratio<60> >(),
+                f.template long_name<ratio<3600> >(),
+                f.template short_name<ratio<3600> >()
+              };
+              std::ios_base::iostate err = std::ios_base::goodbit;
+              const std::basic_string<CharT>* k = chrono_detail::scan_keyword(i, e,
+                  units, units + sizeof(units)/sizeof(units[0]),
+                  //~ std::use_facet<std::ctype<CharT> >(loc),
+                  err);
+              switch ((k - units) / 2)
+              {
+                case 0:
+                num = 1ULL;
+                den = 1000000000000000000ULL;
+                break;
+                case 1:
+                num = 1ULL;
+                den = 1000000000000000ULL;
+                break;
+                case 2:
+                num = 1ULL;
+                den = 1000000000000ULL;
+                break;
+                case 3:
+                num = 1ULL;
+                den = 1000000000ULL;
+                break;
+                case 4:
+                num = 1ULL;
+                den = 1000000ULL;
+                break;
+                case 5:
+                num = 1ULL;
+                den = 1000ULL;
+                break;
+                case 6:
+                num = 1ULL;
+                den = 100ULL;
+                break;
+                case 7:
+                num = 1ULL;
+                den = 10ULL;
+                break;
+                case 8:
+                num = 10ULL;
+                den = 1ULL;
+                break;
+                case 9:
+                num = 100ULL;
+                den = 1ULL;
+                break;
+                case 10:
+                num = 1000ULL;
+                den = 1ULL;
+                break;
+                case 11:
+                num = 1000000ULL;
+                den = 1ULL;
+                break;
+                case 12:
+                num = 1000000000ULL;
+                den = 1ULL;
+                break;
+                case 13:
+                num = 1000000000000ULL;
+                den = 1ULL;
+                break;
+                case 14:
+                num = 1000000000000000ULL;
+                den = 1ULL;
+                break;
+                case 15:
+                num = 1000000000000000000ULL;
+                den = 1ULL;
+                break;
+                case 16:
+                num = 1;
+                den = 1;
+                break;
+                case 17:
+                num = 60;
+                den = 1;
+                break;
+                case 18:
+                num = 3600;
+                den = 1;
+                break;
+                default:
+                is.setstate(err);
+                return is;
+              }
+            }
+            // unit is num/den
+            // r should be multiplied by (num/den) / Period
+            // Reduce (num/den) / Period to lowest terms
+            unsigned long long gcd_n1_n2 = math::gcd<unsigned long long>(num, Period::num);
+            unsigned long long gcd_d1_d2 = math::gcd<unsigned long long>(den, Period::den);
+            num /= gcd_n1_n2;
+            den /= gcd_d1_d2;
+            unsigned long long n2 = Period::num / gcd_n1_n2;
+            unsigned long long d2 = Period::den / gcd_d1_d2;
+            if (num > (std::numeric_limits<unsigned long long>::max)() / d2 ||
+                den > (std::numeric_limits<unsigned long long>::max)() / n2)
+            {
+              // (num/den) / Period overflows
+              is.setstate(is.failbit);
+              return is;
+            }
+            num *= d2;
+            den *= n2;
+            // num / den is now factor to multiply by r
+            typedef typename common_type<intermediate_type, unsigned long long>::type common_type_t;
+            if (is_integral<intermediate_type>::value)
+            {
+              // Reduce r * num / den
+              common_type_t t = math::gcd<common_type_t>(r, den);
+              r /= t;
+              den /= t;
+              if (den != 1)
+              {
+                // Conversion to Period is integral and not exact
+                is.setstate(is.failbit);
+                return is;
+              }
+            }
+            if (r > ((duration_values<common_type_t>::max)() / num))
+            {
+              // Conversion to Period overflowed
+              is.setstate(is.failbit);
+              return is;
+            }
+            common_type_t t = r * num;
+            t /= den;
+            if ((duration_values<Rep>::max)() < t)
+            {
+              // Conversion to Period overflowed
+              is.setstate(is.failbit);
+              return is;
+            }
+            // Success!  Store it.
+            r = Rep(t);
+            d = duration<Rep, Period>(r);
+          }
+          else
+          is.setstate(is.failbit | is.eofbit);
+        }
+        else
+        {
+          if (i == e)
+          is.setstate(is.eofbit);
+          is.setstate(is.failbit);
+        }
+      }
+      else
+      is.setstate(is.failbit);
+      return is;
+    }
+
+  } // chrono
+
+}
+#include <boost/chrono/duration_style.hpp>
+
+#endif  // BOOST_CHRONO_CHRONO_IO_HPP

Added: trunk/boost/chrono/io/time_point_io.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/chrono/io/time_point_io.hpp	2011-09-21 18:26:56 EDT (Wed, 21 Sep 2011)
@@ -0,0 +1,531 @@
+//  chrono_io
+//
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2010 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).
+//
+// This code was adapted by Vicente from Howard Hinnant's experimental work
+// on chrono i/o under lvm/libc++  to Boost
+
+#ifndef BOOST_CHRONO_IO_TIME_POINT_IO_HPP
+#define BOOST_CHRONO_IO_TIME_POINT_IO_HPP
+
+#include <boost/chrono/io/clock_string.hpp>
+#include <boost/chrono/io/duration_io.hpp>
+#include <boost/chrono/chrono.hpp>
+#include <locale>
+#include <boost/chrono/detail/scan_keyword.hpp>
+#include <boost/chrono/round.hpp>
+
+namespace boost
+{
+
+  namespace chrono
+  {
+
+    struct timezone
+    {
+      enum type
+      {
+        utc, local
+      };
+    };
+
+    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 get_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, const time_point<Clock,
+        Duration>& tp)
+    {
+      return os << tp.time_since_epoch() << clock_string<Clock, CharT>::since();
+    }
+
+    template<class CharT, class Traits, class Clock, class Duration>
+    std::basic_istream<CharT, Traits>&
+    operator>>(std::basic_istream<CharT, Traits>& is, time_point<Clock,
+        Duration>& tp)
+    {
+      Duration d;
+      is >> d;
+      if (is.good())
+      {
+        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);
+        in_iterator e;
+        std::ptrdiff_t k =
+            chrono_detail::scan_keyword(i, e, &units, &units + 1,
+            //~ std::use_facet<std::ctype<CharT> >(is.getloc()),
+            err) - &units;
+        if (k == 1)
+        {
+          // failed to read epoch string
+          is.setstate(err);
+          return is;
+        }
+        tp = time_point<Clock, Duration> (d);
+      } else
+        is.setstate(is.failbit);
+      return is;
+    }
+
+#ifndef BOOST_CHRONO_NO_UTC_TIMEPOINT
+
+    namespace detail
+    {
+#if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+    int is_leap(int year)
+    {
+      if(year % 400 == 0)
+      return 1;
+      if(year % 100 == 0)
+      return 0;
+      if(year % 4 == 0)
+      return 1;
+      return 0;
+    }
+    inline int days_from_0(int year)
+    {
+      year--;
+      return 365 * year + (year / 400) - (year/100) + (year / 4);
+    }
+    int days_from_1970(int year)
+    {
+      static const int days_from_0_to_1970 = days_from_0(1970);
+      return days_from_0(year) - days_from_0_to_1970;
+    }
+    int days_from_1jan(int year,int month,int day)
+    {
+      static const int days[2][12] =
+      {
+        { 0,31,59,90,120,151,181,212,243,273,304,334},
+        { 0,31,60,91,121,152,182,213,244,274,305,335}
+      };
+      return days[is_leap(year)][month-1] + day - 1;
+    }
+
+    time_t internal_timegm(std::tm const *t)
+    {
+      int year = t->tm_year + 1900;
+      int month = t->tm_mon;
+      if(month > 11)
+      {
+        year += month/12;
+        month %= 12;
+      }
+      else if(month < 0)
+      {
+        int years_diff = (-month + 11)/12;
+        year -= years_diff;
+        month+=12 * years_diff;
+      }
+      month++;
+      int day = t->tm_mday;
+      int day_of_year = days_from_1jan(year,month,day);
+      int days_since_epoch = days_from_1970(year) + day_of_year;
+
+      time_t seconds_in_day = 3600 * 24;
+      time_t result = seconds_in_day * days_since_epoch + 3600 * t->tm_hour + 60 * t->tm_min + t->tm_sec;
+
+      return result;
+    }
+#endif
+    } // detail
+
+    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.get_timezone();
+          }
+          time_t t = system_clock::to_time_t(tp);
+          tm tm;
+          if (tz == timezone::local)
+          {
+#if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+            std::tm *tmp = 0;
+            if ((tmp=localtime(&t)) == 0)
+            failed = true;
+            tm =*tmp;
+#else
+            if (localtime_r(&t, &tm) == 0)
+              failed = true;
+#endif
+          } else
+          {
+#if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+            std::tm *tmp = 0;
+            if((tmp = gmtime(&t)) == 0)
+            failed = true;
+            tm = *tmp;
+#else
+            if (gmtime_r(&t, &tm) == 0)
+              failed = true;
+#endif
+
+          }
+          if (!failed)
+          {
+            const std::time_put<_CharT>& tpf = std::use_facet<std::time_put<
+                _CharT> >(loc);
+            if (pb == pe)
+            {
+              _CharT
+                  pattern[] =
+                      { '%', 'Y', '-', '%', 'm', ' ', '%', 'd', ' ', '%', '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);
+      }
+
+    } // detail
+
+    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;
+#if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+            t = detail::internal_timegm(&tm);
+#else
+            t = timegm(&tm);
+#endif
+            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 minu(0);
+            if (fz != pe)
+            {
+              if (err != std::ios_base::goodbit)
+              {
+                err |= std::ios_base::failbit;
+                goto exit;
+              }
+              _I i(is);
+              _I eof;
+              minu = 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)
+#if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+              t = detail::internal_timegm(&tm);
+#else
+              t = timegm(&tm);
+#endif
+            else
+              t = mktime(&tm);
+            tp = system_clock::from_time_t(t) - minu;
+          }
+        } catch (...)
+        {
+          err |= std::ios_base::badbit | std::ios_base::failbit;
+        }
+        exit: is.setstate(err);
+      }
+      return is;
+    }
+#endif //UTC
+  } // chrono
+
+}
+
+#endif  // BOOST_CHRONO_CHRONO_IO_HPP