1 #ifndef DATE_TIME_GREGORIAN_IO_HPP__ 2 #define DATE_TIME_GREGORIAN_IO_HPP__ 3 4 /* Copyright (c) 2004-2005 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 <locale> 13 #include <iostream> 14 #include <iterator> // i/ostreambuf_iterator 15 #include <boost/io/ios_state.hpp> 16 #include <boost/date_time/date_facet.hpp> 17 #include <boost/date_time/period_parser.hpp> 18 #include <boost/date_time/period_formatter.hpp> 19 #include <boost/date_time/special_values_parser.hpp> 20 #include <boost/date_time/special_values_formatter.hpp> 21 #include <boost/date_time/gregorian/gregorian_types.hpp> 22 #include <boost/date_time/gregorian/conversion.hpp> // to_tm will be needed in the facets 23 24 namespace boost { 25 namespace gregorian { 26 27 28 typedef boost::date_time::period_formatter<wchar_t> wperiod_formatter; 29 typedef boost::date_time::period_formatter<char> period_formatter; 30 31 typedef boost::date_time::date_facet<date,wchar_t> wdate_facet; 32 typedef boost::date_time::date_facet<date,char> date_facet; 33 34 typedef boost::date_time::period_parser<date,char> period_parser; 35 typedef boost::date_time::period_parser<date,wchar_t> wperiod_parser; 36 37 typedef boost::date_time::special_values_formatter<char> special_values_formatter; 38 typedef boost::date_time::special_values_formatter<wchar_t> wspecial_values_formatter; 39 40 typedef boost::date_time::special_values_parser<date,char> special_values_parser; 41 typedef boost::date_time::special_values_parser<date,wchar_t> wspecial_values_parser; 42 43 typedef boost::date_time::date_input_facet<date,char> date_input_facet; 44 typedef boost::date_time::date_input_facet<date,wchar_t> wdate_input_facet; 45 46 template <class CharT, class TraitsT> 47 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::date & d)48 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::date& d) { 49 boost::io::ios_flags_saver iflags(os); 50 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 51 std::ostreambuf_iterator<CharT> output_itr(os); 52 if (std::has_facet<custom_date_facet>(os.getloc())) 53 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), d); 54 else { 55 //instantiate a custom facet for dealing with dates since the user 56 //has not put one in the stream so far. This is for efficiency 57 //since we would always need to reconstruct for every date 58 //if the locale did not already exist. Of course this will be overridden 59 //if the user imbues at some later point. With the default settings 60 //for the facet the resulting format will be the same as the 61 //std::time_facet settings. 62 custom_date_facet* f = new custom_date_facet(); 63 std::locale l = std::locale(os.getloc(), f); 64 os.imbue(l); 65 f->put(output_itr, os, os.fill(), d); 66 } 67 return os; 68 } 69 70 //! input operator for date 71 template <class CharT, class Traits> 72 inline 73 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,date & d)74 operator>>(std::basic_istream<CharT, Traits>& is, date& d) 75 { 76 boost::io::ios_flags_saver iflags(is); 77 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 78 if (strm_sentry) { 79 try { 80 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 81 82 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 83 if(std::has_facet<date_input_facet>(is.getloc())) { 84 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, d); 85 } 86 else { 87 date_input_facet* f = new date_input_facet(); 88 std::locale l = std::locale(is.getloc(), f); 89 is.imbue(l); 90 f->get(sit, str_end, is, d); 91 } 92 } 93 catch(...) { 94 // mask tells us what exceptions are turned on 95 std::ios_base::iostate exception_mask = is.exceptions(); 96 // if the user wants exceptions on failbit, we'll rethrow our 97 // date_time exception & set the failbit 98 if(std::ios_base::failbit & exception_mask) { 99 try { is.setstate(std::ios_base::failbit); } 100 catch(std::ios_base::failure&) {} // ignore this one 101 throw; // rethrow original exception 102 } 103 else { 104 // if the user want's to fail quietly, we simply set the failbit 105 is.setstate(std::ios_base::failbit); 106 } 107 108 } 109 } 110 return is; 111 } 112 113 template <class CharT, class TraitsT> 114 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::date_duration & dd)115 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::date_duration& dd) { 116 boost::io::ios_flags_saver iflags(os); 117 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 118 std::ostreambuf_iterator<CharT> output_itr(os); 119 if (std::has_facet<custom_date_facet>(os.getloc())) 120 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), dd); 121 else { 122 custom_date_facet* f = new custom_date_facet(); 123 std::locale l = std::locale(os.getloc(), f); 124 os.imbue(l); 125 f->put(output_itr, os, os.fill(), dd); 126 127 } 128 return os; 129 } 130 131 //! input operator for date_duration 132 template <class CharT, class Traits> 133 inline 134 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,date_duration & dd)135 operator>>(std::basic_istream<CharT, Traits>& is, date_duration& dd) 136 { 137 boost::io::ios_flags_saver iflags(is); 138 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 139 if (strm_sentry) { 140 try { 141 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 142 143 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 144 if(std::has_facet<date_input_facet>(is.getloc())) { 145 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dd); 146 } 147 else { 148 date_input_facet* f = new date_input_facet(); 149 std::locale l = std::locale(is.getloc(), f); 150 is.imbue(l); 151 f->get(sit, str_end, is, dd); 152 } 153 } 154 catch(...) { 155 std::ios_base::iostate exception_mask = is.exceptions(); 156 if(std::ios_base::failbit & exception_mask) { 157 try { is.setstate(std::ios_base::failbit); } 158 catch(std::ios_base::failure&) {} 159 throw; // rethrow original exception 160 } 161 else { 162 is.setstate(std::ios_base::failbit); 163 } 164 165 } 166 } 167 return is; 168 } 169 170 template <class CharT, class TraitsT> 171 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::date_period & dp)172 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::date_period& dp) { 173 boost::io::ios_flags_saver iflags(os); 174 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 175 std::ostreambuf_iterator<CharT> output_itr(os); 176 if (std::has_facet<custom_date_facet>(os.getloc())) 177 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), dp); 178 else { 179 //instantiate a custom facet for dealing with date periods since the user 180 //has not put one in the stream so far. This is for efficiency 181 //since we would always need to reconstruct for every time period 182 //if the local did not already exist. Of course this will be overridden 183 //if the user imbues at some later point. With the default settings 184 //for the facet the resulting format will be the same as the 185 //std::time_facet settings. 186 custom_date_facet* f = new custom_date_facet(); 187 std::locale l = std::locale(os.getloc(), f); 188 os.imbue(l); 189 f->put(output_itr, os, os.fill(), dp); 190 191 } 192 return os; 193 } 194 195 //! input operator for date_period 196 template <class CharT, class Traits> 197 inline 198 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,date_period & dp)199 operator>>(std::basic_istream<CharT, Traits>& is, date_period& dp) 200 { 201 boost::io::ios_flags_saver iflags(is); 202 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 203 if (strm_sentry) { 204 try { 205 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 206 207 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 208 if(std::has_facet<date_input_facet>(is.getloc())) { 209 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dp); 210 } 211 else { 212 date_input_facet* f = new date_input_facet(); 213 std::locale l = std::locale(is.getloc(), f); 214 is.imbue(l); 215 f->get(sit, str_end, is, dp); 216 } 217 } 218 catch(...) { 219 std::ios_base::iostate exception_mask = is.exceptions(); 220 if(std::ios_base::failbit & exception_mask) { 221 try { is.setstate(std::ios_base::failbit); } 222 catch(std::ios_base::failure&) {} 223 throw; // rethrow original exception 224 } 225 else { 226 is.setstate(std::ios_base::failbit); 227 } 228 229 } 230 } 231 return is; 232 } 233 234 /********** small gregorian types **********/ 235 236 template <class CharT, class TraitsT> 237 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::greg_month & gm)238 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::greg_month& gm) { 239 boost::io::ios_flags_saver iflags(os); 240 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 241 std::ostreambuf_iterator<CharT> output_itr(os); 242 if (std::has_facet<custom_date_facet>(os.getloc())) 243 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), gm); 244 else { 245 custom_date_facet* f = new custom_date_facet();//-> 10/1074199752/32 because year & day not initialized in put(...) 246 //custom_date_facet* f = new custom_date_facet("%B"); 247 std::locale l = std::locale(os.getloc(), f); 248 os.imbue(l); 249 f->put(output_itr, os, os.fill(), gm); 250 } 251 return os; 252 } 253 254 //! input operator for greg_month 255 template <class CharT, class Traits> 256 inline 257 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,greg_month & m)258 operator>>(std::basic_istream<CharT, Traits>& is, greg_month& m) 259 { 260 boost::io::ios_flags_saver iflags(is); 261 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 262 if (strm_sentry) { 263 try { 264 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 265 266 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 267 if(std::has_facet<date_input_facet>(is.getloc())) { 268 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, m); 269 } 270 else { 271 date_input_facet* f = new date_input_facet(); 272 std::locale l = std::locale(is.getloc(), f); 273 is.imbue(l); 274 f->get(sit, str_end, is, m); 275 } 276 } 277 catch(...) { 278 std::ios_base::iostate exception_mask = is.exceptions(); 279 if(std::ios_base::failbit & exception_mask) { 280 try { is.setstate(std::ios_base::failbit); } 281 catch(std::ios_base::failure&) {} 282 throw; // rethrow original exception 283 } 284 else { 285 is.setstate(std::ios_base::failbit); 286 } 287 288 } 289 } 290 return is; 291 } 292 293 294 template <class CharT, class TraitsT> 295 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::greg_weekday & gw)296 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::greg_weekday& gw) { 297 boost::io::ios_flags_saver iflags(os); 298 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 299 std::ostreambuf_iterator<CharT> output_itr(os); 300 if (std::has_facet<custom_date_facet>(os.getloc())) 301 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), gw); 302 else { 303 custom_date_facet* f = new custom_date_facet(); 304 std::locale l = std::locale(os.getloc(), f); 305 os.imbue(l); 306 f->put(output_itr, os, os.fill(), gw); 307 } 308 return os; 309 } 310 311 //! input operator for greg_weekday 312 template <class CharT, class Traits> 313 inline 314 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,greg_weekday & wd)315 operator>>(std::basic_istream<CharT, Traits>& is, greg_weekday& wd) 316 { 317 boost::io::ios_flags_saver iflags(is); 318 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 319 if (strm_sentry) { 320 try { 321 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 322 323 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 324 if(std::has_facet<date_input_facet>(is.getloc())) { 325 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, wd); 326 } 327 else { 328 date_input_facet* f = new date_input_facet(); 329 std::locale l = std::locale(is.getloc(), f); 330 is.imbue(l); 331 f->get(sit, str_end, is, wd); 332 } 333 } 334 catch(...) { 335 std::ios_base::iostate exception_mask = is.exceptions(); 336 if(std::ios_base::failbit & exception_mask) { 337 try { is.setstate(std::ios_base::failbit); } 338 catch(std::ios_base::failure&) {} 339 throw; // rethrow original exception 340 } 341 else { 342 is.setstate(std::ios_base::failbit); 343 } 344 345 } 346 } 347 return is; 348 } 349 350 //NOTE: output operator for greg_day was not necessary 351 352 //! input operator for greg_day 353 template <class CharT, class Traits> 354 inline 355 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,greg_day & gd)356 operator>>(std::basic_istream<CharT, Traits>& is, greg_day& gd) 357 { 358 boost::io::ios_flags_saver iflags(is); 359 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 360 if (strm_sentry) { 361 try { 362 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 363 364 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 365 if(std::has_facet<date_input_facet>(is.getloc())) { 366 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gd); 367 } 368 else { 369 date_input_facet* f = new date_input_facet(); 370 std::locale l = std::locale(is.getloc(), f); 371 is.imbue(l); 372 f->get(sit, str_end, is, gd); 373 } 374 } 375 catch(...) { 376 std::ios_base::iostate exception_mask = is.exceptions(); 377 if(std::ios_base::failbit & exception_mask) { 378 try { is.setstate(std::ios_base::failbit); } 379 catch(std::ios_base::failure&) {} 380 throw; // rethrow original exception 381 } 382 else { 383 is.setstate(std::ios_base::failbit); 384 } 385 386 } 387 } 388 return is; 389 } 390 391 //NOTE: output operator for greg_year was not necessary 392 393 //! input operator for greg_year 394 template <class CharT, class Traits> 395 inline 396 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,greg_year & gy)397 operator>>(std::basic_istream<CharT, Traits>& is, greg_year& gy) 398 { 399 boost::io::ios_flags_saver iflags(is); 400 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 401 if (strm_sentry) { 402 try { 403 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 404 405 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 406 if(std::has_facet<date_input_facet>(is.getloc())) { 407 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gy); 408 } 409 else { 410 date_input_facet* f = new date_input_facet(); 411 std::locale l = std::locale(is.getloc(), f); 412 is.imbue(l); 413 f->get(sit, str_end, is, gy); 414 } 415 } 416 catch(...) { 417 std::ios_base::iostate exception_mask = is.exceptions(); 418 if(std::ios_base::failbit & exception_mask) { 419 try { is.setstate(std::ios_base::failbit); } 420 catch(std::ios_base::failure&) {} 421 throw; // rethrow original exception 422 } 423 else { 424 is.setstate(std::ios_base::failbit); 425 } 426 427 } 428 } 429 return is; 430 } 431 432 /********** date generator types **********/ 433 434 template <class CharT, class TraitsT> 435 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::partial_date & pd)436 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::partial_date& pd) { 437 boost::io::ios_flags_saver iflags(os); 438 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 439 std::ostreambuf_iterator<CharT> output_itr(os); 440 if (std::has_facet<custom_date_facet>(os.getloc())) 441 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), pd); 442 else { 443 custom_date_facet* f = new custom_date_facet(); 444 std::locale l = std::locale(os.getloc(), f); 445 os.imbue(l); 446 f->put(output_itr, os, os.fill(), pd); 447 } 448 return os; 449 } 450 451 //! input operator for partial_date 452 template <class CharT, class Traits> 453 inline 454 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,partial_date & pd)455 operator>>(std::basic_istream<CharT, Traits>& is, partial_date& pd) 456 { 457 boost::io::ios_flags_saver iflags(is); 458 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 459 if (strm_sentry) { 460 try { 461 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 462 463 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 464 if(std::has_facet<date_input_facet>(is.getloc())) { 465 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, pd); 466 } 467 else { 468 date_input_facet* f = new date_input_facet(); 469 std::locale l = std::locale(is.getloc(), f); 470 is.imbue(l); 471 f->get(sit, str_end, is, pd); 472 } 473 } 474 catch(...) { 475 std::ios_base::iostate exception_mask = is.exceptions(); 476 if(std::ios_base::failbit & exception_mask) { 477 try { is.setstate(std::ios_base::failbit); } 478 catch(std::ios_base::failure&) {} 479 throw; // rethrow original exception 480 } 481 else { 482 is.setstate(std::ios_base::failbit); 483 } 484 485 } 486 } 487 return is; 488 } 489 490 template <class CharT, class TraitsT> 491 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::nth_day_of_the_week_in_month & nkd)492 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::nth_day_of_the_week_in_month& nkd) { 493 boost::io::ios_flags_saver iflags(os); 494 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 495 std::ostreambuf_iterator<CharT> output_itr(os); 496 if (std::has_facet<custom_date_facet>(os.getloc())) 497 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), nkd); 498 else { 499 custom_date_facet* f = new custom_date_facet(); 500 std::locale l = std::locale(os.getloc(), f); 501 os.imbue(l); 502 f->put(output_itr, os, os.fill(), nkd); 503 } 504 return os; 505 } 506 507 //! input operator for nth_day_of_the_week_in_month 508 template <class CharT, class Traits> 509 inline 510 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,nth_day_of_the_week_in_month & nday)511 operator>>(std::basic_istream<CharT, Traits>& is, 512 nth_day_of_the_week_in_month& nday) 513 { 514 boost::io::ios_flags_saver iflags(is); 515 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 516 if (strm_sentry) { 517 try { 518 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 519 520 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 521 if(std::has_facet<date_input_facet>(is.getloc())) { 522 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, nday); 523 } 524 else { 525 date_input_facet* f = new date_input_facet(); 526 std::locale l = std::locale(is.getloc(), f); 527 is.imbue(l); 528 f->get(sit, str_end, is, nday); 529 } 530 } 531 catch(...) { 532 std::ios_base::iostate exception_mask = is.exceptions(); 533 if(std::ios_base::failbit & exception_mask) { 534 try { is.setstate(std::ios_base::failbit); } 535 catch(std::ios_base::failure&) {} 536 throw; // rethrow original exception 537 } 538 else { 539 is.setstate(std::ios_base::failbit); 540 } 541 542 } 543 } 544 return is; 545 } 546 547 548 template <class CharT, class TraitsT> 549 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::first_day_of_the_week_in_month & fkd)550 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::first_day_of_the_week_in_month& fkd) { 551 boost::io::ios_flags_saver iflags(os); 552 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 553 std::ostreambuf_iterator<CharT> output_itr(os); 554 if (std::has_facet<custom_date_facet>(os.getloc())) 555 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), fkd); 556 else { 557 custom_date_facet* f = new custom_date_facet(); 558 std::locale l = std::locale(os.getloc(), f); 559 os.imbue(l); 560 f->put(output_itr, os, os.fill(), fkd); 561 } 562 return os; 563 } 564 565 //! input operator for first_day_of_the_week_in_month 566 template <class CharT, class Traits> 567 inline 568 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,first_day_of_the_week_in_month & fkd)569 operator>>(std::basic_istream<CharT, Traits>& is, 570 first_day_of_the_week_in_month& fkd) 571 { 572 boost::io::ios_flags_saver iflags(is); 573 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 574 if (strm_sentry) { 575 try { 576 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 577 578 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 579 if(std::has_facet<date_input_facet>(is.getloc())) { 580 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkd); 581 } 582 else { 583 date_input_facet* f = new date_input_facet(); 584 std::locale l = std::locale(is.getloc(), f); 585 is.imbue(l); 586 f->get(sit, str_end, is, fkd); 587 } 588 } 589 catch(...) { 590 std::ios_base::iostate exception_mask = is.exceptions(); 591 if(std::ios_base::failbit & exception_mask) { 592 try { is.setstate(std::ios_base::failbit); } 593 catch(std::ios_base::failure&) {} 594 throw; // rethrow original exception 595 } 596 else { 597 is.setstate(std::ios_base::failbit); 598 } 599 600 } 601 } 602 return is; 603 } 604 605 606 template <class CharT, class TraitsT> 607 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::last_day_of_the_week_in_month & lkd)608 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::last_day_of_the_week_in_month& lkd) { 609 boost::io::ios_flags_saver iflags(os); 610 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 611 std::ostreambuf_iterator<CharT> output_itr(os); 612 if (std::has_facet<custom_date_facet>(os.getloc())) 613 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), lkd); 614 else { 615 custom_date_facet* f = new custom_date_facet(); 616 std::locale l = std::locale(os.getloc(), f); 617 os.imbue(l); 618 f->put(output_itr, os, os.fill(), lkd); 619 } 620 return os; 621 } 622 623 //! input operator for last_day_of_the_week_in_month 624 template <class CharT, class Traits> 625 inline 626 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,last_day_of_the_week_in_month & lkd)627 operator>>(std::basic_istream<CharT, Traits>& is, 628 last_day_of_the_week_in_month& lkd) 629 { 630 boost::io::ios_flags_saver iflags(is); 631 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 632 if (strm_sentry) { 633 try { 634 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 635 636 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 637 if(std::has_facet<date_input_facet>(is.getloc())) { 638 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, lkd); 639 } 640 else { 641 date_input_facet* f = new date_input_facet(); 642 std::locale l = std::locale(is.getloc(), f); 643 is.imbue(l); 644 f->get(sit, str_end, is, lkd); 645 } 646 } 647 catch(...) { 648 std::ios_base::iostate exception_mask = is.exceptions(); 649 if(std::ios_base::failbit & exception_mask) { 650 try { is.setstate(std::ios_base::failbit); } 651 catch(std::ios_base::failure&) {} 652 throw; // rethrow original exception 653 } 654 else { 655 is.setstate(std::ios_base::failbit); 656 } 657 658 } 659 } 660 return is; 661 } 662 663 664 template <class CharT, class TraitsT> 665 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::first_day_of_the_week_after & fda)666 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::first_day_of_the_week_after& fda) { 667 boost::io::ios_flags_saver iflags(os); 668 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 669 std::ostreambuf_iterator<CharT> output_itr(os); 670 if (std::has_facet<custom_date_facet>(os.getloc())) { 671 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), fda); 672 } 673 else { 674 custom_date_facet* f = new custom_date_facet(); 675 std::locale l = std::locale(os.getloc(), f); 676 os.imbue(l); 677 f->put(output_itr, os, os.fill(), fda); 678 } 679 return os; 680 } 681 682 //! input operator for first_day_of_the_week_after 683 template <class CharT, class Traits> 684 inline 685 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,first_day_of_the_week_after & fka)686 operator>>(std::basic_istream<CharT, Traits>& is, 687 first_day_of_the_week_after& fka) 688 { 689 boost::io::ios_flags_saver iflags(is); 690 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 691 if (strm_sentry) { 692 try { 693 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 694 695 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 696 if(std::has_facet<date_input_facet>(is.getloc())) { 697 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fka); 698 } 699 else { 700 date_input_facet* f = new date_input_facet(); 701 std::locale l = std::locale(is.getloc(), f); 702 is.imbue(l); 703 f->get(sit, str_end, is, fka); 704 } 705 } 706 catch(...) { 707 std::ios_base::iostate exception_mask = is.exceptions(); 708 if(std::ios_base::failbit & exception_mask) { 709 try { is.setstate(std::ios_base::failbit); } 710 catch(std::ios_base::failure&) {} 711 throw; // rethrow original exception 712 } 713 else { 714 is.setstate(std::ios_base::failbit); 715 } 716 717 } 718 } 719 return is; 720 } 721 722 723 template <class CharT, class TraitsT> 724 inline std::basic_ostream<CharT, TraitsT>& operator <<(std::basic_ostream<CharT,TraitsT> & os,const boost::gregorian::first_day_of_the_week_before & fdb)725 operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::first_day_of_the_week_before& fdb) { 726 boost::io::ios_flags_saver iflags(os); 727 typedef boost::date_time::date_facet<date, CharT> custom_date_facet; 728 std::ostreambuf_iterator<CharT> output_itr(os); 729 if (std::has_facet<custom_date_facet>(os.getloc())) { 730 std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), fdb); 731 } 732 else { 733 custom_date_facet* f = new custom_date_facet(); 734 std::locale l = std::locale(os.getloc(), f); 735 os.imbue(l); 736 f->put(output_itr, os, os.fill(), fdb); 737 } 738 return os; 739 } 740 741 //! input operator for first_day_of_the_week_before 742 template <class CharT, class Traits> 743 inline 744 std::basic_istream<CharT, Traits>& operator >>(std::basic_istream<CharT,Traits> & is,first_day_of_the_week_before & fkb)745 operator>>(std::basic_istream<CharT, Traits>& is, 746 first_day_of_the_week_before& fkb) 747 { 748 boost::io::ios_flags_saver iflags(is); 749 typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 750 if (strm_sentry) { 751 try { 752 typedef typename date_time::date_input_facet<date, CharT> date_input_facet; 753 754 std::istreambuf_iterator<CharT,Traits> sit(is), str_end; 755 if(std::has_facet<date_input_facet>(is.getloc())) { 756 std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkb); 757 } 758 else { 759 date_input_facet* f = new date_input_facet(); 760 std::locale l = std::locale(is.getloc(), f); 761 is.imbue(l); 762 f->get(sit, str_end, is, fkb); 763 } 764 } 765 catch(...) { 766 std::ios_base::iostate exception_mask = is.exceptions(); 767 if(std::ios_base::failbit & exception_mask) { 768 try { is.setstate(std::ios_base::failbit); } 769 catch(std::ios_base::failure&) {} 770 throw; // rethrow original exception 771 } 772 else { 773 is.setstate(std::ios_base::failbit); 774 } 775 776 } 777 } 778 return is; 779 } 780 781 782 } } // namespaces 783 784 #endif // DATE_TIME_GREGORIAN_IO_HPP__ 785