boost/date_time/gregorian/greg_serialize.hpp

   1 #ifndef GREGORIAN_SERIALIZE_HPP___
   2 #define GREGORIAN_SERIALIZE_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 "boost/date_time/gregorian/gregorian_types.hpp"
  13 #include "boost/date_time/gregorian/parsers.hpp"
  14 #include "boost/serialization/split_free.hpp"
  15
  16
  17 // macros to split serialize functions into save & load functions
  18 // An expanded version is below for gregorian::date
  19 // NOTE: these macros define template functions in the boost::serialization namespace.
  20 // They must be expanded *outside* of any namespace
  21 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::date_duration)
  22 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::date_duration::duration_rep)
  23 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::date_period)
  24 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::greg_month)
  25 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::greg_day)
  26 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::greg_weekday)
  27 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::partial_date)
  28 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::nth_kday_of_month)
  29 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::first_kday_of_month)
  30 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::last_kday_of_month)
  31 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::first_kday_before)
  32 BOOST_SERIALIZATION_SPLIT_FREE(::boost::gregorian::first_kday_after)
  33
  34 namespace boost {
  35 namespace serialization {
  36
  37 /*! Method that does serialization for gregorian::date -- splits to load/save
  38  */
  39 template<class Archive>
  40 inline void serialize(Archive & ar,
  41                       ::boost::gregorian::date & d,
  42                       const unsigned int file_version)
  43 {
  44   split_free(ar, d, file_version);
  45 }
  46
  47 //! Function to save gregorian::date objects using serialization lib
  48 /*! Dates are serialized into a string for transport and storage.
  49  *  While it would be more efficient to store the internal
  50  *  integer used to manipulate the dates, it is an unstable solution.
  51  */
  52 template<class Archive>
  53 void save(Archive & ar,
  54           const ::boost::gregorian::date & d,
  55           unsigned int /* version */)
  56 {
  57   std::string ds = to_iso_string(d);
  58   ar & make_nvp("date", ds);
  59 }
  60
  61 //! Function to load gregorian::date objects using serialization lib
  62 /*! Dates are serialized into a string for transport and storage.
  63  *  While it would be more efficient to store the internal
  64  *  integer used to manipulate the dates, it is an unstable solution.
  65  */
  66 template<class Archive>
  67 void load(Archive & ar,
  68           ::boost::gregorian::date & d,
  69           unsigned int /*version*/)
  70 {
  71   std::string ds;
  72   ar & make_nvp("date", ds);
  73   try{
  74     d = ::boost::gregorian::from_undelimited_string(ds);
  75   }catch(bad_lexical_cast&) {
  76     gregorian::special_values sv = gregorian::special_value_from_string(ds);
  77     if(sv == gregorian::not_special) {
  78       throw; // no match found, rethrow original exception
  79     }
  80     else {
  81       d = gregorian::date(sv);
  82     }
  83   }
  84 }
  85
  86
  87 //!override needed b/c no default constructor
  88 template<class Archive>
  89 inline void load_construct_data(Archive & ar,
  90                                 ::boost::gregorian::date* dp,
  91                                 const unsigned int /*file_version*/)
  92 {
  93   // retrieve data from archive required to construct new
  94   // invoke inplace constructor to initialize instance of date
  95   ::new(dp) ::boost::gregorian::date(::boost::gregorian::not_a_date_time);
  96 }
  97
  98 /**** date_duration ****/
  99
 100 //! Function to save gregorian::date_duration objects using serialization lib
 101 template<class Archive>
 102 void save(Archive & ar, const gregorian::date_duration & dd,
 103           unsigned int /*version*/)
 104 {
 105   typename gregorian::date_duration::duration_rep dr = dd.get_rep();
 106   ar & make_nvp("date_duration", dr);
 107 }
 108 //! Function to load gregorian::date_duration objects using serialization lib
 109 template<class Archive>
 110 void load(Archive & ar, gregorian::date_duration & dd, unsigned int /*version*/)
 111 {
 112   typename gregorian::date_duration::duration_rep dr(0);
 113   ar & make_nvp("date_duration", dr);
 114   dd = gregorian::date_duration(dr);
 115 }
 116 //!override needed b/c no default constructor
 117 template<class Archive>
 118 inline void load_construct_data(Archive & ar, gregorian::date_duration* dd,
 119                                 const unsigned int /*file_version*/)
 120 {
 121   ::new(dd) gregorian::date_duration(gregorian::not_a_date_time);
 122 }
 123
 124 /**** date_duration::duration_rep (most likely int_adapter) ****/
 125
 126 //! helper unction to save date_duration objects using serialization lib
 127 template<class Archive>
 128 void save(Archive & ar, const gregorian::date_duration::duration_rep & dr,
 129           unsigned int /*version*/)
 130 {
 131   typename gregorian::date_duration::duration_rep::int_type it = dr.as_number();
 132   ar & make_nvp("date_duration_duration_rep", it);
 133 }
 134 //! helper function to load date_duration objects using serialization lib
 135 template<class Archive>
 136 void load(Archive & ar, gregorian::date_duration::duration_rep & dr, unsigned int /*version*/)
 137 {
 138   typename gregorian::date_duration::duration_rep::int_type it(0);
 139   ar & make_nvp("date_duration_duration_rep", it);
 140   dr = gregorian::date_duration::duration_rep::int_type(it);
 141 }
 142 //!override needed b/c no default constructor
 143 template<class Archive>
 144 inline void load_construct_data(Archive & ar, gregorian::date_duration::duration_rep* dr,
 145                                 const unsigned int /*file_version*/)
 146 {
 147   ::new(dr) gregorian::date_duration::duration_rep(0);
 148 }
 149
 150 /**** date_period ****/
 151
 152 //! Function to save gregorian::date_period objects using serialization lib
 153 /*! date_period objects are broken down into 2 parts for serialization:
 154  * the begining date object and the end date object
 155  */
 156 template<class Archive>
 157 void save(Archive & ar, const gregorian::date_period& dp,
 158           unsigned int /*version*/)
 159 {
 160   gregorian::date d1 = dp.begin();
 161   gregorian::date d2 = dp.end();
 162   ar & make_nvp("date_period_begin_date", d1);
 163   ar & make_nvp("date_period_end_date", d2);
 164 }
 165 //! Function to load gregorian::date_period objects using serialization lib
 166 /*! date_period objects are broken down into 2 parts for serialization:
 167  * the begining date object and the end date object
 168  */
 169 template<class Archive>
 170 void load(Archive & ar, gregorian::date_period& dp, unsigned int /*version*/)
 171 {
 172   gregorian::date d1(gregorian::not_a_date_time);
 173   gregorian::date d2(gregorian::not_a_date_time);
 174   ar & make_nvp("date_period_begin_date", d1);
 175   ar & make_nvp("date_period_end_date", d2);
 176   dp = gregorian::date_period(d1,d2);
 177 }
 178 //!override needed b/c no default constructor
 179 template<class Archive>
 180 inline void load_construct_data(Archive & ar, gregorian::date_period* dp,
 181                                 const unsigned int /*file_version*/)
 182 {
 183   gregorian::date d(gregorian::not_a_date_time);
 184   gregorian::date_duration dd(1);
 185   ::new(dp) gregorian::date_period(d,dd);
 186 }
 187
 188 /**** greg_month ****/
 189
 190 //! Function to save gregorian::greg_month objects using serialization lib
 191 template<class Archive>
 192 void save(Archive & ar, const gregorian::greg_month& gm,
 193           unsigned int /*version*/)
 194 {
 195   unsigned short us = gm.as_number();
 196   ar & make_nvp("greg_month", us);
 197 }
 198 //! Function to load gregorian::greg_month objects using serialization lib
 199 template<class Archive>
 200 void load(Archive & ar, gregorian::greg_month& gm, unsigned int /*version*/)
 201 {
 202   unsigned short us;
 203   ar & make_nvp("greg_month", us);
 204   gm = gregorian::greg_month(us);
 205 }
 206 //!override needed b/c no default constructor
 207 template<class Archive>
 208 inline void load_construct_data(Archive & ar, gregorian::greg_month* gm,
 209                                 const unsigned int /*file_version*/)
 210 {
 211   ::new(gm) gregorian::greg_month(1);
 212 }
 213
 214 /**** greg_day ****/
 215
 216 //! Function to save gregorian::greg_day objects using serialization lib
 217 template<class Archive>
 218 void save(Archive & ar, const gregorian::greg_day& gd,
 219           unsigned int /*version*/)
 220 {
 221   unsigned short us = gd.as_number();
 222   ar & make_nvp("greg_day", us);
 223 }
 224 //! Function to load gregorian::greg_day objects using serialization lib
 225 template<class Archive>
 226 void load(Archive & ar, gregorian::greg_day& gd, unsigned int /*version*/)
 227 {
 228   unsigned short us;
 229   ar & make_nvp("greg_day", us);
 230   gd = gregorian::greg_day(us);
 231 }
 232 //!override needed b/c no default constructor
 233 template<class Archive>
 234 inline void load_construct_data(Archive & ar, gregorian::greg_day* gd,
 235                                 const unsigned int /*file_version*/)
 236 {
 237   ::new(gd) gregorian::greg_day(1);
 238 }
 239
 240 /**** greg_weekday ****/
 241
 242 //! Function to save gregorian::greg_weekday objects using serialization lib
 243 template<class Archive>
 244 void save(Archive & ar, const gregorian::greg_weekday& gd,
 245           unsigned int /*version*/)
 246 {
 247   unsigned short us = gd.as_number();
 248   ar & make_nvp("greg_weekday", us);
 249 }
 250 //! Function to load gregorian::greg_weekday objects using serialization lib
 251 template<class Archive>
 252 void load(Archive & ar, gregorian::greg_weekday& gd, unsigned int /*version*/)
 253 {
 254   unsigned short us;
 255   ar & make_nvp("greg_weekday", us);
 256   gd = gregorian::greg_weekday(us);
 257 }
 258 //!override needed b/c no default constructor
 259 template<class Archive>
 260 inline void load_construct_data(Archive & ar, gregorian::greg_weekday* gd,
 261                                 const unsigned int /*file_version*/)
 262 {
 263   ::new(gd) gregorian::greg_weekday(1);
 264 }
 265
 266 /**** date_generators ****/
 267
 268 /**** partial_date ****/
 269
 270 //! Function to save gregorian::partial_date objects using serialization lib
 271 /*! partial_date objects are broken down into 2 parts for serialization:
 272  * the day (typically greg_day) and month (typically greg_month) objects
 273  */
 274 template<class Archive>
 275 void save(Archive & ar, const gregorian::partial_date& pd,
 276           unsigned int /*version*/)
 277 {
 278   gregorian::greg_day gd(pd.day());
 279   gregorian::greg_month gm(pd.month().as_number());
 280   ar & make_nvp("partial_date_day", gd);
 281   ar & make_nvp("partial_date_month", gm);
 282 }
 283 //! Function to load gregorian::partial_date objects using serialization lib
 284 /*! partial_date objects are broken down into 2 parts for serialization:
 285  * the day (greg_day) and month (greg_month) objects
 286  */
 287 template<class Archive>
 288 void load(Archive & ar, gregorian::partial_date& pd, unsigned int /*version*/)
 289 {
 290   gregorian::greg_day gd(1);
 291   gregorian::greg_month gm(1);
 292   ar & make_nvp("partial_date_day", gd);
 293   ar & make_nvp("partial_date_month", gm);
 294   pd = gregorian::partial_date(gd,gm);
 295 }
 296 //!override needed b/c no default constructor
 297 template<class Archive>
 298 inline void load_construct_data(Archive & ar, gregorian::partial_date* pd,
 299                                 const unsigned int /*file_version*/)
 300 {
 301   gregorian::greg_month gm(1);
 302   gregorian::greg_day gd(1);
 303   ::new(pd) gregorian::partial_date(gd,gm);
 304 }
 305
 306 /**** nth_kday_of_month ****/
 307
 308 //! Function to save nth_day_of_the_week_in_month objects using serialization lib
 309 /*! nth_day_of_the_week_in_month  objects are broken down into 3 parts for
 310  * serialization: the week number, the day of the week, and the month
 311  */
 312 template<class Archive>
 313 void save(Archive & ar, const gregorian::nth_kday_of_month& nkd,
 314           unsigned int /*version*/)
 315 {
 316   typename gregorian::nth_kday_of_month::week_num wn(nkd.nth_week());
 317   typename gregorian::nth_kday_of_month::day_of_week_type d(nkd.day_of_week().as_number());
 318   typename gregorian::nth_kday_of_month::month_type m(nkd.month().as_number());
 319   ar & make_nvp("nth_kday_of_month_week_num", wn);
 320   ar & make_nvp("nth_kday_of_month_day_of_week", d);
 321   ar & make_nvp("nth_kday_of_month_month", m);
 322 }
 323 //! Function to load nth_day_of_the_week_in_month objects using serialization lib
 324 /*! nth_day_of_the_week_in_month  objects are broken down into 3 parts for
 325  * serialization: the week number, the day of the week, and the month
 326  */
 327 template<class Archive>
 328 void load(Archive & ar, gregorian::nth_kday_of_month& nkd, unsigned int /*version*/)
 329 {
 330   typename gregorian::nth_kday_of_month::week_num wn(gregorian::nth_kday_of_month::first);
 331   typename gregorian::nth_kday_of_month::day_of_week_type d(gregorian::Monday);
 332   typename gregorian::nth_kday_of_month::month_type m(gregorian::Jan);
 333   ar & make_nvp("nth_kday_of_month_week_num", wn);
 334   ar & make_nvp("nth_kday_of_month_day_of_week", d);
 335   ar & make_nvp("nth_kday_of_month_month", m);
 336
 337   nkd = gregorian::nth_kday_of_month(wn,d,m);
 338 }
 339 //!override needed b/c no default constructor
 340 template<class Archive>
 341 inline void load_construct_data(Archive & ar,
 342                                 gregorian::nth_kday_of_month* nkd,
 343                                 const unsigned int /*file_version*/)
 344 {
 345   // values used are not significant
 346   ::new(nkd) gregorian::nth_kday_of_month(gregorian::nth_kday_of_month::first,
 347                                          gregorian::Monday,gregorian::Jan);
 348 }
 349
 350 /**** first_kday_of_month ****/
 351
 352 //! Function to save first_day_of_the_week_in_month objects using serialization lib
 353 /*! first_day_of_the_week_in_month objects are broken down into 2 parts for
 354  * serialization: the day of the week, and the month
 355  */
 356 template<class Archive>
 357 void save(Archive & ar, const gregorian::first_kday_of_month& fkd,
 358           unsigned int /*version*/)
 359 {
 360   typename gregorian::first_kday_of_month::day_of_week_type d(fkd.day_of_week().as_number());
 361   typename gregorian::first_kday_of_month::month_type m(fkd.month().as_number());
 362   ar & make_nvp("first_kday_of_month_day_of_week", d);
 363   ar & make_nvp("first_kday_of_month_month", m);
 364 }
 365 //! Function to load first_day_of_the_week_in_month objects using serialization lib
 366 /*! first_day_of_the_week_in_month objects are broken down into 2 parts for
 367  * serialization: the day of the week, and the month
 368  */
 369 template<class Archive>
 370 void load(Archive & ar, gregorian::first_kday_of_month& fkd, unsigned int /*version*/)
 371 {
 372   typename gregorian::first_kday_of_month::day_of_week_type d(gregorian::Monday);
 373   typename gregorian::first_kday_of_month::month_type m(gregorian::Jan);
 374   ar & make_nvp("first_kday_of_month_day_of_week", d);
 375   ar & make_nvp("first_kday_of_month_month", m);
 376
 377   fkd = gregorian::first_kday_of_month(d,m);
 378 }
 379 //!override needed b/c no default constructor
 380 template<class Archive>
 381 inline void load_construct_data(Archive & ar,
 382                                 gregorian::first_kday_of_month* fkd,
 383                                 const unsigned int /*file_version*/)
 384 {
 385   // values used are not significant
 386   ::new(fkd) gregorian::first_kday_of_month(gregorian::Monday,gregorian::Jan);
 387 }
 388
 389 /**** last_kday_of_month ****/
 390
 391 //! Function to save last_day_of_the_week_in_month objects using serialization lib
 392 /*! last_day_of_the_week_in_month objects are broken down into 2 parts for
 393  * serialization: the day of the week, and the month
 394  */
 395 template<class Archive>
 396 void save(Archive & ar, const gregorian::last_kday_of_month& lkd,
 397           unsigned int /*version*/)
 398 {
 399   typename gregorian::last_kday_of_month::day_of_week_type d(lkd.day_of_week().as_number());
 400   typename gregorian::last_kday_of_month::month_type m(lkd.month().as_number());
 401   ar & make_nvp("last_kday_of_month_day_of_week", d);
 402   ar & make_nvp("last_kday_of_month_month", m);
 403 }
 404 //! Function to load last_day_of_the_week_in_month objects using serialization lib
 405 /*! last_day_of_the_week_in_month objects are broken down into 2 parts for
 406  * serialization: the day of the week, and the month
 407  */
 408 template<class Archive>
 409 void load(Archive & ar, gregorian::last_kday_of_month& lkd, unsigned int /*version*/)
 410 {
 411   typename gregorian::last_kday_of_month::day_of_week_type d(gregorian::Monday);
 412   typename gregorian::last_kday_of_month::month_type m(gregorian::Jan);
 413   ar & make_nvp("last_kday_of_month_day_of_week", d);
 414   ar & make_nvp("last_kday_of_month_month", m);
 415
 416   lkd = gregorian::last_kday_of_month(d,m);
 417 }
 418 //!override needed b/c no default constructor
 419 template<class Archive>
 420 inline void load_construct_data(Archive & ar,
 421                                 gregorian::last_kday_of_month* lkd,
 422                                 const unsigned int /*file_version*/)
 423 {
 424   // values used are not significant
 425   ::new(lkd) gregorian::last_kday_of_month(gregorian::Monday,gregorian::Jan);
 426 }
 427
 428 /**** first_kday_before ****/
 429
 430 //! Function to save first_day_of_the_week_before objects using serialization lib
 431 template<class Archive>
 432 void save(Archive & ar, const gregorian::first_kday_before& fkdb,
 433           unsigned int /*version*/)
 434 {
 435   typename gregorian::first_kday_before::day_of_week_type d(fkdb.day_of_week().as_number());
 436   ar & make_nvp("first_kday_before_day_of_week", d);
 437 }
 438 //! Function to load first_day_of_the_week_before objects using serialization lib
 439 template<class Archive>
 440 void load(Archive & ar, gregorian::first_kday_before& fkdb, unsigned int /*version*/)
 441 {
 442   typename gregorian::first_kday_before::day_of_week_type d(gregorian::Monday);
 443   ar & make_nvp("first_kday_before_day_of_week", d);
 444
 445   fkdb = gregorian::first_kday_before(d);
 446 }
 447 //!override needed b/c no default constructor
 448 template<class Archive>
 449 inline void load_construct_data(Archive & ar,
 450                                 gregorian::first_kday_before* fkdb,
 451                                 const unsigned int /*file_version*/)
 452 {
 453   // values used are not significant
 454   ::new(fkdb) gregorian::first_kday_before(gregorian::Monday);
 455 }
 456
 457 /**** first_kday_after ****/
 458
 459 //! Function to save first_day_of_the_week_after objects using serialization lib
 460 template<class Archive>
 461 void save(Archive & ar, const gregorian::first_kday_after& fkda,
 462           unsigned int /*version*/)
 463 {
 464   typename gregorian::first_kday_after::day_of_week_type d(fkda.day_of_week().as_number());
 465   ar & make_nvp("first_kday_after_day_of_week", d);
 466 }
 467 //! Function to load first_day_of_the_week_after objects using serialization lib
 468 template<class Archive>
 469 void load(Archive & ar, gregorian::first_kday_after& fkda, unsigned int /*version*/)
 470 {
 471   typename gregorian::first_kday_after::day_of_week_type d(gregorian::Monday);
 472   ar & make_nvp("first_kday_after_day_of_week", d);
 473
 474   fkda = gregorian::first_kday_after(d);
 475 }
 476 //!override needed b/c no default constructor
 477 template<class Archive>
 478 inline void load_construct_data(Archive & ar,
 479                                 gregorian::first_kday_after* fkda,
 480                                 const unsigned int /*file_version*/)
 481 {
 482   // values used are not significant
 483   ::new(fkda) gregorian::first_kday_after(gregorian::Monday);
 484 }
 485
 486 } // namespace serialization
 487 } // namespace boost
 488
 489 #endif