| #ifndef DATE_TIME_DATE_GENERATORS_HPP__ |
| #define DATE_TIME_DATE_GENERATORS_HPP__ |
| |
| /* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc. |
| * Use, modification and distribution is subject to the |
| * Boost Software License, Version 1.0. (See accompanying |
| * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) |
| * Author: Jeff Garland, Bart Garst |
| * $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $ |
| */ |
| |
| /*! @file date_generators.hpp |
| Definition and implementation of date algorithm templates |
| */ |
| |
| #include <stdexcept> |
| #include <sstream> |
| #include <boost/throw_exception.hpp> |
| #include <boost/date_time/date.hpp> |
| #include <boost/date_time/compiler_config.hpp> |
| |
| namespace boost { |
| namespace date_time { |
| |
| //! Base class for all generators that take a year and produce a date. |
| /*! This class is a base class for polymorphic function objects that take |
| a year and produce a concrete date. |
| @param date_type The type representing a date. This type must |
| export a calender_type which defines a year_type. |
| */ |
| template<class date_type> |
| class year_based_generator |
| { |
| public: |
| typedef typename date_type::calendar_type calendar_type; |
| typedef typename calendar_type::year_type year_type; |
| year_based_generator() {}; |
| virtual ~year_based_generator() {}; |
| virtual date_type get_date(year_type y) const = 0; |
| //! Returns a string for use in a POSIX time_zone string |
| virtual std::string to_string() const =0; |
| }; |
| |
| //! Generates a date by applying the year to the given month and day. |
| /*! |
| Example usage: |
| @code |
| partial_date pd(1, Jan); |
| partial_date pd2(70); |
| date d = pd.get_date(2002); //2002-Jan-01 |
| date d2 = pd2.get_date(2002); //2002-Mar-10 |
| @endcode |
| \ingroup date_alg |
| */ |
| template<class date_type> |
| class partial_date : public year_based_generator<date_type> |
| { |
| public: |
| typedef typename date_type::calendar_type calendar_type; |
| typedef typename calendar_type::day_type day_type; |
| typedef typename calendar_type::month_type month_type; |
| typedef typename calendar_type::year_type year_type; |
| typedef typename date_type::duration_type duration_type; |
| typedef typename duration_type::duration_rep duration_rep; |
| partial_date(day_type d, month_type m) : |
| day_(d), |
| month_(m) |
| {} |
| //! Partial date created from number of days into year. Range 1-366 |
| /*! Allowable values range from 1 to 366. 1=Jan1, 366=Dec31. If argument |
| * exceeds range, partial_date will be created with closest in-range value. |
| * 60 will always be Feb29, if get_date() is called with a non-leap year |
| * an exception will be thrown */ |
| partial_date(duration_rep days) : |
| day_(1), // default values |
| month_(1) |
| { |
| date_type d1(2000,1,1); |
| if(days > 1) { |
| if(days > 366) // prevents wrapping |
| { |
| days = 366; |
| } |
| days = days - 1; |
| duration_type dd(days); |
| d1 = d1 + dd; |
| } |
| day_ = d1.day(); |
| month_ = d1.month(); |
| } |
| //! Return a concrete date when provided with a year specific year. |
| /*! Will throw an 'invalid_argument' exception if a partial_date object, |
| * instantiated with Feb-29, has get_date called with a non-leap year. |
| * Example: |
| * @code |
| * partial_date pd(29, Feb); |
| * pd.get_date(2003); // throws invalid_argument exception |
| * pg.get_date(2000); // returns 2000-2-29 |
| * @endcode |
| */ |
| date_type get_date(year_type y) const |
| { |
| if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) { |
| std::ostringstream ss; |
| ss << "No Feb 29th in given year of " << y << "."; |
| boost::throw_exception(std::invalid_argument(ss.str())); |
| } |
| return date_type(y, month_, day_); |
| } |
| date_type operator()(year_type y) const |
| { |
| return get_date(y); |
| //return date_type(y, month_, day_); |
| } |
| bool operator==(const partial_date& rhs) const |
| { |
| return (month_ == rhs.month_) && (day_ == rhs.day_); |
| } |
| bool operator<(const partial_date& rhs) const |
| { |
| if (month_ < rhs.month_) return true; |
| if (month_ > rhs.month_) return false; |
| //months are equal |
| return (day_ < rhs.day_); |
| } |
| |
| // added for streaming purposes |
| month_type month() const |
| { |
| return month_; |
| } |
| day_type day() const |
| { |
| return day_; |
| } |
| |
| //! Returns string suitable for use in POSIX time zone string |
| /*! Returns string formatted with up to 3 digits: |
| * Jan-01 == "0" |
| * Feb-29 == "58" |
| * Dec-31 == "365" */ |
| virtual std::string to_string() const |
| { |
| std::ostringstream ss; |
| date_type d(2004, month_, day_); |
| unsigned short c = d.day_of_year(); |
| c--; // numbered 0-365 while day_of_year is 1 based... |
| ss << c; |
| return ss.str(); |
| } |
| private: |
| day_type day_; |
| month_type month_; |
| }; |
| |
| |
| //! Returns nth arg as string. 1 -> "first", 2 -> "second", max is 5. |
| BOOST_DATE_TIME_DECL const char* nth_as_str(int n); |
| |
| //! Useful generator functor for finding holidays |
| /*! Based on the idea in Cal. Calc. for finding holidays that are |
| * the 'first Monday of September'. When instantiated with |
| * 'fifth' kday of month, the result will be the last kday of month |
| * which can be the fourth or fifth depending on the structure of |
| * the month. |
| * |
| * The algorithm here basically guesses for the first |
| * day of the month. Then finds the first day of the correct |
| * type. That is, if the first of the month is a Tuesday |
| * and it needs Wenesday then we simply increment by a day |
| * and then we can add the length of a week until we get |
| * to the 'nth kday'. There are probably more efficient |
| * algorithms based on using a mod 7, but this one works |
| * reasonably well for basic applications. |
| * \ingroup date_alg |
| */ |
| template<class date_type> |
| class nth_kday_of_month : public year_based_generator<date_type> |
| { |
| public: |
| typedef typename date_type::calendar_type calendar_type; |
| typedef typename calendar_type::day_of_week_type day_of_week_type; |
| typedef typename calendar_type::month_type month_type; |
| typedef typename calendar_type::year_type year_type; |
| typedef typename date_type::duration_type duration_type; |
| enum week_num {first=1, second, third, fourth, fifth}; |
| nth_kday_of_month(week_num week_no, |
| day_of_week_type dow, |
| month_type m) : |
| month_(m), |
| wn_(week_no), |
| dow_(dow) |
| {} |
| //! Return a concrete date when provided with a year specific year. |
| date_type get_date(year_type y) const |
| { |
| date_type d(y, month_, 1); //first day of month |
| duration_type one_day(1); |
| duration_type one_week(7); |
| while (dow_ != d.day_of_week()) { |
| d = d + one_day; |
| } |
| int week = 1; |
| while (week < wn_) { |
| d = d + one_week; |
| week++; |
| } |
| // remove wrapping to next month behavior |
| if(d.month() != month_) { |
| d = d - one_week; |
| } |
| return d; |
| } |
| // added for streaming |
| month_type month() const |
| { |
| return month_; |
| } |
| week_num nth_week() const |
| { |
| return wn_; |
| } |
| day_of_week_type day_of_week() const |
| { |
| return dow_; |
| } |
| const char* nth_week_as_str() const |
| { |
| return nth_as_str(wn_); |
| } |
| //! Returns string suitable for use in POSIX time zone string |
| /*! Returns a string formatted as "M4.3.0" ==> 3rd Sunday in April. */ |
| virtual std::string to_string() const |
| { |
| std::ostringstream ss; |
| ss << 'M' |
| << static_cast<int>(month_) << '.' |
| << static_cast<int>(wn_) << '.' |
| << static_cast<int>(dow_); |
| return ss.str(); |
| } |
| private: |
| month_type month_; |
| week_num wn_; |
| day_of_week_type dow_; |
| }; |
| |
| //! Useful generator functor for finding holidays and daylight savings |
| /*! Similar to nth_kday_of_month, but requires less paramters |
| * \ingroup date_alg |
| */ |
| template<class date_type> |
| class first_kday_of_month : public year_based_generator<date_type> |
| { |
| public: |
| typedef typename date_type::calendar_type calendar_type; |
| typedef typename calendar_type::day_of_week_type day_of_week_type; |
| typedef typename calendar_type::month_type month_type; |
| typedef typename calendar_type::year_type year_type; |
| typedef typename date_type::duration_type duration_type; |
| //!Specify the first 'Sunday' in 'April' spec |
| /*!@param dow The day of week, eg: Sunday, Monday, etc |
| * @param m The month of the year, eg: Jan, Feb, Mar, etc |
| */ |
| first_kday_of_month(day_of_week_type dow, month_type m) : |
| month_(m), |
| dow_(dow) |
| {} |
| //! Return a concrete date when provided with a year specific year. |
| date_type get_date(year_type year) const |
| { |
| date_type d(year, month_,1); |
| duration_type one_day(1); |
| while (dow_ != d.day_of_week()) { |
| d = d + one_day; |
| } |
| return d; |
| } |
| // added for streaming |
| month_type month() const |
| { |
| return month_; |
| } |
| day_of_week_type day_of_week() const |
| { |
| return dow_; |
| } |
| //! Returns string suitable for use in POSIX time zone string |
| /*! Returns a string formatted as "M4.1.0" ==> 1st Sunday in April. */ |
| virtual std::string to_string() const |
| { |
| std::ostringstream ss; |
| ss << 'M' |
| << static_cast<int>(month_) << '.' |
| << 1 << '.' |
| << static_cast<int>(dow_); |
| return ss.str(); |
| } |
| private: |
| month_type month_; |
| day_of_week_type dow_; |
| }; |
| |
| |
| |
| //! Calculate something like Last Sunday of January |
| /*! Useful generator functor for finding holidays and daylight savings |
| * Get the last day of the month and then calculate the difference |
| * to the last previous day. |
| * @param date_type A date class that exports day_of_week, month_type, etc. |
| * \ingroup date_alg |
| */ |
| template<class date_type> |
| class last_kday_of_month : public year_based_generator<date_type> |
| { |
| public: |
| typedef typename date_type::calendar_type calendar_type; |
| typedef typename calendar_type::day_of_week_type day_of_week_type; |
| typedef typename calendar_type::month_type month_type; |
| typedef typename calendar_type::year_type year_type; |
| typedef typename date_type::duration_type duration_type; |
| //!Specify the date spec like last 'Sunday' in 'April' spec |
| /*!@param dow The day of week, eg: Sunday, Monday, etc |
| * @param m The month of the year, eg: Jan, Feb, Mar, etc |
| */ |
| last_kday_of_month(day_of_week_type dow, month_type m) : |
| month_(m), |
| dow_(dow) |
| {} |
| //! Return a concrete date when provided with a year specific year. |
| date_type get_date(year_type year) const |
| { |
| date_type d(year, month_, calendar_type::end_of_month_day(year,month_)); |
| duration_type one_day(1); |
| while (dow_ != d.day_of_week()) { |
| d = d - one_day; |
| } |
| return d; |
| } |
| // added for streaming |
| month_type month() const |
| { |
| return month_; |
| } |
| day_of_week_type day_of_week() const |
| { |
| return dow_; |
| } |
| //! Returns string suitable for use in POSIX time zone string |
| /*! Returns a string formatted as "M4.5.0" ==> last Sunday in April. */ |
| virtual std::string to_string() const |
| { |
| std::ostringstream ss; |
| ss << 'M' |
| << static_cast<int>(month_) << '.' |
| << 5 << '.' |
| << static_cast<int>(dow_); |
| return ss.str(); |
| } |
| private: |
| month_type month_; |
| day_of_week_type dow_; |
| }; |
| |
| |
| //! Calculate something like "First Sunday after Jan 1,2002 |
| /*! Date generator that takes a date and finds kday after |
| *@code |
| typedef boost::date_time::first_kday_after<date> firstkdayafter; |
| firstkdayafter fkaf(Monday); |
| fkaf.get_date(date(2002,Feb,1)); |
| @endcode |
| * \ingroup date_alg |
| */ |
| template<class date_type> |
| class first_kday_after |
| { |
| public: |
| typedef typename date_type::calendar_type calendar_type; |
| typedef typename calendar_type::day_of_week_type day_of_week_type; |
| typedef typename date_type::duration_type duration_type; |
| first_kday_after(day_of_week_type dow) : |
| dow_(dow) |
| {} |
| //! Return next kday given. |
| date_type get_date(date_type start_day) const |
| { |
| duration_type one_day(1); |
| date_type d = start_day + one_day; |
| while (dow_ != d.day_of_week()) { |
| d = d + one_day; |
| } |
| return d; |
| } |
| // added for streaming |
| day_of_week_type day_of_week() const |
| { |
| return dow_; |
| } |
| private: |
| day_of_week_type dow_; |
| }; |
| |
| //! Calculate something like "First Sunday before Jan 1,2002 |
| /*! Date generator that takes a date and finds kday after |
| *@code |
| typedef boost::date_time::first_kday_before<date> firstkdaybefore; |
| firstkdaybefore fkbf(Monday); |
| fkbf.get_date(date(2002,Feb,1)); |
| @endcode |
| * \ingroup date_alg |
| */ |
| template<class date_type> |
| class first_kday_before |
| { |
| public: |
| typedef typename date_type::calendar_type calendar_type; |
| typedef typename calendar_type::day_of_week_type day_of_week_type; |
| typedef typename date_type::duration_type duration_type; |
| first_kday_before(day_of_week_type dow) : |
| dow_(dow) |
| {} |
| //! Return next kday given. |
| date_type get_date(date_type start_day) const |
| { |
| duration_type one_day(1); |
| date_type d = start_day - one_day; |
| while (dow_ != d.day_of_week()) { |
| d = d - one_day; |
| } |
| return d; |
| } |
| // added for streaming |
| day_of_week_type day_of_week() const |
| { |
| return dow_; |
| } |
| private: |
| day_of_week_type dow_; |
| }; |
| |
| //! Calculates the number of days until the next weekday |
| /*! Calculates the number of days until the next weekday. |
| * If the date given falls on a Sunday and the given weekday |
| * is Tuesday the result will be 2 days */ |
| template<typename date_type, class weekday_type> |
| inline |
| typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd) |
| { |
| typedef typename date_type::duration_type duration_type; |
| duration_type wks(0); |
| duration_type dd(wd.as_number() - d.day_of_week().as_number()); |
| if(dd.is_negative()){ |
| wks = duration_type(7); |
| } |
| return dd + wks; |
| } |
| |
| //! Calculates the number of days since the previous weekday |
| /*! Calculates the number of days since the previous weekday |
| * If the date given falls on a Sunday and the given weekday |
| * is Tuesday the result will be 5 days. The answer will be a positive |
| * number because Tuesday is 5 days before Sunday, not -5 days before. */ |
| template<typename date_type, class weekday_type> |
| inline |
| typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd) |
| { |
| typedef typename date_type::duration_type duration_type; |
| duration_type wks(0); |
| duration_type dd(wd.as_number() - d.day_of_week().as_number()); |
| if(dd.days() > 0){ |
| wks = duration_type(7); |
| } |
| // we want a number of days, not an offset. The value returned must |
| // be zero or larger. |
| return (-dd + wks); |
| } |
| |
| //! Generates a date object representing the date of the following weekday from the given date |
| /*! Generates a date object representing the date of the following |
| * weekday from the given date. If the date given is 2004-May-9 |
| * (a Sunday) and the given weekday is Tuesday then the resulting date |
| * will be 2004-May-11. */ |
| template<class date_type, class weekday_type> |
| inline |
| date_type next_weekday(const date_type& d, const weekday_type& wd) |
| { |
| return d + days_until_weekday(d, wd); |
| } |
| |
| //! Generates a date object representing the date of the previous weekday from the given date |
| /*! Generates a date object representing the date of the previous |
| * weekday from the given date. If the date given is 2004-May-9 |
| * (a Sunday) and the given weekday is Tuesday then the resulting date |
| * will be 2004-May-4. */ |
| template<class date_type, class weekday_type> |
| inline |
| date_type previous_weekday(const date_type& d, const weekday_type& wd) |
| { |
| return d - days_before_weekday(d, wd); |
| } |
| |
| } } //namespace date_time |
| |
| |
| |
| |
| #endif |
| |