boost/chrono/io/time_point_io.hpp
// (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> #if ( defined BOOST_WINDOWS && ! defined(__CYGWIN__) ) \ || (defined(sun) || defined(__sun)) \ || (defined __IBMCPP__) \ || defined __ANDROID__ \ || defined __QNXNTO__ \ || (defined(_AIX) && defined __GNUC__) #define BOOST_CHRONO_INTERNAL_TIMEGM #endif #if (defined BOOST_WINDOWS && ! defined(__CYGWIN__)) \ || ( (defined(sun) || defined(__sun)) && defined __GNUC__) \ || (defined __IBMCPP__) \ || defined __ANDROID__ \ || (defined(_AIX) && defined __GNUC__) #define BOOST_CHRONO_INTERNAL_GMTIME #endif #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 defined 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 int32_t 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__) #if BOOST_MSVC < 1400 // localtime_s doesn't exist in vc7.1 std::tm *tmp = 0; if ((tmp=localtime(&t)) == 0) failed = true; else tm =*tmp; # else if (localtime_s(&tm, &t) != 0) failed = true; # endif #else if (localtime_r(&t, &tm) == 0) failed = true; #endif } else { #if defined 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 defined 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 defined 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