Ugly, not-to-be-pushed sucking in of all of Boost to get windows to work.
[dyninst.git] / external / boost / date_time / posix_time / time_serialize.hpp
1 #ifndef POSIX_TIME_SERIALIZE_HPP___
2 #define POSIX_TIME_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 or http://www.boost.org/LICENSE-1.0)
8  * Author: Jeff Garland, Bart Garst
9  * $Date: 2005/06/21 03:33:15 $
10  */
11
12 #include "boost/date_time/posix_time/posix_time.hpp"
13 #include "boost/date_time/gregorian/greg_serialize.hpp"
14 #include "boost/serialization/split_free.hpp"
15
16
17 // macros to split serialize functions into save & load functions
18 // NOTE: these macros define template functions in the boost::serialization namespace.
19 // They must be expanded *outside* of any namespace
20 BOOST_SERIALIZATION_SPLIT_FREE(boost::posix_time::ptime)
21 BOOST_SERIALIZATION_SPLIT_FREE(boost::posix_time::time_duration)
22 BOOST_SERIALIZATION_SPLIT_FREE(boost::posix_time::time_period)
23
24 namespace boost {
25 namespace serialization {
26
27
28 /*** time_duration ***/
29
30 //! Function to save posix_time::time_duration objects using serialization lib
31 /*! time_duration objects are broken down into 4 parts for serialization:
32  * types are hour_type, min_type, sec_type, and fractional_seconds_type
33  * as defined in the time_duration class
34  */
35 template<class Archive>
36 void save(Archive & ar, 
37           const posix_time::time_duration& td, 
38           unsigned int version)
39 {
40   // serialize a bool so we know how to read this back in later
41   bool is_special = td.is_special();
42   ar & make_nvp("is_special", is_special);
43   if(is_special) {
44     std::string s = to_simple_string(td);
45     ar & make_nvp("sv_time_duration", s);
46   }
47   else {
48     typename posix_time::time_duration::hour_type h = td.hours();
49     typename posix_time::time_duration::min_type m = td.minutes();
50     typename posix_time::time_duration::sec_type s = td.seconds();
51     typename posix_time::time_duration::fractional_seconds_type fs = td.fractional_seconds();
52     ar & make_nvp("time_duration_hours", h);
53     ar & make_nvp("time_duration_minutes", m);
54     ar & make_nvp("time_duration_seconds", s);
55     ar & make_nvp("time_duration_fractional_seconds", fs);
56   }
57 }
58
59 //! Function to load posix_time::time_duration objects using serialization lib
60 /*! time_duration objects are broken down into 4 parts for serialization:
61  * types are hour_type, min_type, sec_type, and fractional_seconds_type
62  * as defined in the time_duration class
63  */
64 template<class Archive>
65 void load(Archive & ar, 
66           posix_time::time_duration & td, 
67           unsigned int version)
68 {
69   bool is_special = false;
70   ar & make_nvp("is_special", is_special);
71   if(is_special) {
72     std::string s;
73     ar & make_nvp("sv_time_duration", s);
74     posix_time::special_values sv = gregorian::special_value_from_string(s);
75     td = posix_time::time_duration(sv);
76   }
77   else {
78     typename posix_time::time_duration::hour_type h(0);
79     typename posix_time::time_duration::min_type m(0);
80     typename posix_time::time_duration::sec_type s(0);
81     typename posix_time::time_duration::fractional_seconds_type fs(0);
82     ar & make_nvp("time_duration_hours", h);
83     ar & make_nvp("time_duration_minutes", m);
84     ar & make_nvp("time_duration_seconds", s);
85     ar & make_nvp("time_duration_fractional_seconds", fs);
86     td = posix_time::time_duration(h,m,s,fs);
87   }
88 }
89
90 // no load_construct_data function provided as time_duration provides a
91 // default constructor
92
93 /*** ptime ***/
94
95 //! Function to save posix_time::ptime objects using serialization lib
96 /*! ptime objects are broken down into 2 parts for serialization:
97  * a date object and a time_duration onject
98  */
99 template<class Archive>
100 void save(Archive & ar, 
101           const posix_time::ptime& pt, 
102           unsigned int version)
103 {
104   // from_iso_string does not include fractional seconds
105   // therefore date and time_duration are used
106   typename posix_time::ptime::date_type d = pt.date();
107   ar & make_nvp("ptime_date", d);
108   if(!pt.is_special()) {
109     typename posix_time::ptime::time_duration_type td = pt.time_of_day();
110     ar & make_nvp("ptime_time_duration", td);
111   }
112 }
113
114 //! Function to load posix_time::ptime objects using serialization lib
115 /*! ptime objects are broken down into 2 parts for serialization:
116  * a date object and a time_duration onject
117  */
118 template<class Archive>
119 void load(Archive & ar, 
120           posix_time::ptime & pt, 
121           unsigned int version)
122 {
123   // from_iso_string does not include fractional seconds
124   // therefore date and time_duration are used
125   typename posix_time::ptime::date_type d(posix_time::not_a_date_time);
126   typename posix_time::ptime::time_duration_type td;
127   ar & make_nvp("ptime_date", d);
128   if(!d.is_special()) {
129     ar & make_nvp("ptime_time_duration", td);
130     pt = boost::posix_time::ptime(d,td);
131   }
132   else {
133     pt = boost::posix_time::ptime(d.as_special());
134   }
135     
136 }
137
138 //!override needed b/c no default constructor
139 template<class Archive>
140 inline void load_construct_data(Archive & ar, 
141                                 posix_time::ptime* pt, 
142                                 const unsigned int file_version)
143 {
144   // retrieve data from archive required to construct new 
145   // invoke inplace constructor to initialize instance of date
146   new(pt) boost::posix_time::ptime(boost::posix_time::not_a_date_time);
147 }
148
149 /*** time_period ***/
150
151 //! Function to save posix_time::time_period objects using serialization lib
152 /*! time_period objects are broken down into 2 parts for serialization:
153  * a begining ptime object and an ending ptime object
154  */
155 template<class Archive>
156 void save(Archive & ar, 
157           const posix_time::time_period& tp, 
158           unsigned int version)
159 {
160   posix_time::ptime beg(tp.begin().date(), tp.begin().time_of_day());
161   posix_time::ptime end(tp.end().date(), tp.end().time_of_day());
162   ar & make_nvp("time_period_begin", beg);
163   ar & make_nvp("time_period_end", end);
164 }
165
166 //! Function to load posix_time::time_period objects using serialization lib
167 /*! time_period objects are broken down into 2 parts for serialization:
168  * a begining ptime object and an ending ptime object
169  */
170 template<class Archive>
171 void load(Archive & ar, 
172           boost::posix_time::time_period & tp, 
173           unsigned int version)
174 {
175   posix_time::time_duration td(1,0,0);
176   gregorian::date d(gregorian::not_a_date_time);
177   posix_time::ptime beg(d,td);
178   posix_time::ptime end(d,td);
179   ar & make_nvp("time_period_begin", beg);
180   ar & make_nvp("time_period_end", end);
181   tp = boost::posix_time::time_period(beg, end);
182 }
183
184 //!override needed b/c no default constructor
185 template<class Archive>
186 inline void load_construct_data(Archive & ar, 
187                                 boost::posix_time::time_period* tp, 
188                                 const unsigned int file_version)
189 {
190   posix_time::time_duration td(1,0,0);
191   gregorian::date d(gregorian::not_a_date_time);
192   posix_time::ptime beg(d,td);
193   posix_time::ptime end(d,td);
194   new(tp) boost::posix_time::time_period(beg,end);
195 }
196
197 } // namespace serialization
198 } // namespace boost
199
200 #endif