PageRenderTime 43ms CodeModel.GetById 19ms app.highlight 20ms RepoModel.GetById 1ms app.codeStats 1ms

/Src/Dependencies/Boost/boost/date_time/time_duration.hpp

http://hadesmem.googlecode.com/
C++ Header | 282 lines | 213 code | 20 blank | 49 comment | 8 complexity | 1ca3430481a6496091c0153daa1d713b MD5 | raw file
  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 18:24:49 +1000 (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
 18namespace boost {
 19namespace 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