|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r81056 - in branches/release: boost/chrono boost/chrono/detail boost/chrono/io boost/chrono/io_v1 libs/chrono/doc libs/chrono/src libs/chrono/test/duration libs/chrono/test/io libs/chrono/test/time_point libs/chrono/test/traits
From: vicente.botet_at_[hidden]
Date: 2012-10-24 20:07:53
Author: viboes
Date: 2012-10-24 20:07:52 EDT (Wed, 24 Oct 2012)
New Revision: 81056
URL: http://svn.boost.org/trac/boost/changeset/81056
Log:
Chrono: merge 81040-81041,81044-81045
Properties modified:
branches/release/boost/chrono/detail/ (props changed)
branches/release/boost/chrono/io/ (props changed)
branches/release/boost/chrono/io_v1/ (props changed)
branches/release/libs/chrono/src/ (props changed)
branches/release/libs/chrono/test/duration/ (props changed)
branches/release/libs/chrono/test/io/ (props changed)
branches/release/libs/chrono/test/time_point/ (props changed)
branches/release/libs/chrono/test/traits/ (props changed)
Text files modified:
branches/release/boost/chrono/config.hpp | 7
branches/release/boost/chrono/io/time_point_io.hpp | 369 +++++++++++++++++++++++++++++++++++++++
branches/release/libs/chrono/doc/chrono.qbk | 109 ++++++++++
branches/release/libs/chrono/test/io/time_point_input.cpp | 58 +++++
branches/release/libs/chrono/test/io/time_point_output.cpp | 91 +++++++++
5 files changed, 607 insertions(+), 27 deletions(-)
Modified: branches/release/boost/chrono/config.hpp
==============================================================================
--- branches/release/boost/chrono/config.hpp (original)
+++ branches/release/boost/chrono/config.hpp 2012-10-24 20:07:52 EDT (Wed, 24 Oct 2012)
@@ -25,6 +25,13 @@
#define BOOST_USE_WINDOWS_H
#endif
+#if ! defined BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT \
+ && ! defined BOOST_CHRONO_DONT_PROVIDE_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
+
+# define BOOST_CHRONO_DONT_PROVIDE_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
+
+#endif
+
// BOOST_CHRONO_POSIX_API, BOOST_CHRONO_MAC_API, or BOOST_CHRONO_WINDOWS_API
// can be defined by the user to specify which API should be used
Modified: branches/release/boost/chrono/io/time_point_io.hpp
==============================================================================
--- branches/release/boost/chrono/io/time_point_io.hpp (original)
+++ branches/release/boost/chrono/io/time_point_io.hpp 2012-10-24 20:07:52 EDT (Wed, 24 Oct 2012)
@@ -3,9 +3,18 @@
// 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
+// 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
@@ -23,6 +32,11 @@
#include <locale>
#include <string.h>
+#define BOOST_CHRONO_INTERNAL_TIMEGM defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+//#define BOOST_CHRONO_INTERNAL_TIMEGM 1
+
+#define BOOST_CHRONO_USES_INTERNAL_TIME_GET
+
namespace boost
{
namespace chrono
@@ -30,6 +44,309 @@
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) - 1;
+ if (!(err & std::ios_base::failbit) && t <= 11)
+ 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;
+ }
+
+
+
+ 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':
+// that_.get_weekdayname(tm->tm_wday, b, e, err, ct);
+// break;
+// case 'b':
+// case 'B':
+// case 'h':
+// that_.get_monthname(tm->tm_mon, b, e, err, ct);
+// break;
+// case 'c':
+// {
+// const string_type& fm = this->c();
+// b = that_.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);
+ //std::cerr << "tm_mday= "<< tm->tm_mday << std::endl;
+
+ break;
+// case 'D':
+// {
+// const char_type fm[] = {'%', 'm', '/', '%', 'd', '/', '%', 'y'};
+// b = that_.get(b, e, iob, err, tm, fm, fm + sizeof(fm)/sizeof(fm[0]));
+// }
+// break;
+// case 'F':
+// {
+// const char_type fm[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd'};
+// b = that_.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);
+ //std::cerr << "tm_hour= "<< tm->tm_hour << std::endl;
+ break;
+// case 'I':
+// that_.get_12_hour(tm->tm_hour, b, e, err, ct);
+// break;
+// case 'j':
+// that_.get_day_year_num(tm->tm_yday, b, e, err, ct);
+// break;
+ case 'm':
+ get_month(tm->tm_mon, b, e, err, ct);
+ //std::cerr << "tm_mon= "<< tm->tm_mon << std::endl;
+ break;
+ case 'M':
+ get_minute(tm->tm_min, b, e, err, ct);
+ //std::cerr << "tm_min= "<< tm->tm_min << std::endl;
+ break;
+// case 'n':
+// case 't':
+// that_.get_white_space(b, e, err, ct);
+// break;
+// case 'p':
+// that_.get_am_pm(tm->tm_hour, b, e, err, ct);
+// break;
+// case 'r':
+// {
+// const char_type fm[] = {'%', 'I', ':', '%', 'M', ':', '%', 'S', ' ', '%', 'p'};
+// b = that_.get(b, e, iob, err, tm, fm, fm + sizeof(fm)/sizeof(fm[0]));
+// }
+// break;
+// case 'R':
+// {
+// const char_type fm[] = {'%', 'H', ':', '%', 'M'};
+// b = that_.get(b, e, iob, err, tm, fm, fm + sizeof(fm)/sizeof(fm[0]));
+// }
+// break;
+// case 'S':
+// that_.get_second(tm->tm_sec, b, e, err, ct);
+// break;
+// case 'T':
+// {
+// const char_type fm[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
+// b = that_.get(b, e, iob, err, tm, fm, fm + sizeof(fm)/sizeof(fm[0]));
+// }
+// break;
+// case 'w':
+// that_.get_weekday(tm->tm_wday, b, e, err, ct);
+// break;
+// case 'x':
+// return that_.get_date(b, e, iob, err, tm);
+// case 'X':
+// {
+// const string_type& fm = this->X();
+// b = that_.get(b, e, iob, err, tm, fm.data(), fm.data() + fm.size());
+// }
+// break;
+// case 'y':
+// that_.get_year(tm->tm_year, b, e, err, ct);
+ break;
+ case 'Y':
+ get_year4(tm->tm_year, b, e, err, ct);
+ //std::cerr << "tm_year= "<< tm->tm_year << std::endl;
+ break;
+// case '%':
+// that_.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> >
{
@@ -338,7 +655,7 @@
namespace detail
{
-#if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+#if BOOST_CHRONO_INTERNAL_TIMEGM
int is_leap(int year)
{
if(year % 400 == 0)
@@ -397,6 +714,7 @@
#endif
} // detail
+#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)
@@ -420,7 +738,7 @@
timezone tz = get_timezone(os);
std::locale loc = os.getloc();
- time_t t = system_clock::to_time_t(tp);
+ time_t t = system_clock::to_time_t(time_point_cast<system_clock::duration>(tp));
std::tm tm;
if (tz == timezone::local)
{
@@ -530,6 +848,7 @@
//std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
return os;
}
+#endif
namespace detail
{
@@ -578,17 +897,22 @@
}
min = min * 10 + cn - '0';
}
- if (++b == e) err |= std::ios_base::eofbit;
+ 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)
@@ -619,7 +943,12 @@
{ '%', '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;
double sec;
CharT c = CharT();
@@ -629,6 +958,7 @@
err |= std::ios_base::failbit;
goto exit;
}
+ //std::cerr << "sec= "<< sec << std::endl;
It i(is);
It eof;
c = *i;
@@ -638,21 +968,30 @@
goto exit;
}
minutes min = detail::extract_z(i, eof, err, ct);
+ //std::cerr << "min= "<< min.count() << std::endl;
+
if (err & std::ios_base::failbit) goto exit;
time_t t;
-#if defined BOOST_WINDOWS && ! defined(__CYGWIN__)
+#if BOOST_CHRONO_INTERNAL_TIMEGM
t = detail::internal_timegm(&tm);
#else
t = timegm(&tm);
#endif
- tp = system_clock::from_time_t(t) - min + round<microseconds> (duration<double> (sec));
+ tp = time_point_cast<Duration>(
+ 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);
+#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)
{
@@ -663,7 +1002,7 @@
}
It i(is);
It eof;
- minu = extract_z(i, eof, err, ct);
+ minu = detail::extract_z(i, eof, err, ct);
if (err & std::ios_base::failbit) goto exit;
if (fz + 2 != pe)
{
@@ -672,21 +1011,32 @@
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_WINDOWS && ! defined(__CYGWIN__)
+ {
+#if BOOST_CHRONO_INTERNAL_TIMEGM
t = detail::internal_timegm(&tm);
#else
t = timegm(&tm);
#endif
+ }
else
+ {
t = mktime(&tm);
- tp = system_clock::from_time_t(t) - minu;
+ }
+ tp = time_point_cast<Duration>(
+ system_clock::from_time_t(t) - minu
+ );
}
}
#ifndef BOOST_NO_EXCEPTIONS
@@ -699,6 +1049,7 @@
}
return is;
}
+#endif
#endif //UTC
} // chrono
Modified: branches/release/libs/chrono/doc/chrono.qbk
==============================================================================
--- branches/release/libs/chrono/doc/chrono.qbk (original)
+++ branches/release/libs/chrono/doc/chrono.qbk 2012-10-24 20:07:52 EDT (Wed, 24 Oct 2012)
@@ -636,10 +636,6 @@
* MSVC 10.0
-Cygwin 1.7 with
-
-* GCC 4.3.4
-
MinGW with
* GCC 4.5.0
@@ -649,12 +645,36 @@
* GCC 4.6.0
* GCC 4.6.0 -std=c++0x
+Ubuntu with
+* GCC 4.4.6
+* GCC 4.4.6 -std=c++0x
+* GCC 4.5.4
+* GCC 4.5.4 -std=c++0x
+* GCC 4.6.1
+* GCC 4.6.1 -std=c++0x
+* Intel 12.1.3
+* Intel 12.1.3 -std=c++0x
+
OsX with
* GCC 4.1.2
+* GCC 4.6.2
+* GCC 4.6.2 -std=c++0x
+* GCC 4.7.0
+* GCC 4.7.0 -std=c++0x
+* GCC 4.7.1
+* GCC 4.7.1 -std=c++0x
* clang 1.6
* clang 2.9
* clang 2.9 -std=c++0x
+* clang 3.0
+* clang 3.0 -std=c++0x
+* clang 3.1
+* clang 3.1 -std=c++0x
+* clang 3.1 -std=c++0x -stdlib=libc++
+* clang 3.2
+* clang 3.2 -std=c++11
+* clang 3.2 -std=c++11 -stdlib=libc++
The committed code is tested with much more compilers. There are two compilers (VACPP and Borland) that don't provide the needed features.
@@ -1397,7 +1417,21 @@
[endsect]
-[section:system_clock_time_point_io system_clock::time_point]
+[section:system_clock_time_point_io `system_clock::time_point`]
+
+[warning
+
+This feature has been disable defining `BOOST_CHRONO_DONT_PROVIDE_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT` until a fix for the following ticket is found:
+
+- [@http://svn.boost.org/trac/boost/ticket/7547 #7547] time_point<system_clock> input version 2 fails to compile
+
+- [@http://svn.boost.org/trac/boost/ticket/7546 #7546] time_point<system_clock> output version 2 fails to compile
+
+In this case the io operators behave like any time_point as defined in next section.
+
+In order to enable this features on compilers working with, you will need to define `BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT`.
+
+]
__system_clock is special. It is the only clock that has conversions between its `time_point` and `time_t`. C subsequently relates time_t to the [@http://en.wikipedia.org/wiki/Gregorian_calendar Gregorian calendar] via `ctime`, `gmtime`, `localtime`, and `strftime`. Neither C, nor POSIX relate `time_t` to any calendar other than the [@http://en.wikipedia.org/wiki/Gregorian_calendar Gregorian calendar]. ISO 8601 is specified only in terms of the [@http://en.wikipedia.org/wiki/Gregorian_calendar Gregorian calendar].
@@ -2562,6 +2596,26 @@
These deprecated features will be only available until boost 1.58, that is you have 1 year and a half to move to the new features.
[endsect]
+
+
+[section:system_clock_time_point time_point<system_clock,D> specialization limitation]
+
+[warning
+
+The time_point<system_clock,D> formatter/parser specializations don't work yet. It has been disable defining `BOOST_CHRONO_DONT_PROVIDE_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT` until a fix for the following ticket is found:
+
+- [@http://svn.boost.org/trac/boost/ticket/7547 #7547] time_point<system_clock> input version 2 fails to compile
+
+- [@http://svn.boost.org/trac/boost/ticket/7546 #7546] time_point<system_clock> output version 2 fails to compile
+
+In this case the io operators behave like any time_point as if the specialization was removed.
+
+In order to enable this features on compilers working with, you will need to define `BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT`.
+
+]
+
+[endsect]
+
[section:version Version]
`BOOST_CHRONO_VERSION` defines the Boost.Chrono version.
@@ -6284,6 +6338,8 @@
// system_clock I/O
+ #if defined BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
+
template <class CharT, class Traits, class __Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os,
@@ -6293,7 +6349,8 @@
basic_istream<CharT, Traits>&
operator>>(basic_istream<CharT, Traits>& is,
time_point<system_clock, __Duration>& tp);
-
+ #endif
+
// Other Clocks I/O
template <class CharT, class Traits, class __Clock, class __Duration>
@@ -6309,6 +6366,8 @@
}
}
+
+
[section:manip I/O Manipulators]
[section:time_fmt1 Non Member Function `time_fmt(__timezone)` ]
@@ -6340,6 +6399,21 @@
[section:streams I/O Streams Operations]
[section:system_clock `system_clock`]
+
+[warning
+
+The time_point<system_clock,D> formatter/parser specializations don't work yet. It has been disable defining `BOOST_CHRONO_DONT_PROVIDE_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT` until a fix for the following ticket is found:
+
+- [@http://svn.boost.org/trac/boost/ticket/7547 #7547] time_point<system_clock> input version 2 fails to compile
+
+- [@http://svn.boost.org/trac/boost/ticket/7546 #7546] time_point<system_clock> output version 2 fails to compile
+
+In this case the io operators behave like any time_point as if the specialization was removed.
+
+In order to enable this features on compilers working with, you will need to define `BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT`.
+
+]
+
[section:op_out Non Member Function `operator<<()`]
template <class CharT, class Traits, class __Duration>
@@ -7253,7 +7327,7 @@
[//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////]
-[section [*Version 2.0.0, October 1, 2012 - 1.52] ]
+[section [*Version 2.0.0, October 23, 2012 - 1.52] ]
[*New Features:]
@@ -7275,6 +7349,7 @@
* [@http://svn.boost.org/trac/boost/ticket/7381 #7381] C++11 compliance: unresolved symbol when assigning a constexpr duration to a non-const local variable.
* [@http://svn.boost.org/trac/boost/ticket/7479 #7479] Compiles fails with compilers supporting constexpr fails if the standard library doesn't provides the constexpr interface
* [@http://svn.boost.org/trac/boost/ticket/7493 #7493] compile fail on intel-linux-12.1.3.0x because of bug on explicit bool conversion
+* [@http://svn.boost.org/trac/boost/ticket/7542 #7542] Missing -lpthread in chrono/io tester Sandia-clang-trunk
[*Would not fix:]
@@ -7282,6 +7357,24 @@
* The neww io interface provided in version 2 solves this issue. You should move to the new version.
+[*Known bugs not fixed yet:]
+
+* [@http://svn.boost.org/trac/boost/ticket/7525 #7525] Wrong clock_string<system_clock>::since() on Windows
+
+[warning
+
+The time_point<system_clock,D> formatter/parser specializations don't work yet. It has been disable defining `BOOST_CHRONO_DONT_PROVIDE_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT` until a fix for the following ticket is found:
+
+- [@http://svn.boost.org/trac/boost/ticket/7547 #7547] time_point<system_clock> input version 2 fails to compile
+
+- [@http://svn.boost.org/trac/boost/ticket/7546 #7546] time_point<system_clock> output version 2 fails to compile
+
+In this case the io operators behave like any time_point as if the specialization was removed.
+
+In order to enable this features on compilers working with, you will need to define `BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT`.
+
+]
+
[endsect] [/section [*Version 2.0.0] ]
[//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////]
@@ -7795,8 +7888,8 @@
[heading For later releases]
* Include Stopwatches.
-* Include chrono::date as defined by Howard Hinnant [@http://home.roadrunner.com/~hinnant/bloomington/date.html here].
* Add User defined literals for some durations.
+* Include chrono::date as defined by Howard Hinnant [@http://home.roadrunner.com/~hinnant/bloomington/date.html here].
[endsect]
Modified: branches/release/libs/chrono/test/io/time_point_input.cpp
==============================================================================
--- branches/release/libs/chrono/test/io/time_point_input.cpp (original)
+++ branches/release/libs/chrono/test/io/time_point_input.cpp 2012-10-24 20:07:52 EDT (Wed, 24 Oct 2012)
@@ -20,6 +20,25 @@
BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>(res)));
}
+#if BOOST_CHRONO_VERSION >= 2
+template <typename D>
+void test_good_system_clock(std::string str, D res)
+{
+ typedef boost::chrono::system_clock Clock;
+
+ std::istringstream in(str);
+ boost::chrono::time_point<Clock, D> tp;
+ in >> tp;
+ BOOST_TEST(in.eof());
+ BOOST_TEST(!in.fail());
+ std::cout << "Input= " << str << std::endl;
+ std::cout << "Expected= " << boost::chrono::time_point<Clock, D>(res) << std::endl;
+ std::cout << "Obtained= " << tp << std::endl;
+ std::cout << "Expected= " << boost::chrono::duration_cast<boost::chrono::nanoseconds>(boost::chrono::time_point<Clock, D>(res).time_since_epoch()).count() << std::endl;
+ std::cout << "Obtained= " << boost::chrono::duration_cast<boost::chrono::nanoseconds>(tp.time_since_epoch()).count() << std::endl;
+ BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>(res)));
+}
+#endif
template <typename Clock, typename D>
void test_fail(const char* str, D)
{
@@ -71,7 +90,7 @@
test_good<Clock> ("5000 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (5000));
test_good<Clock> ("5000 h", hours(5000));
-#if BOOST_CHRONO_VERSION==2
+#if BOOST_CHRONO_VERSION >= 2
test_good<Clock>("5000 min", minutes(5000));
#else
test_good<Clock> ("5000 m", minutes(5000));
@@ -91,6 +110,34 @@
}
+#if BOOST_CHRONO_VERSION >= 2
+void check_all_system_clock()
+{
+ using namespace boost::chrono;
+ using namespace boost;
+
+ test_good_system_clock ("1970-01-01 02:00:00.000000 +0000", hours(2));
+ test_good_system_clock ("1970-07-28 08:00:00.000000 +0000", hours(5000));
+ test_good_system_clock ("1970-01-04 11:20:00.000000 +0000", minutes(5000));
+ test_good_system_clock ("1970-01-01 01:23:20.000000 +0000", seconds(5000));
+ test_good_system_clock ("1970-01-01 00:00:01.000000 +0000", seconds(1));
+ test_good_system_clock ("1970-01-01 00:00:01.000000 +0000", seconds(1));
+ test_good_system_clock ("1969-12-31 23:59:59.000000 +0000", seconds(-1));
+ test_good_system_clock ("1970-01-01 00:00:00.000000 +0000", seconds(0));
+ test_good_system_clock ("1970-01-01 00:00:00.000000 +0000", seconds(0));
+ test_good_system_clock ("1970-01-01 00:00:05.000000 +0000", milliseconds(5000));
+ test_good_system_clock ("1970-01-01 00:00:00.005000 +0000", microseconds(5000));
+ test_good_system_clock ("1970-01-01 00:00:00.000005 +0000", nanoseconds(5000));
+ test_good_system_clock ("1970-01-01 00:08:20.000000 +0000", duration<boost::int_least64_t, deci> (5000));
+ test_good_system_clock ("1970-01-01 00:02:46.666667 +0000", duration<boost::int_least64_t, ratio<1, 30> > (5000));
+
+
+// test_fail<Clock> ("3001 ms", seconds(3));
+// test_fail_epoch<Clock> ("3001 ms", seconds(3));
+// test_fail_epoch<Clock> ("3001 ms since", seconds(3));
+
+}
+#endif
int main()
{
std::cout << "high_resolution_clock=" << std::endl;
@@ -99,9 +146,12 @@
std::cout << "steady_clock=" << std::endl;
check_all<boost::chrono::steady_clock> ();
#endif
- //std::cout << "system_clock=";
- //check_all<boost::chrono::system_clock>();
-
+ std::cout << "system_clock=" << std::endl;
+#if BOOST_CHRONO_VERSION >= 2 && defined BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
+ check_all_system_clock();
+#else
+ check_all<boost::chrono::system_clock> ();
+#endif
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
std::cout << "thread_clock="<< std::endl;
check_all<boost::chrono::thread_clock>();
Modified: branches/release/libs/chrono/test/io/time_point_output.cpp
==============================================================================
--- branches/release/libs/chrono/test/io/time_point_output.cpp (original)
+++ branches/release/libs/chrono/test/io/time_point_output.cpp 2012-10-24 20:07:52 EDT (Wed, 24 Oct 2012)
@@ -16,15 +16,32 @@
boost::chrono::time_point<Clock, D> tp(d);
out << tp;
BOOST_TEST(out.good());
+ //std::cout << "Expected= " << std::string(str) + boost::chrono::clock_string<Clock, char>::since() << std::endl;
+ //std::cout << "Obtained= " << out.str() << std::endl;
BOOST_TEST( (out.str() == std::string(str) + boost::chrono::clock_string<Clock, char>::since()));
}
+template <typename D>
+void test_good_prefix_system_clock(const char* str, D d)
+{
+ typedef boost::chrono::system_clock Clock;
+
+ std::ostringstream out;
+ boost::chrono::time_point<Clock, D> tp(d);
+ out << tp;
+ BOOST_TEST(out.good());
+
+ std::cout << "Expected= " << str << std::endl;
+ std::cout << "Obtained= " << out.str() << std::endl;
+ BOOST_TEST( (out.str() == std::string(str) ));
+}
+
template <typename Clock, typename D>
void test_good_symbol(const char* str, D d)
{
std::ostringstream out;
boost::chrono::time_point<Clock, D> tp(d);
-#if BOOST_CHRONO_VERSION==2
+#if BOOST_CHRONO_VERSION>=2
out << boost::chrono::duration_fmt(boost::chrono::duration_style::symbol) << tp;
#else
out << boost::chrono::duration_short << tp;
@@ -33,7 +50,21 @@
BOOST_TEST( (out.str() == std::string(str) + boost::chrono::clock_string<Clock, char>::since()));
}
-#if BOOST_CHRONO_VERSION==2
+#if BOOST_CHRONO_VERSION>=2
+template <typename D>
+void test_good_symbol_system_clock(const char* str, D d)
+{
+ typedef boost::chrono::system_clock Clock;
+
+ std::ostringstream out;
+ boost::chrono::time_point<Clock, D> tp(d);
+ out << boost::chrono::duration_fmt(boost::chrono::duration_style::symbol) << tp;
+ BOOST_TEST(out.good());
+ std::cout << "Expected= " << str << std::endl;
+ std::cout << "Obtained= " << out.str() << std::endl;
+ BOOST_TEST( (out.str() == std::string(str) ));
+}
+
template<typename Clock, typename D>
void test_good(const char* str, D d, boost::chrono::duration_style style)
{
@@ -43,6 +74,20 @@
BOOST_TEST(out.good());
BOOST_TEST((out.str() == std::string(str)+boost::chrono::clock_string<Clock,char>::since()));
}
+
+template<typename D>
+void test_good_system_clock(const char* str, D d, boost::chrono::duration_style style)
+{
+ typedef boost::chrono::system_clock Clock;
+
+ std::ostringstream out;
+ boost::chrono::time_point<Clock,D> tp(d);
+ out << boost::chrono::duration_fmt(style) << tp;
+ BOOST_TEST(out.good());
+ std::cout << "Expected= " << str << std::endl;
+ std::cout << "Obtained= " << out.str() << std::endl;
+ BOOST_TEST((out.str() == std::string(str) ));
+}
#endif
template <typename Clock>
@@ -51,7 +96,7 @@
using namespace boost::chrono;
using namespace boost;
-#if BOOST_CHRONO_VERSION==2
+#if BOOST_CHRONO_VERSION>=2
test_good<Clock>("2 hours", hours(2), duration_style::prefix);
test_good<Clock>("2 h", hours(2), duration_style::symbol);
#endif
@@ -69,7 +114,7 @@
test_good_prefix<Clock> ("2 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (2));
test_good_symbol<Clock> ("2 h", hours(2));
-#if BOOST_CHRONO_VERSION==2
+#if BOOST_CHRONO_VERSION>=2
test_good_symbol<Clock>("2 min", minutes(2));
#else
test_good_symbol<Clock> ("2 m", minutes(2));
@@ -81,6 +126,36 @@
test_good_symbol<Clock> ("2 [1/30]s", duration<boost::int_least64_t, ratio<1, 30> > (2));
}
+#if BOOST_CHRONO_VERSION >= 2
+void check_all_system_clock()
+{
+ using namespace boost::chrono;
+ using namespace boost;
+
+ test_good_system_clock("1970-01-01 02:00:00.000000 +0000", hours(2), duration_style::prefix);
+ test_good_system_clock("1970-01-01 02:00:00.000000 +0000", hours(2), duration_style::symbol);
+
+ test_good_prefix_system_clock("1970-01-01 02:00:00.000000 +0000", hours(2));
+ test_good_prefix_system_clock("1970-01-01 00:02:00.000000 +0000", minutes(2));
+ test_good_prefix_system_clock("1970-01-01 00:00:02.000000 +0000", seconds(2));
+ test_good_prefix_system_clock("1970-01-01 00:00:01.000000 +0000", seconds(1));
+ test_good_prefix_system_clock("1969-12-31 23:59:59.000000 +0000", seconds(-1));
+ test_good_prefix_system_clock("1970-01-01 00:00:00.000000 +0000", seconds(0));
+ test_good_prefix_system_clock("1970-01-01 00:00:00.002000 +0000", milliseconds(2));
+ test_good_prefix_system_clock("1970-01-01 00:00:00.000002 +0000", microseconds(2));
+ test_good_prefix_system_clock("1970-01-01 00:00:00.000000 +0000", nanoseconds(2));
+ test_good_prefix_system_clock("1970-01-01 00:00:00.200000 +0000", duration<boost::int_least64_t, deci> (2));
+ test_good_prefix_system_clock("1970-01-01 00:00:00.066667 +0000", duration<boost::int_least64_t, ratio<1, 30> > (2));
+
+ test_good_symbol_system_clock("1970-01-01 02:00:00.000000 +0000", hours(2));
+ test_good_symbol_system_clock("1970-01-01 00:02:00.000000 +0000", minutes(2));
+ test_good_symbol_system_clock("1970-01-01 00:00:02.000000 +0000", seconds(2));
+ test_good_symbol_system_clock("1970-01-01 00:00:00.002000 +0000", milliseconds(2));
+ test_good_symbol_system_clock("1970-01-01 00:00:00.000000 +0000", nanoseconds(2));
+ test_good_symbol_system_clock("1970-01-01 00:00:00.200000 +0000", duration<boost::int_least64_t, deci> (2));
+ test_good_symbol_system_clock("1970-01-01 00:00:00.066667 +0000", duration<boost::int_least64_t, ratio<1, 30> > (2));
+}
+#endif
int main()
{
@@ -90,8 +165,12 @@
std::cout << "steady_clock=" << std::endl;
check_all<boost::chrono::steady_clock> ();
#endif
- //std::cout << "system_clock=";
- //check_all<boost::chrono::system_clock>();
+ std::cout << "system_clock=" << std::endl;
+#if BOOST_CHRONO_VERSION >= 2 && defined BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
+ check_all_system_clock();
+#else
+ check_all<boost::chrono::system_clock> ();
+#endif
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
std::cout << "thread_clock="<< std::endl;
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk