1 #ifndef POSIXTIME_FORMATTERS_HPP___ 2 #define POSIXTIME_FORMATTERS_HPP___ 3 4 /* Copyright (c) 2002-2004 CrystalClear Software, Inc. 5 * Use, modification and distribution is subject to the 6 * Boost Software License, Version 1.0. (See accompanying 7 * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) 8 * Author: Jeff Garland, Bart Garst 9 * $Date$ 10 */ 11 12 #include <boost/date_time/gregorian/gregorian.hpp> 13 #include <boost/date_time/compiler_config.hpp> 14 #include <boost/date_time/iso_format.hpp> 15 #include <boost/date_time/date_format_simple.hpp> 16 #include <boost/date_time/posix_time/posix_time_types.hpp> 17 #include <boost/date_time/time_formatting_streams.hpp> 18 #include <boost/date_time/time_resolution_traits.hpp> // absolute_value 19 #include <boost/date_time/time_parsing.hpp> 20 21 /* NOTE: The "to_*_string" code for older compilers, ones that define 22 * BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS, is located in 23 * formatters_limited.hpp 24 */ 25 26 namespace boost { 27 28 namespace posix_time { 29 30 // template function called by wrapper functions: 31 // to_*_string(time_duration) & to_*_wstring(time_duration) 32 template<class charT> to_simple_string_type(time_duration td)33 inline std::basic_string<charT> to_simple_string_type(time_duration td) { 34 std::basic_ostringstream<charT> ss; 35 if(td.is_special()) { 36 /* simply using 'ss << td.get_rep()' won't work on compilers 37 * that don't support locales. This way does. */ 38 // switch copied from date_names_put.hpp 39 switch(td.get_rep().as_special()) 40 { 41 case not_a_date_time: 42 //ss << "not-a-number"; 43 ss << "not-a-date-time"; 44 break; 45 case pos_infin: 46 ss << "+infinity"; 47 break; 48 case neg_infin: 49 ss << "-infinity"; 50 break; 51 default: 52 ss << ""; 53 } 54 } 55 else { 56 charT fill_char = '0'; 57 if(td.is_negative()) { 58 ss << '-'; 59 } 60 ss << std::setw(2) << std::setfill(fill_char) 61 << date_time::absolute_value(td.hours()) << ":"; 62 ss << std::setw(2) << std::setfill(fill_char) 63 << date_time::absolute_value(td.minutes()) << ":"; 64 ss << std::setw(2) << std::setfill(fill_char) 65 << date_time::absolute_value(td.seconds()); 66 //TODO the following is totally non-generic, yelling FIXME 67 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300)) 68 boost::int64_t frac_sec = 69 date_time::absolute_value(td.fractional_seconds()); 70 // JDG [7/6/02 VC++ compatibility] 71 charT buff[32]; 72 _i64toa(frac_sec, buff, 10); 73 #else 74 time_duration::fractional_seconds_type frac_sec = 75 date_time::absolute_value(td.fractional_seconds()); 76 #endif 77 if (frac_sec != 0) { 78 ss << "." << std::setw(time_duration::num_fractional_digits()) 79 << std::setfill(fill_char) 80 81 // JDG [7/6/02 VC++ compatibility] 82 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300)) 83 << buff; 84 #else 85 << frac_sec; 86 #endif 87 } 88 }// else 89 return ss.str(); 90 } 91 //! Time duration to string -hh::mm::ss.fffffff. Example: 10:09:03.0123456 92 /*!\ingroup time_format 93 */ to_simple_string(time_duration td)94 inline std::string to_simple_string(time_duration td) { 95 return to_simple_string_type<char>(td); 96 } 97 98 99 // template function called by wrapper functions: 100 // to_*_string(time_duration) & to_*_wstring(time_duration) 101 template<class charT> to_iso_string_type(time_duration td)102 inline std::basic_string<charT> to_iso_string_type(time_duration td) 103 { 104 std::basic_ostringstream<charT> ss; 105 if(td.is_special()) { 106 /* simply using 'ss << td.get_rep()' won't work on compilers 107 * that don't support locales. This way does. */ 108 // switch copied from date_names_put.hpp 109 switch(td.get_rep().as_special()) { 110 case not_a_date_time: 111 //ss << "not-a-number"; 112 ss << "not-a-date-time"; 113 break; 114 case pos_infin: 115 ss << "+infinity"; 116 break; 117 case neg_infin: 118 ss << "-infinity"; 119 break; 120 default: 121 ss << ""; 122 } 123 } 124 else { 125 charT fill_char = '0'; 126 if(td.is_negative()) { 127 ss << '-'; 128 } 129 ss << std::setw(2) << std::setfill(fill_char) 130 << date_time::absolute_value(td.hours()); 131 ss << std::setw(2) << std::setfill(fill_char) 132 << date_time::absolute_value(td.minutes()); 133 ss << std::setw(2) << std::setfill(fill_char) 134 << date_time::absolute_value(td.seconds()); 135 //TODO the following is totally non-generic, yelling FIXME 136 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300)) 137 boost::int64_t frac_sec = 138 date_time::absolute_value(td.fractional_seconds()); 139 // JDG [7/6/02 VC++ compatibility] 140 charT buff[32]; 141 _i64toa(frac_sec, buff, 10); 142 #else 143 time_duration::fractional_seconds_type frac_sec = 144 date_time::absolute_value(td.fractional_seconds()); 145 #endif 146 if (frac_sec != 0) { 147 ss << "." << std::setw(time_duration::num_fractional_digits()) 148 << std::setfill(fill_char) 149 150 // JDG [7/6/02 VC++ compatibility] 151 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300)) 152 << buff; 153 #else 154 << frac_sec; 155 #endif 156 } 157 }// else 158 return ss.str(); 159 } 160 //! Time duration in iso format -hhmmss,fffffff Example: 10:09:03,0123456 161 /*!\ingroup time_format 162 */ to_iso_string(time_duration td)163 inline std::string to_iso_string(time_duration td){ 164 return to_iso_string_type<char>(td); 165 } 166 167 //! Time to simple format CCYY-mmm-dd hh:mm:ss.fffffff 168 /*!\ingroup time_format 169 */ 170 template<class charT> to_simple_string_type(ptime t)171 inline std::basic_string<charT> to_simple_string_type(ptime t) 172 { 173 // can't use this w/gcc295, no to_simple_string_type<>(td) available 174 std::basic_string<charT> ts = gregorian::to_simple_string_type<charT>(t.date());// + " "; 175 if(!t.time_of_day().is_special()) { 176 charT space = ' '; 177 return ts + space + to_simple_string_type<charT>(t.time_of_day()); 178 } 179 else { 180 return ts; 181 } 182 } to_simple_string(ptime t)183 inline std::string to_simple_string(ptime t){ 184 return to_simple_string_type<char>(t); 185 } 186 187 // function called by wrapper functions to_*_string(time_period) 188 // & to_*_wstring(time_period) 189 template<class charT> to_simple_string_type(time_period tp)190 inline std::basic_string<charT> to_simple_string_type(time_period tp) 191 { 192 charT beg = '[', mid = '/', end = ']'; 193 std::basic_string<charT> d1(to_simple_string_type<charT>(tp.begin())); 194 std::basic_string<charT> d2(to_simple_string_type<charT>(tp.last())); 195 return std::basic_string<charT>(beg + d1 + mid + d2 + end); 196 } 197 //! Convert to string of form [YYYY-mmm-DD HH:MM::SS.ffffff/YYYY-mmm-DD HH:MM::SS.fffffff] 198 /*!\ingroup time_format 199 */ to_simple_string(time_period tp)200 inline std::string to_simple_string(time_period tp){ 201 return to_simple_string_type<char>(tp); 202 } 203 204 // function called by wrapper functions to_*_string(time_period) 205 // & to_*_wstring(time_period) 206 template<class charT> to_iso_string_type(ptime t)207 inline std::basic_string<charT> to_iso_string_type(ptime t) 208 { 209 std::basic_string<charT> ts = gregorian::to_iso_string_type<charT>(t.date());// + "T"; 210 if(!t.time_of_day().is_special()) { 211 charT sep = 'T'; 212 return ts + sep + to_iso_string_type<charT>(t.time_of_day()); 213 } 214 else { 215 return ts; 216 } 217 } 218 //! Convert iso short form YYYYMMDDTHHMMSS where T is the date-time separator 219 /*!\ingroup time_format 220 */ to_iso_string(ptime t)221 inline std::string to_iso_string(ptime t){ 222 return to_iso_string_type<char>(t); 223 } 224 225 226 // function called by wrapper functions to_*_string(time_period) 227 // & to_*_wstring(time_period) 228 template<class charT> to_iso_extended_string_type(ptime t)229 inline std::basic_string<charT> to_iso_extended_string_type(ptime t) 230 { 231 std::basic_string<charT> ts = gregorian::to_iso_extended_string_type<charT>(t.date());// + "T"; 232 if(!t.time_of_day().is_special()) { 233 charT sep = 'T'; 234 return ts + sep + to_simple_string_type<charT>(t.time_of_day()); 235 } 236 else { 237 return ts; 238 } 239 } 240 //! Convert to form YYYY-MM-DDTHH:MM:SS where T is the date-time separator 241 /*!\ingroup time_format 242 */ to_iso_extended_string(ptime t)243 inline std::string to_iso_extended_string(ptime t){ 244 return to_iso_extended_string_type<char>(t); 245 } 246 247 #if !defined(BOOST_NO_STD_WSTRING) 248 //! Time duration to wstring -hh::mm::ss.fffffff. Example: 10:09:03.0123456 249 /*!\ingroup time_format 250 */ to_simple_wstring(time_duration td)251 inline std::wstring to_simple_wstring(time_duration td) { 252 return to_simple_string_type<wchar_t>(td); 253 } 254 //! Time duration in iso format -hhmmss,fffffff Example: 10:09:03,0123456 255 /*!\ingroup time_format 256 */ to_iso_wstring(time_duration td)257 inline std::wstring to_iso_wstring(time_duration td){ 258 return to_iso_string_type<wchar_t>(td); 259 } to_simple_wstring(ptime t)260 inline std::wstring to_simple_wstring(ptime t){ 261 return to_simple_string_type<wchar_t>(t); 262 } 263 //! Convert to wstring of form [YYYY-mmm-DD HH:MM::SS.ffffff/YYYY-mmm-DD HH:MM::SS.fffffff] 264 /*!\ingroup time_format 265 */ to_simple_wstring(time_period tp)266 inline std::wstring to_simple_wstring(time_period tp){ 267 return to_simple_string_type<wchar_t>(tp); 268 } 269 //! Convert iso short form YYYYMMDDTHHMMSS where T is the date-time separator 270 /*!\ingroup time_format 271 */ to_iso_wstring(ptime t)272 inline std::wstring to_iso_wstring(ptime t){ 273 return to_iso_string_type<wchar_t>(t); 274 } 275 //! Convert to form YYYY-MM-DDTHH:MM:SS where T is the date-time separator 276 /*!\ingroup time_format 277 */ to_iso_extended_wstring(ptime t)278 inline std::wstring to_iso_extended_wstring(ptime t){ 279 return to_iso_extended_string_type<wchar_t>(t); 280 } 281 282 #endif // BOOST_NO_STD_WSTRING 283 284 285 } } //namespace posix_time 286 287 288 #endif 289 290