passenger 5.1.12 → 5.2.0

data/src/cxx_supportlib/vendor-modified/boost/chrono/io/time_point_io.hpp

@@ -0,0 +1,1243 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2010-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).
+
+//===-------------------------- locale ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// This code was adapted by Vicente from Howard Hinnant's experimental work
+// on chrono i/o to Boost and some functions from libc++/locale to emulate the missing time_get::get()
+
+#ifndef BOOST_CHRONO_IO_TIME_POINT_IO_HPP
+#define BOOST_CHRONO_IO_TIME_POINT_IO_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>
+#include <boost/chrono/time_point.hpp>
+#include <boost/chrono/clock_string.hpp>
+#include <boost/chrono/round.hpp>
+#include <boost/chrono/detail/scan_keyword.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <cstring>
+#include <locale>
+#include <ctime>
+
+#define  BOOST_CHRONO_INTERNAL_TIMEGM \
+     ( defined BOOST_WINDOWS && ! defined(__CYGWIN__) )  \
+  || (defined(sun) || defined(__sun)) \
+  || (defined __IBMCPP__) \
+  || defined __ANDROID__ \
+  || defined __QNXNTO__ \
+  || (defined(_AIX) && defined __GNUC__)
+
+#define  BOOST_CHRONO_INTERNAL_GMTIME \
+     (defined BOOST_WINDOWS && ! defined(__CYGWIN__)) \
+  || ( (defined(sun) || defined(__sun)) && defined __GNUC__) \
+  || (defined __IBMCPP__) \
+  || defined __ANDROID__ \
+  || (defined(_AIX) && defined __GNUC__)
+
+#define  BOOST_CHRONO_USES_INTERNAL_TIME_GET
+
+namespace boost
+{
+  namespace chrono
+  {
+    typedef double fractional_seconds;
+    namespace detail
+    {
+
+
+      template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
+      struct time_get
+      {
+        std::time_get<CharT> const &that_;
+        time_get(std::time_get<CharT> const& that) : that_(that) {}
+
+        typedef std::time_get<CharT> facet;
+        typedef typename facet::iter_type iter_type;
+        typedef typename facet::char_type char_type;
+        typedef std::basic_string<char_type> string_type;
+
+        static int
+        get_up_to_n_digits(
+            InputIterator& b, InputIterator e,
+            std::ios_base::iostate& err,
+            const std::ctype<CharT>& ct,
+            int n)
+        {
+            // Precondition:  n >= 1
+            if (b == e)
+            {
+                err |= std::ios_base::eofbit | std::ios_base::failbit;
+                return 0;
+            }
+            // get first digit
+            CharT c = *b;
+            if (!ct.is(std::ctype_base::digit, c))
+            {
+                err |= std::ios_base::failbit;
+                return 0;
+            }
+            int r = ct.narrow(c, 0) - '0';
+            for (++b, --n; b != e && n > 0; ++b, --n)
+            {
+                // get next digit
+                c = *b;
+                if (!ct.is(std::ctype_base::digit, c))
+                    return r;
+                r = r * 10 + ct.narrow(c, 0) - '0';
+            }
+            if (b == e)
+                err |= std::ios_base::eofbit;
+            return r;
+        }
+
+
+        void get_day(
+            int& d,
+            iter_type& b, iter_type e,
+            std::ios_base::iostate& err,
+            const std::ctype<char_type>& ct) const
+        {
+            int t = get_up_to_n_digits(b, e, err, ct, 2);
+            if (!(err & std::ios_base::failbit) && 1 <= t && t <= 31)
+                d = t;
+            else
+                err |= std::ios_base::failbit;
+        }
+
+        void get_month(
+            int& m,
+            iter_type& b, iter_type e,
+            std::ios_base::iostate& err,
+            const std::ctype<char_type>& ct) const
+        {
+            int t = get_up_to_n_digits(b, e, err, ct, 2);
+            if (!(err & std::ios_base::failbit) && 1 <= t && t <= 12)
+                m = --t;
+            else
+                err |= std::ios_base::failbit;
+        }
+
+
+        void get_year4(int& y,
+                                                      iter_type& b, iter_type e,
+                                                      std::ios_base::iostate& err,
+                                                      const std::ctype<char_type>& ct) const
+        {
+            int t = get_up_to_n_digits(b, e, err, ct, 4);
+            if (!(err & std::ios_base::failbit))
+                y = t - 1900;
+        }
+
+        void
+        get_hour(int& h,
+                                                     iter_type& b, iter_type e,
+                                                     std::ios_base::iostate& err,
+                                                     const std::ctype<char_type>& ct) const
+        {
+            int t = get_up_to_n_digits(b, e, err, ct, 2);
+            if (!(err & std::ios_base::failbit) && t <= 23)
+                h = t;
+            else
+                err |= std::ios_base::failbit;
+        }
+
+        void
+        get_minute(int& m,
+                                                       iter_type& b, iter_type e,
+                                                       std::ios_base::iostate& err,
+                                                       const std::ctype<char_type>& ct) const
+        {
+            int t = get_up_to_n_digits(b, e, err, ct, 2);
+            if (!(err & std::ios_base::failbit) && t <= 59)
+                m = t;
+            else
+                err |= std::ios_base::failbit;
+        }
+
+        void  get_second(int& s,
+                                                       iter_type& b, iter_type e,
+                                                       std::ios_base::iostate& err,
+                                                       const std::ctype<char_type>& ct) const
+        {
+            int t = get_up_to_n_digits(b, e, err, ct, 2);
+            if (!(err & std::ios_base::failbit) && t <= 60)
+                s = t;
+            else
+                err |= std::ios_base::failbit;
+        }
+
+        void get_white_space(iter_type& b, iter_type e,
+                                                            std::ios_base::iostate& err,
+                                                            const std::ctype<char_type>& ct) const
+        {
+            for (; b != e && ct.is(std::ctype_base::space, *b); ++b)
+                ;
+            if (b == e)
+                err |= std::ios_base::eofbit;
+        }
+
+        void get_12_hour(int& h,
+                                                        iter_type& b, iter_type e,
+                                                        std::ios_base::iostate& err,
+                                                        const std::ctype<char_type>& ct) const
+        {
+            int t = get_up_to_n_digits(b, e, err, ct, 2);
+            if (!(err & std::ios_base::failbit) && 1 <= t && t <= 12)
+                h = t;
+            else
+                err |= std::ios_base::failbit;
+        }
+
+        void get_percent(iter_type& b, iter_type e,
+                                                        std::ios_base::iostate& err,
+                                                        const std::ctype<char_type>& ct) const
+        {
+            if (b == e)
+            {
+                err |= std::ios_base::eofbit | std::ios_base::failbit;
+                return;
+            }
+            if (ct.narrow(*b, 0) != '%')
+                err |= std::ios_base::failbit;
+            else if(++b == e)
+                err |= std::ios_base::eofbit;
+        }
+
+        void get_day_year_num(int& d,
+                                                             iter_type& b, iter_type e,
+                                                             std::ios_base::iostate& err,
+                                                             const std::ctype<char_type>& ct) const
+        {
+            int t = get_up_to_n_digits(b, e, err, ct, 3);
+            if (!(err & std::ios_base::failbit) && 1 <= t && t <= 366)
+                d = --t;
+            else
+                err |= std::ios_base::failbit;
+        }
+
+        void
+        get_weekday(int& w,
+                                                        iter_type& b, iter_type e,
+                                                        std::ios_base::iostate& err,
+                                                        const std::ctype<char_type>& ct) const
+        {
+            int t = get_up_to_n_digits(b, e, err, ct, 1);
+            if (!(err & std::ios_base::failbit) && t <= 6)
+                w = t;
+            else
+                err |= std::ios_base::failbit;
+        }
+#if 0
+
+        void
+        get_am_pm(int& h,
+                                                      iter_type& b, iter_type e,
+                                                      std::ios_base::iostate& err,
+                                                      const std::ctype<char_type>& ct) const
+        {
+            const string_type* ap = am_pm();
+            if (ap[0].size() + ap[1].size() == 0)
+            {
+                err |= ios_base::failbit;
+                return;
+            }
+            ptrdiff_t i = detail::scan_keyword(b, e, ap, ap+2, ct, err, false) - ap;
+            if (i == 0 && h == 12)
+                h = 0;
+            else if (i == 1 && h < 12)
+                h += 12;
+        }
+
+#endif
+
+        InputIterator get(
+            iter_type b, iter_type e,
+            std::ios_base& iob,
+            std::ios_base::iostate& err,
+            std::tm* tm,
+            char fmt, char) const
+        {
+            err = std::ios_base::goodbit;
+            const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(iob.getloc());
+
+            switch (fmt)
+            {
+            case 'a':
+            case 'A':
+              {
+                std::tm tm2;
+                std::memset(&tm2, 0, sizeof(std::tm));
+                that_.get_weekday(b, e, iob, err, &tm2);
+                //tm->tm_wday = tm2.tm_wday;
+              }
+              break;
+            case 'b':
+            case 'B':
+            case 'h':
+              {
+                std::tm tm2;
+                std::memset(&tm2, 0, sizeof(std::tm));
+                that_.get_monthname(b, e, iob, err, &tm2);
+                //tm->tm_mon = tm2.tm_mon;
+              }
+              break;
+//            case 'c':
+//              {
+//                const string_type& fm = c();
+//                b = get(b, e, iob, err, tm, fm.data(), fm.data() + fm.size());
+//              }
+//              break;
+            case 'd':
+            case 'e':
+              get_day(tm->tm_mday, b, e, err, ct);
+              break;
+            case 'D':
+              {
+                const char_type fm[] = {'%', 'm', '/', '%', 'd', '/', '%', 'y'};
+                b = get(b, e, iob, err, tm, fm, fm + sizeof(fm)/sizeof(fm[0]));
+              }
+              break;
+            case 'F':
+              {
+                const char_type fm[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd'};
+                b = get(b, e, iob, err, tm, fm, fm + sizeof(fm)/sizeof(fm[0]));
+              }
+              break;
+            case 'H':
+              get_hour(tm->tm_hour, b, e, err, ct);
+              break;
+            case 'I':
+              get_12_hour(tm->tm_hour, b, e, err, ct);
+              break;
+            case 'j':
+              get_day_year_num(tm->tm_yday, b, e, err, ct);
+              break;
+            case 'm':
+              get_month(tm->tm_mon, b, e, err, ct);
+              break;
+            case 'M':
+              get_minute(tm->tm_min, b, e, err, ct);
+              break;
+            case 'n':
+            case 't':
+              get_white_space(b, e, err, ct);
+              break;
+//            case 'p':
+//              get_am_pm(tm->tm_hour, b, e, err, ct);
+//              break;
+            case 'r':
+              {
+                const char_type fm[] = {'%', 'I', ':', '%', 'M', ':', '%', 'S', ' ', '%', 'p'};
+                b = get(b, e, iob, err, tm, fm, fm + sizeof(fm)/sizeof(fm[0]));
+              }
+              break;
+            case 'R':
+              {
+                const char_type fm[] = {'%', 'H', ':', '%', 'M'};
+                b = get(b, e, iob, err, tm, fm, fm + sizeof(fm)/sizeof(fm[0]));
+              }
+              break;
+            case 'S':
+              get_second(tm->tm_sec, b, e, err, ct);
+              break;
+            case 'T':
+              {
+                const char_type fm[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
+                b = get(b, e, iob, err, tm, fm, fm + sizeof(fm)/sizeof(fm[0]));
+              }
+              break;
+            case 'w':
+              {
+                get_weekday(tm->tm_wday, b, e, err, ct);
+              }
+              break;
+            case 'x':
+              return that_.get_date(b, e, iob, err, tm);
+//            case 'X':
+//              return that_.get_time(b, e, iob, err, tm);
+//              {
+//                const string_type& fm = X();
+//                b = that_.get(b, e, iob, err, tm, fm.data(), fm.data() + fm.size());
+//              }
+//              break;
+//            case 'y':
+//              get_year(tm->tm_year, b, e, err, ct);
+                break;
+            case 'Y':
+              get_year4(tm->tm_year, b, e, err, ct);
+              break;
+            case '%':
+              get_percent(b, e, err, ct);
+              break;
+            default:
+                err |= std::ios_base::failbit;
+            }
+            return b;
+        }
+
+
+        InputIterator get(
+          iter_type b, iter_type e,
+          std::ios_base& iob,
+          std::ios_base::iostate& err, std::tm* tm,
+          const char_type* fmtb, const char_type* fmte) const
+        {
+          const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(iob.getloc());
+          err = std::ios_base::goodbit;
+          while (fmtb != fmte && err == std::ios_base::goodbit)
+          {
+              if (b == e)
+              {
+                  err = std::ios_base::failbit;
+                  break;
+              }
+              if (ct.narrow(*fmtb, 0) == '%')
+              {
+                  if (++fmtb == fmte)
+                  {
+                      err = std::ios_base::failbit;
+                      break;
+                  }
+                  char cmd = ct.narrow(*fmtb, 0);
+                  char opt = '\0';
+                  if (cmd == 'E' || cmd == '0')
+                  {
+                      if (++fmtb == fmte)
+                      {
+                          err = std::ios_base::failbit;
+                          break;
+                      }
+                      opt = cmd;
+                      cmd = ct.narrow(*fmtb, 0);
+                  }
+                  b = get(b, e, iob, err, tm, cmd, opt);
+                  ++fmtb;
+              }
+              else if (ct.is(std::ctype_base::space, *fmtb))
+              {
+                  for (++fmtb; fmtb != fmte && ct.is(std::ctype_base::space, *fmtb); ++fmtb)
+                      ;
+                  for (        ;    b != e    && ct.is(std::ctype_base::space, *b);    ++b)
+                      ;
+              }
+              else if (ct.toupper(*b) == ct.toupper(*fmtb))
+              {
+                  ++b;
+                  ++fmtb;
+              }
+              else
+                  err = std::ios_base::failbit;
+          }
+          if (b == e)
+              err |= std::ios_base::eofbit;
+          return b;
+        }
+
+      };
+
+
+      template <class CharT>
+      class time_manip: public manip<time_manip<CharT> >
+      {
+        std::basic_string<CharT> fmt_;
+        timezone tz_;
+      public:
+
+        time_manip(timezone tz, std::basic_string<CharT> fmt)
+        // todo move semantics
+        :
+          fmt_(fmt), tz_(tz)
+        {
+        }
+
+        /**
+         * Change the timezone and time format ios state;
+         */
+        void operator()(std::ios_base &ios) const
+        {
+          set_time_fmt<CharT> (ios, fmt_);
+          set_timezone(ios, tz_);
+        }
+      };
+
+      class time_man: public manip<time_man>
+      {
+        timezone tz_;
+      public:
+
+        time_man(timezone tz)
+        // todo move semantics
+        :
+          tz_(tz)
+        {
+        }
+
+        /**
+         * Change the timezone and time format ios state;
+         */
+        void operator()(std::ios_base &ios) const
+        {
+          //set_time_fmt<typename out_stream::char_type>(ios, "");
+          set_timezone(ios, tz_);
+        }
+      };
+
+    }
+
+    template <class CharT>
+    inline detail::time_manip<CharT> time_fmt(timezone tz, const CharT* fmt)
+    {
+      return detail::time_manip<CharT>(tz, fmt);
+    }
+
+    template <class CharT>
+    inline detail::time_manip<CharT> time_fmt(timezone tz, std::basic_string<CharT> fmt)
+    {
+      // todo move semantics
+      return detail::time_manip<CharT>(tz, fmt);
+    }
+
+    inline detail::time_man time_fmt(timezone f)
+    {
+      return detail::time_man(f);
+    }
+
+    /**
+     * time_fmt_io_saver 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 time_fmt_io_saver
+    {
+
+      //! the type of the state to restore
+      //typedef std::basic_ostream<CharT, Traits> state_type;
+      typedef std::ios_base state_type;
+
+      //! the type of aspect to save
+      typedef std::basic_string<CharT, Traits> aspect_type;
+
+      /**
+       * Explicit construction from an i/o stream.
+       *
+       * Store a reference to the i/o stream and the value of the associated @c time format .
+       */
+      explicit time_fmt_io_saver(state_type &s) :
+        s_save_(s), a_save_(get_time_fmt<CharT>(s_save_))
+      {
+      }
+
+      /**
+       * Construction from an i/o stream and a @c time format  to restore.
+       *
+       * Stores a reference to the i/o stream and the value @c new_value to restore given as parameter.
+       */
+      time_fmt_io_saver(state_type &s, aspect_type new_value) :
+        s_save_(s), a_save_(get_time_fmt<CharT>(s_save_))
+      {
+        set_time_fmt(s_save_, new_value);
+      }
+
+      /**
+       * Destructor.
+       *
+       * Restores the i/o stream with the format to be restored.
+       */
+      ~time_fmt_io_saver()
+      {
+        this->restore();
+      }
+
+      /**
+       * Restores the i/o stream with the time format to be restored.
+       */
+      void restore()
+      {
+        set_time_fmt(s_save_, a_save_);
+      }
+    private:
+      state_type& s_save_;
+      aspect_type a_save_;
+    };
+
+    /**
+     * timezone_io_saver i/o saver.
+     *
+     * See Boost.IO i/o state savers for a motivating compression.
+     */
+    struct timezone_io_saver
+    {
+
+      //! the type of the state to restore
+      typedef std::ios_base state_type;
+      //! the type of aspect to save
+      typedef timezone aspect_type;
+
+      /**
+       * Explicit construction from an i/o stream.
+       *
+       * Store a reference to the i/o stream and the value of the associated @c timezone.
+       */
+      explicit timezone_io_saver(state_type &s) :
+        s_save_(s), a_save_(get_timezone(s_save_))
+      {
+      }
+
+      /**
+       * Construction from an i/o stream and a @c timezone to restore.
+       *
+       * Stores a reference to the i/o stream and the value @c new_value to restore given as parameter.
+       */
+      timezone_io_saver(state_type &s, aspect_type new_value) :
+        s_save_(s), a_save_(get_timezone(s_save_))
+      {
+        set_timezone(s_save_, new_value);
+      }
+
+      /**
+       * Destructor.
+       *
+       * Restores the i/o stream with the format to be restored.
+       */
+      ~timezone_io_saver()
+      {
+        this->restore();
+      }
+
+      /**
+       * Restores the i/o stream with the timezone to be restored.
+       */
+      void restore()
+      {
+        set_timezone(s_save_, a_save_);
+      }
+    private:
+      timezone_io_saver& operator=(timezone_io_saver const& rhs) ;
+
+      state_type& s_save_;
+      aspect_type a_save_;
+    };
+
+    /**
+     *
+     * @param os
+     * @param tp
+     * @Effects Behaves as a formatted output function. After constructing a @c sentry object, if the @ sentry
+     * converts to true, calls to @c facet.put(os,os,os.fill(),tp) where @c facet is the @c time_point_put<CharT>
+     * facet associated to @c os or a new created instance of the default @c time_point_put<CharT> facet.
+     * @return @c os.
+     */
+    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)
+    {
+
+      bool failed = false;
+      BOOST_TRY
+      {
+        std::ios_base::iostate err = std::ios_base::goodbit;
+        BOOST_TRY
+        {
+          typename std::basic_ostream<CharT, Traits>::sentry opfx(os);
+          if (bool(opfx))
+          {
+            if (!std::has_facet<time_point_put<CharT> >(os.getloc()))
+            {
+              if (time_point_put<CharT> ().put(os, os, os.fill(), tp) .failed())
+              {
+                err = std::ios_base::badbit;
+              }
+            }
+            else
+            {
+              if (std::use_facet<time_point_put<CharT> >(os.getloc()) .put(os, os, os.fill(), tp).failed())
+              {
+                err = std::ios_base::badbit;
+              }
+            }
+            os.width(0);
+          }
+        }
+        BOOST_CATCH (...)
+        {
+          bool flag = false;
+          BOOST_TRY
+          {
+            os.setstate(std::ios_base::failbit);
+          }
+          BOOST_CATCH (std::ios_base::failure )
+          {
+            flag = true;
+          }
+          BOOST_CATCH_END
+          if (flag) throw;
+        }
+        BOOST_CATCH_END
+        if (err) os.setstate(err);
+        return os;
+      }
+      BOOST_CATCH (...)
+      {
+        failed = true;
+      }
+      BOOST_CATCH_END
+      if (failed) os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+      return os;
+    }
+
+    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)
+    {
+      std::ios_base::iostate err = std::ios_base::goodbit;
+
+      BOOST_TRY
+      {
+        typename std::basic_istream<CharT, Traits>::sentry ipfx(is);
+        if (bool(ipfx))
+        {
+          if (!std::has_facet<time_point_get<CharT> >(is.getloc()))
+          {
+            time_point_get<CharT> ().get(is, std::istreambuf_iterator<CharT, Traits>(), is, err, tp);
+          }
+          else
+          {
+            std::use_facet<time_point_get<CharT> >(is.getloc()).get(is, std::istreambuf_iterator<CharT, Traits>(), is,
+                err, tp);
+          }
+        }
+      }
+      BOOST_CATCH (...)
+      {
+        bool flag = false;
+        BOOST_TRY
+        {
+          is.setstate(std::ios_base::failbit);
+        }
+        BOOST_CATCH (std::ios_base::failure )
+        {
+          flag = true;
+        }
+        BOOST_CATCH_END
+        if (flag) throw;
+      }
+      BOOST_CATCH_END
+      if (err) is.setstate(err);
+      return is;
+    }
+
+
+    namespace detail
+    {
+
+//#if BOOST_CHRONO_INTERNAL_TIMEGM
+
+    inline int32_t is_leap(int32_t year)
+    {
+      if(year % 400 == 0)
+      return 1;
+      if(year % 100 == 0)
+      return 0;
+      if(year % 4 == 0)
+      return 1;
+      return 0;
+    }
+    inline int32_t days_from_0(int32_t year)
+    {
+      year--;
+      return 365 * year + (year / 400) - (year/100) + (year / 4);
+    }
+    inline int32_t days_from_1970(int32_t year)
+    {
+      static const int days_from_0_to_1970 = days_from_0(1970);
+      return days_from_0(year) - days_from_0_to_1970;
+    }
+    inline int32_t days_from_1jan(int32_t year,int32_t month,int32_t day)
+    {
+      static const int32_t 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;
+    }
+
+    inline 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
+
+    /**
+    * from_ymd could be made more efficient by using a table
+    * day_count_table indexed by the y%400.
+    * This table could contain the day_count
+    * by*365 + by/4 - by/100 + by/400
+    *
+    * from_ymd = (by/400)*days_by_400_years+day_count_table[by%400] +
+    * days_in_year_before[is_leap_table[by%400]][m-1] + d;
+    */
+    inline unsigned days_before_years(int32_t y)
+   {
+     return y * 365 + y / 4 - y / 100 + y / 400;
+   }
+
+    // Returns year/month/day triple in civil calendar
+    // Preconditions:  z is number of days since 1970-01-01 and is in the range:
+    //                   [numeric_limits<Int>::min(), numeric_limits<Int>::max()-719468].
+    template <class Int>
+    //constexpr
+    void
+    inline civil_from_days(Int z, Int& y, unsigned& m, unsigned& d) BOOST_NOEXCEPT
+    {
+        BOOST_STATIC_ASSERT_MSG(std::numeric_limits<unsigned>::digits >= 18,
+                 "This algorithm has not been ported to a 16 bit unsigned integer");
+        BOOST_STATIC_ASSERT_MSG(std::numeric_limits<Int>::digits >= 20,
+                 "This algorithm has not been ported to a 16 bit signed integer");
+        z += 719468;
+        const Int era = (z >= 0 ? z : z - 146096) / 146097;
+        const unsigned doe = static_cast<unsigned>(z - era * 146097);          // [0, 146096]
+        const unsigned yoe = (doe - doe/1460 + doe/36524 - doe/146096) / 365;  // [0, 399]
+        y = static_cast<Int>(yoe) + era * 400;
+        const unsigned doy = doe - (365*yoe + yoe/4 - yoe/100);                // [0, 365]
+        const unsigned mp = (5*doy + 2)/153;                                   // [0, 11]
+        d = doy - (153*mp+2)/5 + 1;                             // [1, 31]
+        m = mp + (mp < 10 ? 3 : -9);                            // [1, 12]
+        y += (m <= 2);
+        --m;
+    }
+   inline std::tm * internal_gmtime(std::time_t const* t, std::tm *tm)
+   {
+      if (t==0) return 0;
+      if (tm==0) return 0;
+
+#if 0
+      static  const unsigned char
+        day_of_year_month[2][366] =
+           {
+           { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12 },
+
+           { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12
+
+           } };
+
+      static const int32_t days_in_year_before[2][13] =
+     {
+       { -1, 30, 58, 89, 119, 150, 180, 211, 242, 272, 303, 333, 364 },
+       { -1, 30, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 }
+     };
+#endif
+
+     const time_t seconds_in_day = 3600 * 24;
+     int32_t days_since_epoch = static_cast<int32_t>(*t / seconds_in_day);
+     int32_t hms = static_cast<int32_t>(*t - seconds_in_day*days_since_epoch);
+     if (hms < 0) {
+       days_since_epoch-=1;
+       hms = seconds_in_day+hms;
+     }
+
+#if 0
+     int32_t x = days_since_epoch;
+     int32_t y = static_cast<int32_t> (static_cast<long long> (x + 2) * 400
+           / 146097);
+       const int32_t ym1 = y - 1;
+       int32_t doy = x - days_before_years(y);
+       const int32_t doy1 = x - days_before_years(ym1);
+       const int32_t N = std::numeric_limits<int>::digits - 1;
+       const int32_t mask1 = doy >> N; // arithmetic rshift - not portable - but nearly universal
+       const int32_t mask0 = ~mask1;
+       doy = (doy & mask0) | (doy1 & mask1);
+       y = (y & mask0) | (ym1 & mask1);
+       //y -= 32767 + 2;
+       y += 70;
+       tm->tm_year=y;
+       const int32_t leap = is_leap(y);
+       tm->tm_mon = day_of_year_month[leap][doy]-1;
+       tm->tm_mday = doy - days_in_year_before[leap][tm->tm_mon] ;
+#else
+       int32_t y;
+       unsigned m, d;
+       civil_from_days(days_since_epoch, y, m, d);
+       tm->tm_year=y-1900; tm->tm_mon=m; tm->tm_mday=d;
+#endif
+
+     tm->tm_hour = hms / 3600;
+     const int ms = hms % 3600;
+     tm->tm_min = ms / 60;
+     tm->tm_sec = ms % 60;
+
+     tm->tm_isdst = -1;
+     (void)mktime(tm);
+     return tm;
+   }
+
+    } // detail
+#ifndef BOOST_CHRONO_NO_UTC_TIMEPOINT
+
+#if defined BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
+
+    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 (bool(ok))
+      {
+        bool failed = false;
+        BOOST_TRY
+        {
+          const CharT* pb = 0; //nullptr;
+          const CharT* pe = pb;
+          std::basic_string<CharT> fmt = get_time_fmt<CharT> (os);
+          pb = fmt.data();
+          pe = pb + fmt.size();
+
+          timezone tz = get_timezone(os);
+          std::locale loc = os.getloc();
+          time_t t = system_clock::to_time_t(time_point_cast<system_clock::duration>(tp));
+          std::tm tm;
+          std::memset(&tm, 0, sizeof(std::tm));
+          if (tz == timezone::local)
+          {
+#if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+            std::tm *tmp = 0;
+            if ((tmp=localtime(&t)) == 0)
+              failed = true;
+            else
+              tm =*tmp;
+#else
+            if (localtime_r(&t, &tm) == 0) failed = true;
+#endif
+          }
+          else
+          {
+#if BOOST_CHRONO_INTERNAL_GMTIME
+            if (detail::internal_gmtime(&t, &tm) == 0) failed = true;
+
+#elif defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+            std::tm *tmp = 0;
+            if((tmp = gmtime(&t)) == 0)
+              failed = true;
+            else
+              tm = *tmp;
+#else
+            if (gmtime_r(&t, &tm) == 0) failed = true;
+            tm.tm_isdst = -1;
+            (void)mktime(&tm);
+
+#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<fractional_seconds> d = tp - system_clock::from_time_t(t) + seconds(tm.tm_sec);
+                if (d.count() < 10) os << CharT('0');
+                //if (! os.good()) {
+                //  throw "exception";
+                //}
+                std::ios::fmtflags flgs = os.flags();
+                os.setf(std::ios::fixed, std::ios::floatfield);
+                //if (! os.good()) {
+                //throw "exception";
+                //}
+                os.precision(9);
+                os << d.count();
+                //if (! os.good()) {
+                //throw "exception";
+                //}
+                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();
+            }
+          }
+        }
+        BOOST_CATCH (...)
+        {
+          failed = true;
+        }
+        BOOST_CATCH_END
+        if (failed)
+        {
+          os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+        }
+      }
+      return os;
+    }
+#endif
+
+    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
+
+#if defined BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
+
+    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 (bool(ok))
+      {
+        std::ios_base::iostate err = std::ios_base::goodbit;
+        BOOST_TRY
+        {
+          const CharT* pb = 0; //nullptr;
+          const CharT* pe = pb;
+          std::basic_string<CharT> fmt = get_time_fmt<CharT> (is);
+          pb = fmt.data();
+          pe = pb + fmt.size();
+
+          timezone tz = get_timezone(is);
+          std::locale loc = is.getloc();
+          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}
+          std::memset(&tm, 0, sizeof(std::tm));
+
+          typedef std::istreambuf_iterator<CharT, Traits> It;
+          if (pb == pe)
+          {
+            CharT pattern[] =
+            { '%', 'Y', '-', '%', 'm', '-', '%', 'd', ' ', '%', 'H', ':', '%', 'M', ':' };
+            pb = pattern;
+            pe = pb + sizeof (pattern) / sizeof(CharT);
+
+#if defined BOOST_CHRONO_USES_INTERNAL_TIME_GET
+            const detail::time_get<CharT>& dtg(tg);
+            dtg.get(is, 0, is, err, &tm, pb, pe);
+#else
+            tg.get(is, 0, is, err, &tm, pb, pe);
+#endif
+            if (err & std::ios_base::failbit) goto exit;
+            fractional_seconds sec;
+            CharT c = CharT();
+            std::ios::fmtflags flgs = is.flags();
+            is.setf(std::ios::fixed, std::ios::floatfield);
+            is.precision(9);
+            is >> sec;
+            is.flags(flgs);
+            if (is.fail())
+            {
+              err |= std::ios_base::failbit;
+              goto exit;
+            }
+            It i(is);
+            It 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 BOOST_CHRONO_INTERNAL_TIMEGM
+            t = detail::internal_timegm(&tm);
+#else
+            t = timegm(&tm);
+#endif
+            tp = time_point_cast<Duration>(
+                system_clock::from_time_t(t) - min + round<system_clock::duration> (duration<fractional_seconds> (sec))
+                );
+          }
+          else
+          {
+            const CharT z[2] =
+            { '%', 'z' };
+            const CharT* fz = std::search(pb, pe, z, z + 2);
+#if defined BOOST_CHRONO_USES_INTERNAL_TIME_GET
+            const detail::time_get<CharT>& dtg(tg);
+            dtg.get(is, 0, is, err, &tm, pb, fz);
+#else
+            tg.get(is, 0, is, err, &tm, pb, fz);
+#endif
+            minutes minu(0);
+            if (fz != pe)
+            {
+              if (err != std::ios_base::goodbit)
+              {
+                err |= std::ios_base::failbit;
+                goto exit;
+              }
+              It i(is);
+              It eof;
+              minu = detail::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;
+                }
+#if defined BOOST_CHRONO_USES_INTERNAL_TIME_GET
+                const detail::time_get<CharT>& dtg(tg);
+                dtg.get(is, 0, is, err, &tm, fz + 2, pe);
+#else
+                tg.get(is, 0, is, err, &tm, fz + 2, pe);
+#endif
+                if (err & std::ios_base::failbit) goto exit;
+              }
+            }
+            tm.tm_isdst = -1;
+            time_t t;
+            if (tz == timezone::utc || fz != pe)
+            {
+#if BOOST_CHRONO_INTERNAL_TIMEGM
+              t = detail::internal_timegm(&tm);
+#else
+              t = timegm(&tm);
+#endif
+            }
+            else
+            {
+              t = mktime(&tm);
+            }
+            tp = time_point_cast<Duration>(
+                system_clock::from_time_t(t) - minu
+                );
+          }
+        }
+        BOOST_CATCH (...)
+        {
+          err |= std::ios_base::badbit | std::ios_base::failbit;
+        }
+        BOOST_CATCH_END
+        exit: is.setstate(err);
+      }
+      return is;
+    }
+
+#endif
+#endif //UTC
+  } // chrono
+
+}
+
+#endif  // header