1 #ifndef DATE_TIME_TIME_DURATION_HPP___
2 #define DATE_TIME_TIME_DURATION_HPP___
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
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>
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.
32 @param T The subclass type
33 @param rep_type The time resolution traits for this duration type.
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
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) */
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;
59 time_duration() : ticks_(0) {}
60 time_duration(hour_type hours_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))
66 // copy constructor required for dividable<>
67 //! Construct from another time_duration (Copy constructor)
68 time_duration(const time_duration<T, rep_type>& other)
69 : ticks_(other.ticks_)
71 //! Construct from special_values
72 time_duration(special_values sv) : ticks_(impl_type::from_special(sv))
74 //! Returns smallest representable duration
75 static duration_type unit()
77 return duration_type(0,0,0,1);
79 //! Return the number of ticks in a second
80 static tick_type ticks_per_second()
82 return rep_type::res_adjust();
84 //! Provide the resolution of this duration type
85 static time_resolutions resolution()
87 return rep_type::resolution();
89 //! Returns number of hours in the duration
90 hour_type hours() const
92 return static_cast<hour_type>(ticks() / (3600*ticks_per_second()));
94 //! Returns normalized number of minutes
95 min_type minutes() const
97 return static_cast<min_type>((ticks() / (60*ticks_per_second())) % 60);
99 //! Returns normalized number of seconds (0..60)
100 sec_type seconds() const
102 return static_cast<sec_type>((ticks()/ticks_per_second()) % 60);
104 //! Returns total number of seconds truncating any fractional seconds
105 sec_type total_seconds() const
107 return static_cast<sec_type>(ticks() / ticks_per_second());
109 //! Returns total number of milliseconds truncating any fractional seconds
110 tick_type total_milliseconds() const
112 if (ticks_per_second() < 1000) {
113 return ticks() * (static_cast<tick_type>(1000) / ticks_per_second());
115 return ticks() / (ticks_per_second() / static_cast<tick_type>(1000)) ;
117 //! Returns total number of nanoseconds truncating any sub millisecond values
118 tick_type total_nanoseconds() const
120 if (ticks_per_second() < 1000000000) {
121 return ticks() * (static_cast<tick_type>(1000000000) / ticks_per_second());
123 return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000000)) ;
125 //! Returns total number of microseconds truncating any sub microsecond values
126 tick_type total_microseconds() const
128 if (ticks_per_second() < 1000000) {
129 return ticks() * (static_cast<tick_type>(1000000) / ticks_per_second());
131 return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000)) ;
133 //! Returns count of fractional seconds at given resolution
134 fractional_seconds_type fractional_seconds() const
136 return (ticks() % ticks_per_second());
138 //! Returns number of possible digits in fractional seconds
139 static unsigned short num_fractional_digits()
141 return rep_type::num_fractional_digits();
143 duration_type invert_sign() const
145 return duration_type(ticks_ * (-1));
147 bool is_negative() const
151 bool operator<(const time_duration& rhs) const
153 return ticks_ < rhs.ticks_;
155 bool operator==(const time_duration& rhs) const
157 return ticks_ == rhs.ticks_;
159 //! unary- Allows for time_duration td = -td1
160 duration_type operator-()const
162 return duration_type(ticks_ * (-1));
164 duration_type operator-(const duration_type& d) const
166 return duration_type(ticks_ - d.ticks_);
168 duration_type operator+(const duration_type& d) const
170 return duration_type(ticks_ + d.ticks_);
172 duration_type operator/(int divisor) const
174 return duration_type(ticks_ / divisor);
176 duration_type operator-=(const duration_type& d)
178 ticks_ = ticks_ - d.ticks_;
179 return duration_type(ticks_);
181 duration_type operator+=(const duration_type& d)
183 ticks_ = ticks_ + d.ticks_;
184 return duration_type(ticks_);
186 //! Division operations on a duration with an integer.
187 duration_type operator/=(int divisor)
189 ticks_ = ticks_ / divisor;
190 return duration_type(ticks_);
192 //! Multiplication operations an a duration with an integer
193 duration_type operator*(int rhs) const
195 return duration_type(ticks_ * rhs);
197 duration_type operator*=(int divisor)
199 ticks_ = ticks_ * divisor;
200 return duration_type(ticks_);
202 tick_type ticks() const
204 return traits_type::as_number(ticks_);
207 //! Is ticks_ a special value?
208 bool is_special()const
210 if(traits_type::is_adapted())
212 return ticks_.is_special();
218 //! Is duration pos-infinity
219 bool is_pos_infinity()const
221 if(traits_type::is_adapted())
223 return ticks_.is_pos_infinity();
229 //! Is duration neg-infinity
230 bool is_neg_infinity()const
232 if(traits_type::is_adapted())
234 return ticks_.is_neg_infinity();
240 //! Is duration not-a-date-time
241 bool is_not_a_date_time()const
243 if(traits_type::is_adapted())
245 return ticks_.is_nan();
252 //! Used for special_values output
253 impl_type get_rep()const
259 explicit time_duration(impl_type in) : ticks_(in) {}
265 //! Template for instantiating derived adjusting durations
266 /* These templates are designed to work with multiples of
267 * 10 for frac_of_second and resolution adjustment
269 template<class base_duration, boost::int64_t frac_of_second>
270 class BOOST_SYMBOL_VISIBLE subsecond_duration : public base_duration
273 typedef typename base_duration::impl_type impl_type;
274 typedef typename base_duration::traits_type traits_type;
277 // To avoid integer overflow we precompute the duration resolution conversion coefficient (ticket #3471)
278 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,\
279 "The base duration resolution must be a multiple of the subsecond duration resolution");
280 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));
283 // The argument (ss) must be an integral type
284 template <typename T>
285 explicit subsecond_duration(T const& ss,
286 typename boost::enable_if<boost::is_integral<T>, void>::type* = 0) :
287 base_duration(impl_type(traits_type::ticks_per_second >= frac_of_second ? ss * adjustment_ratio : ss / adjustment_ratio))
292 } } //namespace date_time