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