boost/date_time/posix_time/time_formatters.hpp

   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
  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>
  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    */
  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>
 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    */
 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>
 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   }
 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>
 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    */
 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>
 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    */
 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>
 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    */
 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    */
 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    */
 257   inline std::wstring to_iso_wstring(time_duration td){
 258     return to_iso_string_type<wchar_t>(td);
 259   }
 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    */
 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    */
 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    */
 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