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