| #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 |