src/boost/boost/date_time/time_duration.hpp

   1 #ifndef DATE_TIME_TIME_DURATION_HPP___
   2 #define DATE_TIME_TIME_DURATION_HPP___
   3
   4 /* Copyright (c) 2002,2003 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: 2009-06-04 04:24:49 -0400 (Thu, 04 Jun 2009) $
  10  */
  11
  12 #include <boost/cstdint.hpp>
  13 #include <boost/operators.hpp>
  14 #include <boost/date_time/time_defs.hpp>
  15 #include <boost/date_time/special_defs.hpp>
  16 #include <boost/date_time/compiler_config.hpp>
  17
  18 namespace boost {
  19 namespace date_time {
  20
  21
  22   //! Represents some amount of elapsed time measure to a given resolution
  23   /*! This class represents a standard set of capabilities for all
  24       counted time durations.  Time duration implementations should derive
  25       from this class passing their type as the first template parameter.
  26       This design allows the subclass duration types to provide custom
  27       construction policies or other custom features not provided here.
  28
  29       @param T The subclass type
  30       @param rep_type The time resolution traits for this duration type.
  31   */
  32   template<class T, typename rep_type>
  33   class time_duration : private
  34       boost::less_than_comparable<T
  35     , boost::equality_comparable<T
  36     > >
  37   /* dividable, addable, and subtractable operator templates
  38    * won't work with this class (MSVC++ 6.0). return type
  39    * from '+=' is different than expected return type
  40    * from '+'. multipliable probably wont work
  41    * either (haven't tried) */
  42   {
  43   public:
  44     typedef T duration_type;  //the subclass
  45     typedef rep_type traits_type;
  46     typedef typename rep_type::day_type  day_type;
  47     typedef typename rep_type::hour_type hour_type;
  48     typedef typename rep_type::min_type  min_type;
  49     typedef typename rep_type::sec_type  sec_type;
  50     typedef typename rep_type::fractional_seconds_type fractional_seconds_type;
  51     typedef typename rep_type::tick_type tick_type;
  52     typedef typename rep_type::impl_type impl_type;
  53
  54     time_duration() : ticks_(0) {}
  55     time_duration(hour_type hours_in,
  56                   min_type minutes_in,
  57                   sec_type seconds_in=0,
  58                   fractional_seconds_type frac_sec_in = 0) :
  59       ticks_(rep_type::to_tick_count(hours_in,minutes_in,seconds_in,frac_sec_in))
  60     {}
  61     // copy constructor required for dividable<>
  62     //! Construct from another time_duration (Copy constructor)
  63     time_duration(const time_duration<T, rep_type>& other)
  64       : ticks_(other.ticks_)
  65     {}
  66     //! Construct from special_values
  67     time_duration(special_values sv) : ticks_(impl_type::from_special(sv))
  68     {}
  69     //! Returns smallest representable duration
  70     static duration_type unit()
  71     {
  72       return duration_type(0,0,0,1);
  73     }
  74     //! Return the number of ticks in a second
  75     static tick_type ticks_per_second()
  76     {
  77       return rep_type::res_adjust();
  78     }
  79     //! Provide the resolution of this duration type
  80     static time_resolutions resolution()
  81     {
  82       return rep_type::resolution();
  83     }
  84     //! Returns number of hours in the duration
  85     hour_type hours()   const
  86     {
  87       return static_cast<hour_type>(ticks() / (3600*ticks_per_second()));
  88     }
  89     //! Returns normalized number of minutes
  90     min_type minutes() const
  91     {
  92       return static_cast<min_type>((ticks() / (60*ticks_per_second())) % 60);
  93     }
  94     //! Returns normalized number of seconds (0..60)
  95     sec_type seconds() const
  96     {
  97       return static_cast<sec_type>((ticks()/ticks_per_second()) % 60);
  98     }
  99     //! Returns total number of seconds truncating any fractional seconds
 100     sec_type total_seconds() const
 101     {
 102       return static_cast<sec_type>(ticks() / ticks_per_second());
 103     }
 104     //! Returns total number of milliseconds truncating any fractional seconds
 105     tick_type total_milliseconds() const
 106     {
 107       if (ticks_per_second() < 1000) {
 108         return ticks() * (static_cast<tick_type>(1000) / ticks_per_second());
 109       }
 110       return ticks() / (ticks_per_second() / static_cast<tick_type>(1000)) ;
 111     }
 112     //! Returns total number of nanoseconds truncating any sub millisecond values
 113     tick_type total_nanoseconds() const
 114     {
 115       if (ticks_per_second() < 1000000000) {
 116         return ticks() * (static_cast<tick_type>(1000000000) / ticks_per_second());
 117       }
 118       return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000000)) ;
 119     }
 120     //! Returns total number of microseconds truncating any sub microsecond values
 121     tick_type total_microseconds() const
 122     {
 123       if (ticks_per_second() < 1000000) {
 124         return ticks() * (static_cast<tick_type>(1000000) / ticks_per_second());
 125       }
 126       return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000)) ;
 127     }
 128     //! Returns count of fractional seconds at given resolution
 129     fractional_seconds_type fractional_seconds() const
 130     {
 131       return (ticks() % ticks_per_second());
 132     }
 133     //! Returns number of possible digits in fractional seconds
 134     static unsigned short num_fractional_digits()
 135     {
 136       return rep_type::num_fractional_digits();
 137     }
 138     duration_type invert_sign() const
 139     {
 140       return duration_type(ticks_ * (-1));
 141     }
 142     bool is_negative() const
 143     {
 144       return ticks_ < 0;
 145     }
 146     bool operator<(const time_duration& rhs)  const
 147     {
 148       return ticks_ <  rhs.ticks_;
 149     }
 150     bool operator==(const time_duration& rhs)  const
 151     {
 152       return ticks_ ==  rhs.ticks_;
 153     }
 154     //! unary- Allows for time_duration td = -td1
 155     duration_type operator-()const
 156     {
 157       return duration_type(ticks_ * (-1));
 158     }
 159     duration_type operator-(const duration_type& d) const
 160     {
 161       return duration_type(ticks_ - d.ticks_);
 162     }
 163     duration_type operator+(const duration_type& d) const
 164     {
 165       return duration_type(ticks_ + d.ticks_);
 166     }
 167     duration_type operator/(int divisor) const
 168     {
 169       return duration_type(ticks_ / divisor);
 170     }
 171     duration_type operator-=(const duration_type& d)
 172     {
 173       ticks_ = ticks_ - d.ticks_;
 174       return duration_type(ticks_);
 175     }
 176     duration_type operator+=(const duration_type& d)
 177     {
 178       ticks_ = ticks_ + d.ticks_;
 179       return duration_type(ticks_);
 180     }
 181     //! Division operations on a duration with an integer.
 182     duration_type operator/=(int divisor)
 183     {
 184       ticks_ = ticks_ / divisor;
 185       return duration_type(ticks_);
 186     }
 187     //! Multiplication operations an a duration with an integer
 188     duration_type operator*(int rhs) const
 189     {
 190       return duration_type(ticks_ * rhs);
 191     }
 192     duration_type operator*=(int divisor)
 193     {
 194       ticks_ = ticks_ * divisor;
 195       return duration_type(ticks_);
 196     }
 197     tick_type ticks() const
 198     {
 199       return traits_type::as_number(ticks_);
 200     }
 201
 202     //! Is ticks_ a special value?
 203     bool is_special()const
 204     {
 205       if(traits_type::is_adapted())
 206       {
 207         return ticks_.is_special();
 208       }
 209       else{
 210         return false;
 211       }
 212     }
 213     //! Is duration pos-infinity
 214     bool is_pos_infinity()const
 215     {
 216       if(traits_type::is_adapted())
 217       {
 218         return ticks_.is_pos_infinity();
 219       }
 220       else{
 221         return false;
 222       }
 223     }
 224     //! Is duration neg-infinity
 225     bool is_neg_infinity()const
 226     {
 227       if(traits_type::is_adapted())
 228       {
 229         return ticks_.is_neg_infinity();
 230       }
 231       else{
 232         return false;
 233       }
 234     }
 235     //! Is duration not-a-date-time
 236     bool is_not_a_date_time()const
 237     {
 238       if(traits_type::is_adapted())
 239       {
 240         return ticks_.is_nan();
 241       }
 242       else{
 243         return false;
 244       }
 245     }
 246
 247     //! Used for special_values output
 248     impl_type get_rep()const
 249     {
 250       return ticks_;
 251     }
 252
 253   protected:
 254     explicit time_duration(impl_type in) : ticks_(in) {};
 255     impl_type ticks_;
 256   };
 257
 258
 259
 260   //! Template for instantiating derived adjusting durations
 261   /* These templates are designed to work with multiples of
 262    * 10 for frac_of_second and resoultion adjustment
 263    */
 264   template<class base_duration, boost::int64_t frac_of_second>
 265   class subsecond_duration : public base_duration
 266   {
 267   public:
 268     typedef typename base_duration::traits_type traits_type;
 269     explicit subsecond_duration(boost::int64_t ss) :
 270       base_duration(0,0,0,ss*traits_type::res_adjust()/frac_of_second)
 271     {}
 272   };
 273
 274
 275
 276 } } //namespace date_time
 277
 278
 279
 280
 281 #endif
 282