Swift
summaryrefslogtreecommitdiffstats
path: root/3rdParty/Boost/boost/date_time/time_duration.hpp
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2009-06-01 08:48:42 (GMT)
committerRemko Tronçon <git@el-tramo.be>2009-06-01 09:24:28 (GMT)
commit2812bddd81f8a1b804c7460f4e14cd0aa393d129 (patch)
treed46294f35150c4f0f43deaf2d31fceaf945ae715 /3rdParty/Boost/boost/date_time/time_duration.hpp
downloadswift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.zip
swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.tar.bz2
Import.
Diffstat (limited to '3rdParty/Boost/boost/date_time/time_duration.hpp')
-rw-r--r--3rdParty/Boost/boost/date_time/time_duration.hpp281
1 files changed, 281 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/date_time/time_duration.hpp b/3rdParty/Boost/boost/date_time/time_duration.hpp
new file mode 100644
index 0000000..4004125
--- /dev/null
+++ b/3rdParty/Boost/boost/date_time/time_duration.hpp
@@ -0,0 +1,281 @@
+#ifndef DATE_TIME_TIME_DURATION_HPP___
+#define DATE_TIME_TIME_DURATION_HPP___
+
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ */
+
+#include "boost/operators.hpp"
+#include "boost/date_time/time_defs.hpp"
+#include "boost/date_time/special_defs.hpp"
+#include "boost/date_time/compiler_config.hpp"
+
+namespace boost {
+namespace date_time {
+
+
+ //! Represents some amount of elapsed time measure to a given resolution
+ /*! This class represents a standard set of capabilities for all
+ counted time durations. Time duration implementations should derive
+ from this class passing their type as the first template parameter.
+ This design allows the subclass duration types to provide custom
+ construction policies or other custom features not provided here.
+
+ @param T The subclass type
+ @param rep_type The time resolution traits for this duration type.
+ */
+ template<class T, typename rep_type>
+ class time_duration : private
+ boost::less_than_comparable<T
+ , boost::equality_comparable<T
+ > >
+ /* dividable, addable, and subtractable operator templates
+ * won't work with this class (MSVC++ 6.0). return type
+ * from '+=' is different than expected return type
+ * from '+'. multipliable probably wont work
+ * either (haven't tried) */
+ {
+ public:
+ typedef T duration_type; //the subclass
+ typedef rep_type traits_type;
+ typedef typename rep_type::day_type day_type;
+ typedef typename rep_type::hour_type hour_type;
+ typedef typename rep_type::min_type min_type;
+ typedef typename rep_type::sec_type sec_type;
+ typedef typename rep_type::fractional_seconds_type fractional_seconds_type;
+ typedef typename rep_type::tick_type tick_type;
+ typedef typename rep_type::impl_type impl_type;
+
+ 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) :
+ ticks_(rep_type::to_tick_count(hours_in,minutes_in,seconds_in,frac_sec_in))
+ {}
+ // copy constructor required for dividable<>
+ //! Construct from another time_duration (Copy constructor)
+ time_duration(const time_duration<T, rep_type>& other)
+ : ticks_(other.ticks_)
+ {}
+ //! Construct from special_values
+ time_duration(special_values sv) : ticks_(impl_type::from_special(sv))
+ {}
+ //! Returns smallest representable duration
+ static duration_type unit()
+ {
+ return duration_type(0,0,0,1);
+ }
+ //! Return the number of ticks in a second
+ static tick_type ticks_per_second()
+ {
+ return rep_type::res_adjust();
+ }
+ //! Provide the resolution of this duration type
+ static time_resolutions resolution()
+ {
+ return rep_type::resolution();
+ }
+ //! Returns number of hours in the duration
+ hour_type hours() const
+ {
+ return static_cast<hour_type>(ticks() / (3600*ticks_per_second()));
+ }
+ //! Returns normalized number of minutes
+ min_type minutes() const
+ {
+ return static_cast<min_type>((ticks() / (60*ticks_per_second())) % 60);
+ }
+ //! Returns normalized number of seconds (0..60)
+ sec_type seconds() const
+ {
+ return static_cast<sec_type>((ticks()/ticks_per_second()) % 60);
+ }
+ //! Returns total number of seconds truncating any fractional seconds
+ sec_type total_seconds() const
+ {
+ return static_cast<sec_type>(ticks() / ticks_per_second());
+ }
+ //! Returns total number of milliseconds truncating any fractional seconds
+ tick_type total_milliseconds() const
+ {
+ if (ticks_per_second() < 1000) {
+ return ticks() * (static_cast<tick_type>(1000) / ticks_per_second());
+ }
+ return ticks() / (ticks_per_second() / static_cast<tick_type>(1000)) ;
+ }
+ //! Returns total number of nanoseconds truncating any sub millisecond values
+ tick_type total_nanoseconds() const
+ {
+ if (ticks_per_second() < 1000000000) {
+ return ticks() * (static_cast<tick_type>(1000000000) / ticks_per_second());
+ }
+ return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000000)) ;
+ }
+ //! Returns total number of microseconds truncating any sub microsecond values
+ tick_type total_microseconds() const
+ {
+ if (ticks_per_second() < 1000000) {
+ return ticks() * (static_cast<tick_type>(1000000) / ticks_per_second());
+ }
+ return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000)) ;
+ }
+ //! Returns count of fractional seconds at given resolution
+ fractional_seconds_type fractional_seconds() const
+ {
+ return (ticks() % ticks_per_second());
+ }
+ //! Returns number of possible digits in fractional seconds
+ static unsigned short num_fractional_digits()
+ {
+ return rep_type::num_fractional_digits();
+ }
+ duration_type invert_sign() const
+ {
+ return duration_type(ticks_ * (-1));
+ }
+ bool is_negative() const
+ {
+ return ticks_ < 0;
+ }
+ bool operator<(const time_duration& rhs) const
+ {
+ return ticks_ < rhs.ticks_;
+ }
+ bool operator==(const time_duration& rhs) const
+ {
+ return ticks_ == rhs.ticks_;
+ }
+ //! unary- Allows for time_duration td = -td1
+ duration_type operator-()const
+ {
+ return duration_type(ticks_ * (-1));
+ }
+ duration_type operator-(const duration_type& d) const
+ {
+ return duration_type(ticks_ - d.ticks_);
+ }
+ duration_type operator+(const duration_type& d) const
+ {
+ return duration_type(ticks_ + d.ticks_);
+ }
+ duration_type operator/(int divisor) const
+ {
+ return duration_type(ticks_ / divisor);
+ }
+ duration_type operator-=(const duration_type& d)
+ {
+ ticks_ = ticks_ - d.ticks_;
+ return duration_type(ticks_);
+ }
+ duration_type operator+=(const duration_type& d)
+ {
+ ticks_ = ticks_ + d.ticks_;
+ return duration_type(ticks_);
+ }
+ //! Division operations on a duration with an integer.
+ duration_type operator/=(int divisor)
+ {
+ ticks_ = ticks_ / divisor;
+ return duration_type(ticks_);
+ }
+ //! Multiplication operations an a duration with an integer
+ duration_type operator*(int rhs) const
+ {
+ return duration_type(ticks_ * rhs);
+ }
+ duration_type operator*=(int divisor)
+ {
+ ticks_ = ticks_ * divisor;
+ return duration_type(ticks_);
+ }
+ tick_type ticks() const
+ {
+ return traits_type::as_number(ticks_);
+ }
+
+ //! Is ticks_ a special value?
+ bool is_special()const
+ {
+ if(traits_type::is_adapted())
+ {
+ return ticks_.is_special();
+ }
+ else{
+ return false;
+ }
+ }
+ //! Is duration pos-infinity
+ bool is_pos_infinity()const
+ {
+ if(traits_type::is_adapted())
+ {
+ return ticks_.is_pos_infinity();
+ }
+ else{
+ return false;
+ }
+ }
+ //! Is duration neg-infinity
+ bool is_neg_infinity()const
+ {
+ if(traits_type::is_adapted())
+ {
+ return ticks_.is_neg_infinity();
+ }
+ else{
+ return false;
+ }
+ }
+ //! Is duration not-a-date-time
+ bool is_not_a_date_time()const
+ {
+ if(traits_type::is_adapted())
+ {
+ return ticks_.is_nan();
+ }
+ else{
+ return false;
+ }
+ }
+
+ //! Used for special_values output
+ impl_type get_rep()const
+ {
+ return ticks_;
+ }
+
+ protected:
+ explicit time_duration(impl_type in) : ticks_(in) {};
+ impl_type ticks_;
+ };
+
+
+
+ //! Template for instantiating derived adjusting durations
+ /* These templates are designed to work with multiples of
+ * 10 for frac_of_second and resoultion adjustment
+ */
+ template<class base_duration, boost::int64_t frac_of_second>
+ class subsecond_duration : public base_duration
+ {
+ public:
+ typedef typename base_duration::traits_type traits_type;
+ explicit subsecond_duration(boost::int64_t ss) :
+ base_duration(0,0,0,ss*traits_type::res_adjust()/frac_of_second)
+ {}
+ };
+
+
+
+} } //namespace date_time
+
+
+
+
+#endif
+