summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2009-06-01 08:48:42 (GMT)
committerRemko Tronçon <git@el-tramo.be>2009-06-01 09:24:28 (GMT)
commit2812bddd81f8a1b804c7460f4e14cd0aa393d129 (patch)
treed46294f35150c4f0f43deaf2d31fceaf945ae715 /3rdParty/Boost/boost/date_time/time_parsing.hpp
downloadswift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.zip
swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.tar.bz2
Import.
Diffstat (limited to '3rdParty/Boost/boost/date_time/time_parsing.hpp')
-rw-r--r--3rdParty/Boost/boost/date_time/time_parsing.hpp321
1 files changed, 321 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/date_time/time_parsing.hpp b/3rdParty/Boost/boost/date_time/time_parsing.hpp
new file mode 100644
index 0000000..dfccf6a
--- /dev/null
+++ b/3rdParty/Boost/boost/date_time/time_parsing.hpp
@@ -0,0 +1,321 @@
+#ifndef _DATE_TIME_TIME_PARSING_HPP___
+#define _DATE_TIME_TIME_PARSING_HPP___
+
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ */
+
+#include "boost/tokenizer.hpp"
+#include "boost/lexical_cast.hpp"
+#include "boost/date_time/date_parsing.hpp"
+#include "boost/cstdint.hpp"
+#include <iostream>
+
+namespace boost {
+namespace date_time {
+
+ //! computes exponential math like 2^8 => 256, only works with positive integers
+ //Not general purpose, but needed b/c std::pow is not available
+ //everywehere. Hasn't been tested with negatives and zeros
+ template<class int_type>
+ inline
+ int_type power(int_type base, int_type exponent)
+ {
+ int_type result = 1;
+ for(int i = 0; i < exponent; ++i){
+ result *= base;
+ }
+ return result;
+ }
+
+ //! Creates a time_duration object from a delimited string
+ /*! Expected format for string is "[-]h[h][:mm][:ss][.fff]".
+ * If the number of fractional digits provided is greater than the
+ * precision of the time duration type then the extra digits are
+ * truncated.
+ *
+ * A negative duration will be created if the first character in
+ * string is a '-', all other '-' will be treated as delimiters.
+ * Accepted delimiters are "-:,.".
+ */
+ template<class time_duration, class char_type>
+ inline
+ time_duration
+ str_from_delimited_time_duration(const std::basic_string<char_type>& s)
+ {
+ unsigned short min=0, sec =0;
+ int hour =0;
+ bool is_neg = (s.at(0) == '-');
+ boost::int64_t fs=0;
+ int pos = 0;
+
+ typedef typename std::basic_string<char_type>::traits_type traits_type;
+ typedef boost::char_separator<char_type, traits_type> char_separator_type;
+ typedef boost::tokenizer<char_separator_type,
+ typename std::basic_string<char_type>::const_iterator,
+ std::basic_string<char_type> > tokenizer;
+ typedef typename boost::tokenizer<char_separator_type,
+ typename std::basic_string<char_type>::const_iterator,
+ typename std::basic_string<char_type> >::iterator tokenizer_iterator;
+
+ char_type sep_chars[5] = {'-',':',',','.'};
+ char_separator_type sep(sep_chars);
+ tokenizer tok(s,sep);
+ for(tokenizer_iterator beg=tok.begin(); beg!=tok.end();++beg){
+ switch(pos) {
+ case 0: {
+ hour = boost::lexical_cast<int>(*beg);
+ break;
+ }
+ case 1: {
+ min = boost::lexical_cast<unsigned short>(*beg);
+ break;
+ }
+ case 2: {
+ sec = boost::lexical_cast<unsigned short>(*beg);
+ break;
+ };
+ case 3: {
+ int digits = static_cast<int>(beg->length());
+ //Works around a bug in MSVC 6 library that does not support
+ //operator>> thus meaning lexical_cast will fail to compile.
+#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+ // msvc wouldn't compile 'time_duration::num_fractional_digits()'
+ // (required template argument list) as a workaround a temp
+ // time_duration object was used
+ time_duration td(hour,min,sec,fs);
+ int precision = td.num_fractional_digits();
+ // _atoi64 is an MS specific function
+ if(digits >= precision) {
+ // drop excess digits
+ fs = _atoi64(beg->substr(0, precision).c_str());
+ }
+ else {
+ fs = _atoi64(beg->c_str());
+ }
+#else
+ int precision = time_duration::num_fractional_digits();
+ if(digits >= precision) {
+ // drop excess digits
+ fs = boost::lexical_cast<boost::int64_t>(beg->substr(0, precision));
+ }
+ else {
+ fs = boost::lexical_cast<boost::int64_t>(*beg);
+ }
+#endif
+ if(digits < precision){
+ // trailing zeros get dropped from the string,
+ // "1:01:01.1" would yield .000001 instead of .100000
+ // the power() compensates for the missing decimal places
+ fs *= power(10, precision - digits);
+ }
+
+ break;
+ }
+ }//switch
+ pos++;
+ }
+ if(is_neg) {
+ return -time_duration(hour, min, sec, fs);
+ }
+ else {
+ return time_duration(hour, min, sec, fs);
+ }
+ }
+
+ //! Creates a time_duration object from a delimited string
+ /*! Expected format for string is "[-]h[h][:mm][:ss][.fff]".
+ * If the number of fractional digits provided is greater than the
+ * precision of the time duration type then the extra digits are
+ * truncated.
+ *
+ * A negative duration will be created if the first character in
+ * string is a '-', all other '-' will be treated as delimiters.
+ * Accepted delimiters are "-:,.".
+ */
+ template<class time_duration>
+ inline
+ time_duration
+ parse_delimited_time_duration(const std::string& s)
+ {
+ return str_from_delimited_time_duration<time_duration,char>(s);
+ }
+
+ //! Utility function to split appart string
+ inline
+ bool
+ split(const std::string& s,
+ char sep,
+ std::string& first,
+ std::string& second)
+ {
+ int sep_pos = static_cast<int>(s.find(sep));
+ first = s.substr(0,sep_pos);
+ second = s.substr(sep_pos+1);
+ return true;
+ }
+
+
+ template<class time_type>
+ inline
+ time_type
+ parse_delimited_time(const std::string& s, char sep)
+ {
+ typedef typename time_type::time_duration_type time_duration;
+ typedef typename time_type::date_type date_type;
+
+ //split date/time on a unique delimiter char such as ' ' or 'T'
+ std::string date_string, tod_string;
+ split(s, sep, date_string, tod_string);
+ //call parse_date with first string
+ date_type d = parse_date<date_type>(date_string);
+ //call parse_time_duration with remaining string
+ time_duration td = parse_delimited_time_duration<time_duration>(tod_string);
+ //construct a time
+ return time_type(d, td);
+
+ }
+
+ //! Parse time duration part of an iso time of form: [-]hhmmss[.fff...] (eg: 120259.123 is 12 hours, 2 min, 59 seconds, 123000 microseconds)
+ template<class time_duration>
+ inline
+ time_duration
+ parse_undelimited_time_duration(const std::string& s)
+ {
+ int precision = 0;
+ {
+ // msvc wouldn't compile 'time_duration::num_fractional_digits()'
+ // (required template argument list) as a workaround, a temp
+ // time_duration object was used
+ time_duration tmp(0,0,0,1);
+ precision = tmp.num_fractional_digits();
+ }
+ // 'precision+1' is so we grab all digits, plus the decimal
+ int offsets[] = {2,2,2, precision+1};
+ int pos = 0, sign = 0;
+ int hours = 0;
+ short min=0, sec=0;
+ boost::int64_t fs=0;
+ // increment one position if the string was "signed"
+ if(s.at(sign) == '-')
+ {
+ ++sign;
+ }
+ // stlport choked when passing s.substr() to tokenizer
+ // using a new string fixed the error
+ std::string remain = s.substr(sign);
+ /* We do not want the offset_separator to wrap the offsets, we
+ * will never want to process more than:
+ * 2 char, 2 char, 2 char, frac_sec length.
+ * We *do* want the offset_separator to give us a partial for the
+ * last characters if there were not enough provided in the input string. */
+ bool wrap_off = false;
+ bool ret_part = true;
+ boost::offset_separator osf(offsets, offsets+4, wrap_off, ret_part);
+ typedef boost::tokenizer<boost::offset_separator,
+ std::basic_string<char>::const_iterator,
+ std::basic_string<char> > tokenizer;
+ typedef boost::tokenizer<boost::offset_separator,
+ std::basic_string<char>::const_iterator,
+ std::basic_string<char> >::iterator tokenizer_iterator;
+ tokenizer tok(remain, osf);
+ for(tokenizer_iterator ti=tok.begin(); ti!=tok.end();++ti){
+ switch(pos) {
+ case 0:
+ {
+ hours = boost::lexical_cast<int>(*ti);
+ break;
+ }
+ case 1:
+ {
+ min = boost::lexical_cast<short>(*ti);
+ break;
+ }
+ case 2:
+ {
+ sec = boost::lexical_cast<short>(*ti);
+ break;
+ }
+ case 3:
+ {
+ std::string char_digits(ti->substr(1)); // digits w/no decimal
+ int digits = static_cast<int>(char_digits.length());
+
+ //Works around a bug in MSVC 6 library that does not support
+ //operator>> thus meaning lexical_cast will fail to compile.
+#if (defined(BOOST_MSVC) && (_MSC_VER <= 1200)) // 1200 == VC++ 6.0
+ // _atoi64 is an MS specific function
+ if(digits >= precision) {
+ // drop excess digits
+ fs = _atoi64(char_digits.substr(0, precision).c_str());
+ }
+ else if(digits == 0) {
+ fs = 0; // just in case _atoi64 doesn't like an empty string
+ }
+ else {
+ fs = _atoi64(char_digits.c_str());
+ }
+#else
+ if(digits >= precision) {
+ // drop excess digits
+ fs = boost::lexical_cast<boost::int64_t>(char_digits.substr(0, precision));
+ }
+ else if(digits == 0) {
+ fs = 0; // lexical_cast doesn't like empty strings
+ }
+ else {
+ fs = boost::lexical_cast<boost::int64_t>(char_digits);
+ }
+#endif
+ if(digits < precision){
+ // trailing zeros get dropped from the string,
+ // "1:01:01.1" would yield .000001 instead of .100000
+ // the power() compensates for the missing decimal places
+ fs *= power(10, precision - digits);
+ }
+
+ break;
+ }
+ };
+ pos++;
+ }
+ if(sign) {
+ return -time_duration(hours, min, sec, fs);
+ }
+ else {
+ return time_duration(hours, min, sec, fs);
+ }
+ }
+
+ //! Parse time string of form YYYYMMDDThhmmss where T is delimeter between date and time
+ template<class time_type>
+ inline
+ time_type
+ parse_iso_time(const std::string& s, char sep)
+ {
+ typedef typename time_type::time_duration_type time_duration;
+ typedef typename time_type::date_type date_type;
+
+ //split date/time on a unique delimiter char such as ' ' or 'T'
+ std::string date_string, tod_string;
+ split(s, sep, date_string, tod_string);
+ //call parse_date with first string
+ date_type d = parse_undelimited_date<date_type>(date_string);
+ //call parse_time_duration with remaining string
+ time_duration td = parse_undelimited_time_duration<time_duration>(tod_string);
+ //construct a time
+ return time_type(d, td);
+ }
+
+
+
+} }//namespace date_time
+
+
+
+
+#endif