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