1 | #ifndef DATE_TIME_DATE_GENERATORS_HPP__ |
2 | #define DATE_TIME_DATE_GENERATORS_HPP__ |
3 | |
4 | /* Copyright (c) 2002,2003,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 | /*! @file date_generators.hpp |
13 | Definition and implementation of date algorithm templates |
14 | */ |
15 | |
16 | #include <stdexcept> |
17 | #include <sstream> |
18 | #include <boost/throw_exception.hpp> |
19 | #include <boost/date_time/date.hpp> |
20 | #include <boost/date_time/compiler_config.hpp> |
21 | |
22 | namespace boost { |
23 | namespace date_time { |
24 | |
25 | //! Base class for all generators that take a year and produce a date. |
26 | /*! This class is a base class for polymorphic function objects that take |
27 | a year and produce a concrete date. |
28 | @param date_type The type representing a date. This type must |
29 | export a calender_type which defines a year_type. |
30 | */ |
31 | template<class date_type> |
32 | class year_based_generator |
33 | { |
34 | public: |
35 | typedef typename date_type::calendar_type calendar_type; |
36 | typedef typename calendar_type::year_type year_type; |
37 | year_based_generator() {} |
38 | virtual ~year_based_generator() {} |
39 | virtual date_type get_date(year_type y) const = 0; |
40 | //! Returns a string for use in a POSIX time_zone string |
41 | virtual std::string to_string() const =0; |
42 | }; |
43 | |
44 | //! Generates a date by applying the year to the given month and day. |
45 | /*! |
46 | Example usage: |
47 | @code |
48 | partial_date pd(1, Jan); |
49 | partial_date pd2(70); |
50 | date d = pd.get_date(2002); //2002-Jan-01 |
51 | date d2 = pd2.get_date(2002); //2002-Mar-10 |
52 | @endcode |
53 | \ingroup date_alg |
54 | */ |
55 | template<class date_type> |
56 | class partial_date : public year_based_generator<date_type> |
57 | { |
58 | public: |
59 | typedef typename date_type::calendar_type calendar_type; |
60 | typedef typename calendar_type::day_type day_type; |
61 | typedef typename calendar_type::month_type month_type; |
62 | typedef typename calendar_type::year_type year_type; |
63 | typedef typename date_type::duration_type duration_type; |
64 | typedef typename duration_type::duration_rep duration_rep; |
65 | partial_date(day_type d, month_type m) : |
66 | day_(d), |
67 | month_(m) |
68 | {} |
69 | //! Partial date created from number of days into year. Range 1-366 |
70 | /*! Allowable values range from 1 to 366. 1=Jan1, 366=Dec31. If argument |
71 | * exceeds range, partial_date will be created with closest in-range value. |
72 | * 60 will always be Feb29, if get_date() is called with a non-leap year |
73 | * an exception will be thrown */ |
74 | partial_date(duration_rep days) : |
75 | day_(1), // default values |
76 | month_(1) |
77 | { |
78 | date_type d1(2000,1,1); |
79 | if(days > 1) { |
80 | if(days > 366) // prevents wrapping |
81 | { |
82 | days = 366; |
83 | } |
84 | days = days - 1; |
85 | duration_type dd(days); |
86 | d1 = d1 + dd; |
87 | } |
88 | day_ = d1.day(); |
89 | month_ = d1.month(); |
90 | } |
91 | //! Return a concrete date when provided with a year specific year. |
92 | /*! Will throw an 'invalid_argument' exception if a partial_date object, |
93 | * instantiated with Feb-29, has get_date called with a non-leap year. |
94 | * Example: |
95 | * @code |
96 | * partial_date pd(29, Feb); |
97 | * pd.get_date(2003); // throws invalid_argument exception |
98 | * pg.get_date(2000); // returns 2000-2-29 |
99 | * @endcode |
100 | */ |
101 | date_type get_date(year_type y) const |
102 | { |
103 | if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) { |
104 | std::ostringstream ss; |
105 | ss << "No Feb 29th in given year of " << y << "." ; |
106 | boost::throw_exception(e: std::invalid_argument(ss.str())); |
107 | } |
108 | return date_type(y, month_, day_); |
109 | } |
110 | date_type operator()(year_type y) const |
111 | { |
112 | return get_date(y); |
113 | //return date_type(y, month_, day_); |
114 | } |
115 | bool operator==(const partial_date& rhs) const |
116 | { |
117 | return (month_ == rhs.month_) && (day_ == rhs.day_); |
118 | } |
119 | bool operator<(const partial_date& rhs) const |
120 | { |
121 | if (month_ < rhs.month_) return true; |
122 | if (month_ > rhs.month_) return false; |
123 | //months are equal |
124 | return (day_ < rhs.day_); |
125 | } |
126 | |
127 | // added for streaming purposes |
128 | month_type month() const |
129 | { |
130 | return month_; |
131 | } |
132 | day_type day() const |
133 | { |
134 | return day_; |
135 | } |
136 | |
137 | //! Returns string suitable for use in POSIX time zone string |
138 | /*! Returns string formatted with up to 3 digits: |
139 | * Jan-01 == "0" |
140 | * Feb-29 == "58" |
141 | * Dec-31 == "365" */ |
142 | virtual std::string to_string() const |
143 | { |
144 | std::ostringstream ss; |
145 | date_type d(2004, month_, day_); |
146 | unsigned short c = d.day_of_year(); |
147 | c--; // numbered 0-365 while day_of_year is 1 based... |
148 | ss << c; |
149 | return ss.str(); |
150 | } |
151 | private: |
152 | day_type day_; |
153 | month_type month_; |
154 | }; |
155 | |
156 | |
157 | //! Returns nth arg as string. 1 -> "first", 2 -> "second", max is 5. |
158 | BOOST_DATE_TIME_DECL const char* nth_as_str(int n); |
159 | |
160 | //! Useful generator functor for finding holidays |
161 | /*! Based on the idea in Cal. Calc. for finding holidays that are |
162 | * the 'first Monday of September'. When instantiated with |
163 | * 'fifth' kday of month, the result will be the last kday of month |
164 | * which can be the fourth or fifth depending on the structure of |
165 | * the month. |
166 | * |
167 | * The algorithm here basically guesses for the first |
168 | * day of the month. Then finds the first day of the correct |
169 | * type. That is, if the first of the month is a Tuesday |
170 | * and it needs Wenesday then we simply increment by a day |
171 | * and then we can add the length of a week until we get |
172 | * to the 'nth kday'. There are probably more efficient |
173 | * algorithms based on using a mod 7, but this one works |
174 | * reasonably well for basic applications. |
175 | * \ingroup date_alg |
176 | */ |
177 | template<class date_type> |
178 | class nth_kday_of_month : public year_based_generator<date_type> |
179 | { |
180 | public: |
181 | typedef typename date_type::calendar_type calendar_type; |
182 | typedef typename calendar_type::day_of_week_type day_of_week_type; |
183 | typedef typename calendar_type::month_type month_type; |
184 | typedef typename calendar_type::year_type year_type; |
185 | typedef typename date_type::duration_type duration_type; |
186 | enum week_num {first=1, second, third, fourth, fifth}; |
187 | nth_kday_of_month(week_num week_no, |
188 | day_of_week_type dow, |
189 | month_type m) : |
190 | month_(m), |
191 | wn_(week_no), |
192 | dow_(dow) |
193 | {} |
194 | //! Return a concrete date when provided with a year specific year. |
195 | date_type get_date(year_type y) const |
196 | { |
197 | date_type d(y, month_, 1); //first day of month |
198 | duration_type one_day(1); |
199 | duration_type one_week(7); |
200 | while (dow_ != d.day_of_week()) { |
201 | d = d + one_day; |
202 | } |
203 | int week = 1; |
204 | while (week < wn_) { |
205 | d = d + one_week; |
206 | week++; |
207 | } |
208 | // remove wrapping to next month behavior |
209 | if(d.month() != month_) { |
210 | d = d - one_week; |
211 | } |
212 | return d; |
213 | } |
214 | // added for streaming |
215 | month_type month() const |
216 | { |
217 | return month_; |
218 | } |
219 | week_num nth_week() const |
220 | { |
221 | return wn_; |
222 | } |
223 | day_of_week_type day_of_week() const |
224 | { |
225 | return dow_; |
226 | } |
227 | const char* nth_week_as_str() const |
228 | { |
229 | return nth_as_str(wn_); |
230 | } |
231 | //! Returns string suitable for use in POSIX time zone string |
232 | /*! Returns a string formatted as "M4.3.0" ==> 3rd Sunday in April. */ |
233 | virtual std::string to_string() const |
234 | { |
235 | std::ostringstream ss; |
236 | ss << 'M' |
237 | << static_cast<int>(month_) << '.' |
238 | << static_cast<int>(wn_) << '.' |
239 | << static_cast<int>(dow_); |
240 | return ss.str(); |
241 | } |
242 | private: |
243 | month_type month_; |
244 | week_num wn_; |
245 | day_of_week_type dow_; |
246 | }; |
247 | |
248 | //! Useful generator functor for finding holidays and daylight savings |
249 | /*! Similar to nth_kday_of_month, but requires less paramters |
250 | * \ingroup date_alg |
251 | */ |
252 | template<class date_type> |
253 | class first_kday_of_month : public year_based_generator<date_type> |
254 | { |
255 | public: |
256 | typedef typename date_type::calendar_type calendar_type; |
257 | typedef typename calendar_type::day_of_week_type day_of_week_type; |
258 | typedef typename calendar_type::month_type month_type; |
259 | typedef typename calendar_type::year_type year_type; |
260 | typedef typename date_type::duration_type duration_type; |
261 | //!Specify the first 'Sunday' in 'April' spec |
262 | /*!@param dow The day of week, eg: Sunday, Monday, etc |
263 | * @param m The month of the year, eg: Jan, Feb, Mar, etc |
264 | */ |
265 | first_kday_of_month(day_of_week_type dow, month_type m) : |
266 | month_(m), |
267 | dow_(dow) |
268 | {} |
269 | //! Return a concrete date when provided with a year specific year. |
270 | date_type get_date(year_type year) const |
271 | { |
272 | date_type d(year, month_,1); |
273 | duration_type one_day(1); |
274 | while (dow_ != d.day_of_week()) { |
275 | d = d + one_day; |
276 | } |
277 | return d; |
278 | } |
279 | // added for streaming |
280 | month_type month() const |
281 | { |
282 | return month_; |
283 | } |
284 | day_of_week_type day_of_week() const |
285 | { |
286 | return dow_; |
287 | } |
288 | //! Returns string suitable for use in POSIX time zone string |
289 | /*! Returns a string formatted as "M4.1.0" ==> 1st Sunday in April. */ |
290 | virtual std::string to_string() const |
291 | { |
292 | std::ostringstream ss; |
293 | ss << 'M' |
294 | << static_cast<int>(month_) << '.' |
295 | << 1 << '.' |
296 | << static_cast<int>(dow_); |
297 | return ss.str(); |
298 | } |
299 | private: |
300 | month_type month_; |
301 | day_of_week_type dow_; |
302 | }; |
303 | |
304 | |
305 | |
306 | //! Calculate something like Last Sunday of January |
307 | /*! Useful generator functor for finding holidays and daylight savings |
308 | * Get the last day of the month and then calculate the difference |
309 | * to the last previous day. |
310 | * @param date_type A date class that exports day_of_week, month_type, etc. |
311 | * \ingroup date_alg |
312 | */ |
313 | template<class date_type> |
314 | class last_kday_of_month : public year_based_generator<date_type> |
315 | { |
316 | public: |
317 | typedef typename date_type::calendar_type calendar_type; |
318 | typedef typename calendar_type::day_of_week_type day_of_week_type; |
319 | typedef typename calendar_type::month_type month_type; |
320 | typedef typename calendar_type::year_type year_type; |
321 | typedef typename date_type::duration_type duration_type; |
322 | //!Specify the date spec like last 'Sunday' in 'April' spec |
323 | /*!@param dow The day of week, eg: Sunday, Monday, etc |
324 | * @param m The month of the year, eg: Jan, Feb, Mar, etc |
325 | */ |
326 | last_kday_of_month(day_of_week_type dow, month_type m) : |
327 | month_(m), |
328 | dow_(dow) |
329 | {} |
330 | //! Return a concrete date when provided with a year specific year. |
331 | date_type get_date(year_type year) const |
332 | { |
333 | date_type d(year, month_, calendar_type::end_of_month_day(year,month_)); |
334 | duration_type one_day(1); |
335 | while (dow_ != d.day_of_week()) { |
336 | d = d - one_day; |
337 | } |
338 | return d; |
339 | } |
340 | // added for streaming |
341 | month_type month() const |
342 | { |
343 | return month_; |
344 | } |
345 | day_of_week_type day_of_week() const |
346 | { |
347 | return dow_; |
348 | } |
349 | //! Returns string suitable for use in POSIX time zone string |
350 | /*! Returns a string formatted as "M4.5.0" ==> last Sunday in April. */ |
351 | virtual std::string to_string() const |
352 | { |
353 | std::ostringstream ss; |
354 | ss << 'M' |
355 | << static_cast<int>(month_) << '.' |
356 | << 5 << '.' |
357 | << static_cast<int>(dow_); |
358 | return ss.str(); |
359 | } |
360 | private: |
361 | month_type month_; |
362 | day_of_week_type dow_; |
363 | }; |
364 | |
365 | |
366 | //! Calculate something like "First Sunday after Jan 1,2002 |
367 | /*! Date generator that takes a date and finds kday after |
368 | *@code |
369 | typedef boost::date_time::first_kday_after<date> firstkdayafter; |
370 | firstkdayafter fkaf(Monday); |
371 | fkaf.get_date(date(2002,Feb,1)); |
372 | @endcode |
373 | * \ingroup date_alg |
374 | */ |
375 | template<class date_type> |
376 | class first_kday_after |
377 | { |
378 | public: |
379 | typedef typename date_type::calendar_type calendar_type; |
380 | typedef typename calendar_type::day_of_week_type day_of_week_type; |
381 | typedef typename date_type::duration_type duration_type; |
382 | first_kday_after(day_of_week_type dow) : |
383 | dow_(dow) |
384 | {} |
385 | //! Return next kday given. |
386 | date_type get_date(date_type start_day) const |
387 | { |
388 | duration_type one_day(1); |
389 | date_type d = start_day + one_day; |
390 | while (dow_ != d.day_of_week()) { |
391 | d = d + one_day; |
392 | } |
393 | return d; |
394 | } |
395 | // added for streaming |
396 | day_of_week_type day_of_week() const |
397 | { |
398 | return dow_; |
399 | } |
400 | private: |
401 | day_of_week_type dow_; |
402 | }; |
403 | |
404 | //! Calculate something like "First Sunday before Jan 1,2002 |
405 | /*! Date generator that takes a date and finds kday after |
406 | *@code |
407 | typedef boost::date_time::first_kday_before<date> firstkdaybefore; |
408 | firstkdaybefore fkbf(Monday); |
409 | fkbf.get_date(date(2002,Feb,1)); |
410 | @endcode |
411 | * \ingroup date_alg |
412 | */ |
413 | template<class date_type> |
414 | class first_kday_before |
415 | { |
416 | public: |
417 | typedef typename date_type::calendar_type calendar_type; |
418 | typedef typename calendar_type::day_of_week_type day_of_week_type; |
419 | typedef typename date_type::duration_type duration_type; |
420 | first_kday_before(day_of_week_type dow) : |
421 | dow_(dow) |
422 | {} |
423 | //! Return next kday given. |
424 | date_type get_date(date_type start_day) const |
425 | { |
426 | duration_type one_day(1); |
427 | date_type d = start_day - one_day; |
428 | while (dow_ != d.day_of_week()) { |
429 | d = d - one_day; |
430 | } |
431 | return d; |
432 | } |
433 | // added for streaming |
434 | day_of_week_type day_of_week() const |
435 | { |
436 | return dow_; |
437 | } |
438 | private: |
439 | day_of_week_type dow_; |
440 | }; |
441 | |
442 | //! Calculates the number of days until the next weekday |
443 | /*! Calculates the number of days until the next weekday. |
444 | * If the date given falls on a Sunday and the given weekday |
445 | * is Tuesday the result will be 2 days */ |
446 | template<typename date_type, class weekday_type> |
447 | inline |
448 | typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd) |
449 | { |
450 | typedef typename date_type::duration_type duration_type; |
451 | duration_type wks(0); |
452 | duration_type dd(wd.as_number() - d.day_of_week().as_number()); |
453 | if(dd.is_negative()){ |
454 | wks = duration_type(7); |
455 | } |
456 | return dd + wks; |
457 | } |
458 | |
459 | //! Calculates the number of days since the previous weekday |
460 | /*! Calculates the number of days since the previous weekday |
461 | * If the date given falls on a Sunday and the given weekday |
462 | * is Tuesday the result will be 5 days. The answer will be a positive |
463 | * number because Tuesday is 5 days before Sunday, not -5 days before. */ |
464 | template<typename date_type, class weekday_type> |
465 | inline |
466 | typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd) |
467 | { |
468 | typedef typename date_type::duration_type duration_type; |
469 | duration_type wks(0); |
470 | duration_type dd(wd.as_number() - d.day_of_week().as_number()); |
471 | if(dd.days() > 0){ |
472 | wks = duration_type(7); |
473 | } |
474 | // we want a number of days, not an offset. The value returned must |
475 | // be zero or larger. |
476 | return (-dd + wks); |
477 | } |
478 | |
479 | //! Generates a date object representing the date of the following weekday from the given date |
480 | /*! Generates a date object representing the date of the following |
481 | * weekday from the given date. If the date given is 2004-May-9 |
482 | * (a Sunday) and the given weekday is Tuesday then the resulting date |
483 | * will be 2004-May-11. */ |
484 | template<class date_type, class weekday_type> |
485 | inline |
486 | date_type next_weekday(const date_type& d, const weekday_type& wd) |
487 | { |
488 | return d + days_until_weekday(d, wd); |
489 | } |
490 | |
491 | //! Generates a date object representing the date of the previous weekday from the given date |
492 | /*! Generates a date object representing the date of the previous |
493 | * weekday from the given date. If the date given is 2004-May-9 |
494 | * (a Sunday) and the given weekday is Tuesday then the resulting date |
495 | * will be 2004-May-4. */ |
496 | template<class date_type, class weekday_type> |
497 | inline |
498 | date_type previous_weekday(const date_type& d, const weekday_type& wd) |
499 | { |
500 | return d - days_before_weekday(d, wd); |
501 | } |
502 | |
503 | } } //namespace date_time |
504 | |
505 | |
506 | |
507 | |
508 | #endif |
509 | |
510 | |