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/core/enable_if.hpp> 13 #include <boost/cstdint.hpp> 14 #include <boost/date_time/compiler_config.hpp> 15 #include <boost/date_time/special_defs.hpp> 16 #include <boost/date_time/time_defs.hpp> 17 #include <boost/operators.hpp> 18 #include <boost/static_assert.hpp> 19 #include <boost/type_traits/is_integral.hpp> 20 21 namespace boost { 22 namespace date_time { 23 24 25 //! Represents some amount of elapsed time measure to a given resolution 26 /*! This class represents a standard set of capabilities for all 27 counted time durations. Time duration implementations should derive 28 from this class passing their type as the first template parameter. 29 This design allows the subclass duration types to provide custom 30 construction policies or other custom features not provided here. 31 32 @tparam T The subclass type 33 @tparam rep_type The time resolution traits for this duration type. 34 */ 35 template<class T, typename rep_type> 36 class BOOST_SYMBOL_VISIBLE time_duration : private 37 boost::less_than_comparable<T 38 , boost::equality_comparable<T 39 > > 40 /* dividable, addable, and subtractable operator templates 41 * won't work with this class (MSVC++ 6.0). return type 42 * from '+=' is different than expected return type 43 * from '+'. multipliable probably wont work 44 * either (haven't tried) */ 45 { 46 public: 47 // A tag for type categorization. Can be used to detect Boost.DateTime duration types in generic code. 48 typedef void _is_boost_date_time_duration; 49 typedef T duration_type; //the subclass 50 typedef rep_type traits_type; 51 typedef typename rep_type::day_type day_type; 52 typedef typename rep_type::hour_type hour_type; 53 typedef typename rep_type::min_type min_type; 54 typedef typename rep_type::sec_type sec_type; 55 typedef typename rep_type::fractional_seconds_type fractional_seconds_type; 56 typedef typename rep_type::tick_type tick_type; 57 typedef typename rep_type::impl_type impl_type; 58 time_duration()59 BOOST_CXX14_CONSTEXPR 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)60 BOOST_CXX14_CONSTEXPR time_duration(hour_type hours_in, 61 min_type minutes_in, 62 sec_type seconds_in=0, 63 fractional_seconds_type frac_sec_in = 0) : 64 ticks_(rep_type::to_tick_count(hours_in,minutes_in,seconds_in,frac_sec_in)) 65 {} 66 //! Construct from special_values time_duration(special_values sv)67 BOOST_CXX14_CONSTEXPR time_duration(special_values sv) : ticks_(impl_type::from_special(sv)) 68 {} 69 //! Returns smallest representable duration unit()70 static BOOST_CXX14_CONSTEXPR duration_type unit() 71 { 72 return duration_type(0,0,0,1); 73 } 74 //! Return the number of ticks in a second ticks_per_second()75 static BOOST_CXX14_CONSTEXPR tick_type ticks_per_second() 76 { 77 return rep_type::res_adjust(); 78 } 79 //! Provide the resolution of this duration type resolution()80 static BOOST_CXX14_CONSTEXPR time_resolutions resolution() 81 { 82 return rep_type::resolution(); 83 } 84 //! Returns number of hours in the duration hours() const85 BOOST_CXX14_CONSTEXPR hour_type hours() const 86 { 87 return static_cast<hour_type>(ticks() / (3600*ticks_per_second())); 88 } 89 //! Returns normalized number of minutes minutes() const90 BOOST_CXX14_CONSTEXPR 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) seconds() const95 BOOST_CXX14_CONSTEXPR 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 total_seconds() const100 BOOST_CXX14_CONSTEXPR 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 total_milliseconds() const105 BOOST_CXX14_CONSTEXPR 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 total_nanoseconds() const113 BOOST_CXX14_CONSTEXPR 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 total_microseconds() const121 BOOST_CXX14_CONSTEXPR 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 fractional_seconds() const129 BOOST_CXX14_CONSTEXPR fractional_seconds_type fractional_seconds() const 130 { 131 return (ticks() % ticks_per_second()); 132 } 133 //! Returns number of possible digits in fractional seconds num_fractional_digits()134 static BOOST_CXX14_CONSTEXPR unsigned short num_fractional_digits() 135 { 136 return rep_type::num_fractional_digits(); 137 } invert_sign() const138 BOOST_CXX14_CONSTEXPR duration_type invert_sign() const 139 { 140 return duration_type(ticks_ * (-1)); 141 } abs() const142 BOOST_CXX14_CONSTEXPR duration_type abs() const 143 { 144 if ( is_negative() ) 145 { 146 return invert_sign(); 147 } 148 return duration_type(ticks_); 149 } is_negative() const150 BOOST_CONSTEXPR bool is_negative() const 151 { 152 return ticks_ < 0; 153 } is_zero() const154 BOOST_CONSTEXPR bool is_zero() const 155 { 156 return ticks_ == 0; 157 } is_positive() const158 BOOST_CONSTEXPR bool is_positive() const 159 { 160 return ticks_ > 0; 161 } operator <(const time_duration & rhs) const162 BOOST_CONSTEXPR bool operator<(const time_duration& rhs) const 163 { 164 return ticks_ < rhs.ticks_; 165 } operator ==(const time_duration & rhs) const166 BOOST_CONSTEXPR bool operator==(const time_duration& rhs) const 167 { 168 return ticks_ == rhs.ticks_; 169 } 170 //! unary- Allows for time_duration td = -td1 operator -() const171 BOOST_CONSTEXPR duration_type operator-()const 172 { 173 return duration_type(ticks_ * (-1)); 174 } operator -(const duration_type & d) const175 BOOST_CONSTEXPR duration_type operator-(const duration_type& d) const 176 { 177 return duration_type(ticks_ - d.ticks_); 178 } operator +(const duration_type & d) const179 BOOST_CONSTEXPR duration_type operator+(const duration_type& d) const 180 { 181 return duration_type(ticks_ + d.ticks_); 182 } operator /(int divisor) const183 BOOST_CONSTEXPR duration_type operator/(int divisor) const 184 { 185 return duration_type(ticks_ / divisor); 186 } operator -=(const duration_type & d)187 BOOST_CXX14_CONSTEXPR duration_type operator-=(const duration_type& d) 188 { 189 ticks_ = ticks_ - d.ticks_; 190 return duration_type(ticks_); 191 } operator +=(const duration_type & d)192 BOOST_CXX14_CONSTEXPR duration_type operator+=(const duration_type& d) 193 { 194 ticks_ = ticks_ + d.ticks_; 195 return duration_type(ticks_); 196 } 197 //! Division operations on a duration with an integer. operator /=(int divisor)198 BOOST_CXX14_CONSTEXPR duration_type operator/=(int divisor) 199 { 200 ticks_ = ticks_ / divisor; 201 return duration_type(ticks_); 202 } 203 //! Multiplication operations an a duration with an integer operator *(int rhs) const204 BOOST_CXX14_CONSTEXPR duration_type operator*(int rhs) const 205 { 206 return duration_type(ticks_ * rhs); 207 } operator *=(int divisor)208 BOOST_CXX14_CONSTEXPR duration_type operator*=(int divisor) 209 { 210 ticks_ = ticks_ * divisor; 211 return duration_type(ticks_); 212 } ticks() const213 BOOST_CXX14_CONSTEXPR tick_type ticks() const 214 { 215 return traits_type::as_number(ticks_); 216 } 217 218 //! Is ticks_ a special value? is_special() const219 BOOST_CXX14_CONSTEXPR bool is_special()const 220 { 221 if(traits_type::is_adapted()) 222 { 223 return ticks_.is_special(); 224 } 225 else{ 226 return false; 227 } 228 } 229 //! Is duration pos-infinity is_pos_infinity() const230 BOOST_CXX14_CONSTEXPR bool is_pos_infinity()const 231 { 232 if(traits_type::is_adapted()) 233 { 234 return ticks_.is_pos_infinity(); 235 } 236 else{ 237 return false; 238 } 239 } 240 //! Is duration neg-infinity is_neg_infinity() const241 BOOST_CXX14_CONSTEXPR bool is_neg_infinity()const 242 { 243 if(traits_type::is_adapted()) 244 { 245 return ticks_.is_neg_infinity(); 246 } 247 else{ 248 return false; 249 } 250 } 251 //! Is duration not-a-date-time is_not_a_date_time() const252 BOOST_CXX14_CONSTEXPR bool is_not_a_date_time()const 253 { 254 if(traits_type::is_adapted()) 255 { 256 return ticks_.is_nan(); 257 } 258 else{ 259 return false; 260 } 261 } 262 263 //! Used for special_values output get_rep() const264 BOOST_CONSTEXPR impl_type get_rep()const 265 { 266 return ticks_; 267 } 268 269 protected: time_duration(impl_type in)270 BOOST_CXX14_CONSTEXPR explicit time_duration(impl_type in) : ticks_(in) {} 271 impl_type ticks_; 272 }; 273 274 275 276 //! Template for instantiating derived adjusting durations 277 /* These templates are designed to work with multiples of 278 * 10 for frac_of_second and resolution adjustment 279 */ 280 template<class base_duration, boost::int64_t frac_of_second> 281 class BOOST_SYMBOL_VISIBLE subsecond_duration : public base_duration 282 { 283 public: 284 typedef typename base_duration::impl_type impl_type; 285 typedef typename base_duration::traits_type traits_type; 286 287 private: 288 // To avoid integer overflow we precompute the duration resolution conversion coefficient (ticket #3471) 289 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,\ 290 "The base duration resolution must be a multiple of the subsecond duration resolution"); 291 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)); 292 293 public: 294 // The argument (ss) must be an integral type 295 template <typename T> subsecond_duration(T const & ss,typename boost::enable_if<boost::is_integral<T>,void>::type * =BOOST_DATE_TIME_NULLPTR)296 BOOST_CXX14_CONSTEXPR explicit subsecond_duration(T const& ss, 297 typename boost::enable_if<boost::is_integral<T>, 298 void>::type* = BOOST_DATE_TIME_NULLPTR) : 299 base_duration(impl_type(traits_type::ticks_per_second >= frac_of_second ? ss * adjustment_ratio : ss / adjustment_ratio)) 300 { 301 } 302 }; 303 304 } } //namespace date_time 305 306 307 308 309 #endif 310 311