| #ifndef DATE_TIME_DATE_HPP___ |
| #define DATE_TIME_DATE_HPP___ |
| |
| /* Copyright (c) 2002,2003 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: 2010-01-10 14:17:23 -0500 (Sun, 10 Jan 2010) $ |
| */ |
| |
| #include <boost/operators.hpp> |
| #include <boost/date_time/year_month_day.hpp> |
| #include <boost/date_time/special_defs.hpp> |
| |
| namespace boost { |
| namespace date_time { |
| |
| //!Representation of timepoint at the one day level resolution. |
| /*! |
| The date template represents an interface shell for a date class |
| that is based on a year-month-day system such as the gregorian |
| or iso systems. It provides basic operations to enable calculation |
| and comparisons. |
| |
| <b>Theory</b> |
| |
| This date representation fundamentally departs from the C tm struct |
| approach. The goal for this type is to provide efficient date |
| operations (add, subtract) and storage (minimize space to represent) |
| in a concrete class. Thus, the date uses a count internally to |
| represent a particular date. The calendar parameter defines |
| the policies for converting the the year-month-day and internal |
| counted form here. Applications that need to perform heavy |
| formatting of the same date repeatedly will perform better |
| by using the year-month-day representation. |
| |
| Internally the date uses a day number to represent the date. |
| This is a monotonic time representation. This representation |
| allows for fast comparison as well as simplifying |
| the creation of writing numeric operations. Essentially, the |
| internal day number is like adjusted julian day. The adjustment |
| is determined by the Epoch date which is represented as day 1 of |
| the calendar. Day 0 is reserved for negative infinity so that |
| any actual date is automatically greater than negative infinity. |
| When a date is constructed from a date or formatted for output, |
| the appropriate conversions are applied to create the year, month, |
| day representations. |
| */ |
| |
| |
| template<class T, class calendar, class duration_type_> |
| class date : private |
| boost::less_than_comparable<T |
| , boost::equality_comparable<T |
| > > |
| { |
| public: |
| typedef T date_type; |
| typedef calendar calendar_type; |
| typedef typename calendar::date_traits_type traits_type; |
| typedef duration_type_ duration_type; |
| typedef typename calendar::year_type year_type; |
| typedef typename calendar::month_type month_type; |
| typedef typename calendar::day_type day_type; |
| typedef typename calendar::ymd_type ymd_type; |
| typedef typename calendar::date_rep_type date_rep_type; |
| typedef typename calendar::date_int_type date_int_type; |
| typedef typename calendar::day_of_week_type day_of_week_type; |
| date(year_type y, month_type m, day_type d) |
| : days_(calendar::day_number(ymd_type(y, m, d))) |
| {} |
| date(const ymd_type& ymd) |
| : days_(calendar::day_number(ymd)) |
| {} |
| //let the compiler write copy, assignment, and destructor |
| year_type year() const |
| { |
| ymd_type ymd = calendar::from_day_number(days_); |
| return ymd.year; |
| } |
| month_type month() const |
| { |
| ymd_type ymd = calendar::from_day_number(days_); |
| return ymd.month; |
| } |
| day_type day() const |
| { |
| ymd_type ymd = calendar::from_day_number(days_); |
| return ymd.day; |
| } |
| day_of_week_type day_of_week() const |
| { |
| ymd_type ymd = calendar::from_day_number(days_); |
| return calendar::day_of_week(ymd); |
| } |
| ymd_type year_month_day() const |
| { |
| return calendar::from_day_number(days_); |
| } |
| bool operator<(const date_type& rhs) const |
| { |
| return days_ < rhs.days_; |
| } |
| bool operator==(const date_type& rhs) const |
| { |
| return days_ == rhs.days_; |
| } |
| //! check to see if date is a special value |
| bool is_special()const |
| { |
| return(is_not_a_date() || is_infinity()); |
| } |
| //! check to see if date is not a value |
| bool is_not_a_date() const |
| { |
| return traits_type::is_not_a_number(days_); |
| } |
| //! check to see if date is one of the infinity values |
| bool is_infinity() const |
| { |
| return traits_type::is_inf(days_); |
| } |
| //! check to see if date is greater than all possible dates |
| bool is_pos_infinity() const |
| { |
| return traits_type::is_pos_inf(days_); |
| } |
| //! check to see if date is greater than all possible dates |
| bool is_neg_infinity() const |
| { |
| return traits_type::is_neg_inf(days_); |
| } |
| //! return as a special value or a not_special if a normal date |
| special_values as_special() const |
| { |
| return traits_type::to_special(days_); |
| } |
| duration_type operator-(const date_type& d) const |
| { |
| if (!this->is_special() && !d.is_special()) |
| { |
| // The duration underlying type may be wider than the date underlying type. |
| // Thus we calculate the difference in terms of two durations from some common fixed base date. |
| typedef typename duration_type::duration_rep_type duration_rep_type; |
| return duration_type(static_cast< duration_rep_type >(days_) - static_cast< duration_rep_type >(d.days_)); |
| } |
| else |
| { |
| // In this case the difference will be a special value, too |
| date_rep_type val = date_rep_type(days_) - date_rep_type(d.days_); |
| return duration_type(val.as_special()); |
| } |
| } |
| |
| date_type operator-(const duration_type& dd) const |
| { |
| if(dd.is_special()) |
| { |
| return date_type(date_rep_type(days_) - dd.get_rep()); |
| } |
| return date_type(date_rep_type(days_) - dd.days()); |
| } |
| date_type operator-=(const duration_type& dd) |
| { |
| *this = *this - dd; |
| return date_type(days_); |
| } |
| date_rep_type day_count() const |
| { |
| return days_; |
| } |
| //allow internal access from operators |
| date_type operator+(const duration_type& dd) const |
| { |
| if(dd.is_special()) |
| { |
| return date_type(date_rep_type(days_) + dd.get_rep()); |
| } |
| return date_type(date_rep_type(days_) + dd.days()); |
| } |
| date_type operator+=(const duration_type& dd) |
| { |
| *this = *this + dd; |
| return date_type(days_); |
| } |
| |
| //see reference |
| protected: |
| /*! This is a private constructor which allows for the creation of new |
| dates. It is not exposed to users since that would require class |
| users to understand the inner workings of the date class. |
| */ |
| explicit date(date_int_type days) : days_(days) {}; |
| explicit date(date_rep_type days) : days_(days.as_number()) {}; |
| date_int_type days_; |
| |
| }; |
| |
| |
| |
| |
| } } // namespace date_time |
| |
| |
| |
| |
| #endif |