boost/date_time/date_duration_types.hpp

   1 #ifndef DATE_DURATION_TYPES_HPP___
   2 #define DATE_DURATION_TYPES_HPP___
   3
   4 /* Copyright (c) 2004 CrystalClear Software, Inc.
   5  * Subject to the Boost Software License, Version 1.0.
   6  * (See accompanying file LICENSE_1_0.txt or
   7  * http://www.boost.org/LICENSE_1_0.txt)
   8  * Author: Jeff Garland, Bart Garst
   9  * $Date$
  10  */
  11
  12 #include <boost/date_time/int_adapter.hpp>
  13 #include <boost/date_time/special_defs.hpp>
  14 #include <boost/date_time/date_duration.hpp>
  15
  16 namespace boost {
  17 namespace date_time {
  18
  19
  20   //! Additional duration type that represents a number of n*7 days
  21   template <class duration_config>
  22   class weeks_duration : public date_duration<duration_config> {
  23   public:
  24     weeks_duration(typename duration_config::impl_type w)
  25       : date_duration<duration_config>(w * 7) {}
  26     weeks_duration(special_values sv)
  27       : date_duration<duration_config>(sv) {}
  28   };
  29
  30   // predeclare
  31   template<class t>
  32   class years_duration;
  33
  34   //! additional duration type that represents a logical month
  35   /*! A logical month enables things like: "date(2002,Mar,2) + months(2) ->
  36    * 2002-May2". If the date is a last day-of-the-month, the result will
  37    * also be a last-day-of-the-month.
  38    */
  39   template<class base_config>
  40   class months_duration
  41   {
  42     private:
  43       typedef typename base_config::int_rep int_rep;
  44       typedef typename int_rep::int_type int_type;
  45       typedef typename base_config::date_type date_type;
  46       typedef typename date_type::duration_type duration_type;
  47       typedef typename base_config::month_adjustor_type month_adjustor_type;
  48       typedef months_duration<base_config> months_type;
  49       typedef years_duration<base_config> years_type;
  50     public:
  51       months_duration(int_rep num) : _m(num) {}
  52       months_duration(special_values sv) : _m(sv)
  53       {
  54         _m = int_rep::from_special(sv);
  55       }
  56       int_rep number_of_months() const { return _m; }
  57       //! returns a negative duration
  58       duration_type get_neg_offset(const date_type& d) const
  59       {
  60         month_adjustor_type m_adj(_m.as_number());
  61         return duration_type(m_adj.get_neg_offset(d));
  62       }
  63       duration_type get_offset(const date_type& d) const
  64       {
  65         month_adjustor_type m_adj(_m.as_number());
  66         return duration_type(m_adj.get_offset(d));
  67       }
  68       bool operator==(const months_type& rhs) const
  69       {
  70         return(_m == rhs._m);
  71       }
  72       bool operator!=(const months_type& rhs) const
  73       {
  74         return(_m != rhs._m);
  75       }
  76       months_type operator+(const months_type& rhs)const
  77       {
  78         return months_type(_m + rhs._m);
  79       }
  80       months_type& operator+=(const months_type& rhs)
  81       {
  82         _m = _m + rhs._m;
  83         return *this;
  84       }
  85       months_type operator-(const months_type& rhs)const
  86       {
  87         return months_type(_m - rhs._m);
  88       }
  89       months_type& operator-=(const months_type& rhs)
  90       {
  91         _m = _m - rhs._m;
  92         return *this;
  93       }
  94       months_type operator*(const int_type rhs)const
  95       {
  96         return months_type(_m * rhs);
  97       }
  98       months_type& operator*=(const int_type rhs)
  99       {
 100         _m = _m * rhs;
 101         return *this;
 102       }
 103       months_type operator/(const int_type rhs)const
 104       {
 105         return months_type(_m / rhs);
 106       }
 107       months_type& operator/=(const int_type rhs)
 108       {
 109         _m = _m / rhs;
 110         return *this;
 111       }
 112       months_type operator+(const years_type& y)const
 113       {
 114         return months_type(y.number_of_years() * 12 + _m);
 115       }
 116       months_type& operator+=(const years_type& y)
 117       {
 118         _m = y.number_of_years() * 12 + _m;
 119         return *this;
 120       }
 121       months_type operator-(const years_type& y) const
 122       {
 123         return months_type(_m - y.number_of_years() * 12);
 124       }
 125       months_type& operator-=(const years_type& y)
 126       {
 127         _m = _m - y.number_of_years() * 12;
 128         return *this;
 129       }
 130
 131       //
 132       friend date_type operator+(const date_type& d, const months_type& m)
 133       {
 134         return d + m.get_offset(d);
 135       }
 136       friend date_type operator+=(date_type& d, const months_type& m)
 137       {
 138         return d += m.get_offset(d);
 139       }
 140       friend date_type operator-(const date_type& d, const months_type& m)
 141       {
 142         // get_neg_offset returns a negative duration, so we add
 143         return d + m.get_neg_offset(d);
 144       }
 145       friend date_type operator-=(date_type& d, const months_type& m)
 146       {
 147         // get_neg_offset returns a negative duration, so we add
 148         return d += m.get_neg_offset(d);
 149       }
 150
 151     private:
 152       int_rep _m;
 153   };
 154
 155   //! additional duration type that represents a logical year
 156   /*! A logical year enables things like: "date(2002,Mar,2) + years(2) ->
 157    * 2004-Mar-2". If the date is a last day-of-the-month, the result will
 158    * also be a last-day-of-the-month (ie date(2001-Feb-28) + years(3) ->
 159    * 2004-Feb-29).
 160    */
 161   template<class base_config>
 162   class years_duration
 163   {
 164     private:
 165       typedef typename base_config::int_rep int_rep;
 166       typedef typename int_rep::int_type int_type;
 167       typedef typename base_config::date_type date_type;
 168       typedef typename date_type::duration_type duration_type;
 169       typedef typename base_config::month_adjustor_type month_adjustor_type;
 170       typedef years_duration<base_config> years_type;
 171       typedef months_duration<base_config> months_type;
 172     public:
 173       years_duration(int_rep num) : _y(num) {}
 174       years_duration(special_values sv) : _y(sv)
 175       {
 176         _y = int_rep::from_special(sv);
 177       }
 178       int_rep number_of_years() const { return _y; }
 179       //! returns a negative duration
 180       duration_type get_neg_offset(const date_type& d) const
 181       {
 182         month_adjustor_type m_adj(_y.as_number() * 12);
 183         return duration_type(m_adj.get_neg_offset(d));
 184       }
 185       duration_type get_offset(const date_type& d) const
 186       {
 187         month_adjustor_type m_adj(_y.as_number() * 12);
 188         return duration_type(m_adj.get_offset(d));
 189       }
 190       bool operator==(const years_type& rhs) const
 191       {
 192         return(_y == rhs._y);
 193       }
 194       bool operator!=(const years_type& rhs) const
 195       {
 196         return(_y != rhs._y);
 197       }
 198       years_type operator+(const years_type& rhs)const
 199       {
 200         return years_type(_y + rhs._y);
 201       }
 202       years_type& operator+=(const years_type& rhs)
 203       {
 204         _y = _y + rhs._y;
 205         return *this;
 206       }
 207       years_type operator-(const years_type& rhs)const
 208       {
 209         return years_type(_y - rhs._y);
 210       }
 211       years_type& operator-=(const years_type& rhs)
 212       {
 213         _y = _y - rhs._y;
 214         return *this;
 215       }
 216       years_type operator*(const int_type rhs)const
 217       {
 218         return years_type(_y * rhs);
 219       }
 220       years_type& operator*=(const int_type rhs)
 221       {
 222         _y = _y * rhs;
 223         return *this;
 224       }
 225       years_type operator/(const int_type rhs)const
 226       {
 227         return years_type(_y / rhs);
 228       }
 229       years_type& operator/=(const int_type rhs)
 230       {
 231         _y = _y / rhs;
 232         return *this;
 233       }
 234       months_type operator+(const months_type& m) const
 235       {
 236         return(months_type(_y * 12 + m.number_of_months()));
 237       }
 238       months_type operator-(const months_type& m) const
 239       {
 240         return(months_type(_y * 12 - m.number_of_months()));
 241       }
 242
 243       //
 244       friend date_type operator+(const date_type& d, const years_type& y)
 245       {
 246         return d + y.get_offset(d);
 247       }
 248       friend date_type operator+=(date_type& d, const years_type& y)
 249       {
 250         return d += y.get_offset(d);
 251       }
 252       friend date_type operator-(const date_type& d, const years_type& y)
 253       {
 254         // get_neg_offset returns a negative duration, so we add
 255         return d + y.get_neg_offset(d);
 256       }
 257       friend date_type operator-=(date_type& d, const years_type& y)
 258       {
 259         // get_neg_offset returns a negative duration, so we add
 260         return d += y.get_neg_offset(d);
 261       }
 262
 263     private:
 264       int_rep _y;
 265   };
 266
 267 }} // namespace boost::date_time
 268
 269 #endif // DATE_DURATION_TYPES_HPP___