third_party/boost/include/boost/date_time/time_parsing.hpp - webm/webmlive - Git at Google

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