boost/date_time/microsec_time_clock.hpp

0001 #ifndef DATE_TIME_HIGHRES_TIME_CLOCK_HPP___
0002 #define DATE_TIME_HIGHRES_TIME_CLOCK_HPP___
0003
0004 /* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
0005  * Use, modification and distribution is subject to the
0006  * Boost Software License, Version 1.0. (See accompanying
0007  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
0008  * Author: Jeff Garland, Bart Garst
0009  * $Date$
0010  */
0011
0012
0013 /*! @file microsec_time_clock.hpp
0014   This file contains a high resolution time clock implementation.
0015 */
0016
0017 #include <boost/cstdint.hpp>
0018 #include <boost/shared_ptr.hpp>
0019 #include <boost/detail/workaround.hpp>
0020 #include <boost/date_time/compiler_config.hpp>
0021 #include <boost/date_time/c_time.hpp>
0022 #include <boost/date_time/time_clock.hpp>
0023 #if defined(BOOST_HAS_FTIME)
0024 #include <boost/winapi/time.hpp>
0025 #endif
0026
0027 #ifdef BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
0028
0029 namespace boost {
0030 namespace date_time {
0031
0032   //! A clock providing microsecond level resolution
0033   /*! A high precision clock that measures the local time
0034    *  at a resolution up to microseconds and adjusts to the
0035    *  resolution of the time system.  For example, for the
0036    *  a library configuration with nano second resolution,
0037    *  the last 3 places of the fractional seconds will always
0038    *  be 000 since there are 1000 nano-seconds in a micro second.
0039    */
0040   template<class time_type>
0041   class microsec_clock
0042   {
0043   private:
0044     //! Type for the function used to convert time_t to tm
0045     typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);
0046
0047   public:
0048     typedef typename time_type::date_type date_type;
0049     typedef typename time_type::time_duration_type time_duration_type;
0050     typedef typename time_duration_type::rep_type resolution_traits_type;
0051
0052     //! return a local time object for the given zone, based on computer clock
0053     //JKG -- looks like we could rewrite this against universal_time
0054     template<class time_zone_type>
0055     static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
0056     {
0057       typedef typename time_type::utc_time_type utc_time_type;
0058       typedef second_clock<utc_time_type> second_clock;
0059       // we'll need to know the utc_offset this machine has
0060       // in order to get a utc_time_type set to utc
0061       utc_time_type utc_time = second_clock::universal_time();
0062       time_duration_type utc_offset = second_clock::local_time() - utc_time;
0063       // use micro clock to get a local time with sub seconds
0064       // and adjust it to get a true utc time reading with sub seconds
0065       utc_time = microsec_clock<utc_time_type>::local_time() - utc_offset;
0066       return time_type(utc_time, tz_ptr);
0067     }
0068
0069     //! Returns the local time based on computer clock settings
0070     static time_type local_time()
0071     {
0072       return create_time(&c_time::localtime);
0073     }
0074
0075     //! Returns the UTC time based on computer settings
0076     static time_type universal_time()
0077     {
0078       return create_time(&c_time::gmtime);
0079     }
0080
0081   private:
0082     static time_type create_time(time_converter converter)
0083     {
0084 #ifdef BOOST_HAS_GETTIMEOFDAY
0085       timeval tv;
0086       gettimeofday(&tv, 0); //gettimeofday does not support TZ adjust on Linux.
0087       std::time_t t = tv.tv_sec;
0088       boost::uint32_t sub_sec = tv.tv_usec;
0089 #elif defined(BOOST_HAS_FTIME)
0090       boost::winapi::FILETIME_ ft;
0091       boost::winapi::GetSystemTimeAsFileTime(&ft);
0092 #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
0093       // Some runtime library implementations expect local times as the norm for ctime functions.
0094       {
0095         boost::winapi::FILETIME_ local_ft;
0096         boost::winapi::FileTimeToLocalFileTime(&ft, &local_ft);
0097         ft = local_ft;
0098       }
0099 #endif
0100
0101       boost::uint64_t micros = file_time_to_microseconds(ft); // it will not wrap, since ft is the current time
0102                                                               // and cannot be before 1970-Jan-01
0103       std::time_t t = static_cast<std::time_t>(micros / 1000000UL); // seconds since epoch
0104       // microseconds -- static casts suppress warnings
0105       boost::uint32_t sub_sec = static_cast<boost::uint32_t>(micros % 1000000UL);
0106 #else
0107 #error Internal Boost.DateTime error: BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK is defined, however neither gettimeofday nor FILETIME support is detected.
0108 #endif
0109
0110       std::tm curr;
0111       std::tm* curr_ptr = converter(&t, &curr);
0112       date_type d(static_cast< typename date_type::year_type::value_type >(curr_ptr->tm_year + 1900),
0113                   static_cast< typename date_type::month_type::value_type >(curr_ptr->tm_mon + 1),
0114                   static_cast< typename date_type::day_type::value_type >(curr_ptr->tm_mday));
0115
0116       //The following line will adjust the fractional second tick in terms
0117       //of the current time system.  For example, if the time system
0118       //doesn't support fractional seconds then res_adjust returns 0
0119       //and all the fractional seconds return 0.
0120       int adjust = static_cast< int >(resolution_traits_type::res_adjust() / 1000000);
0121
0122       time_duration_type td(static_cast< typename time_duration_type::hour_type >(curr_ptr->tm_hour),
0123                             static_cast< typename time_duration_type::min_type >(curr_ptr->tm_min),
0124                             static_cast< typename time_duration_type::sec_type >(curr_ptr->tm_sec),
0125                             sub_sec * adjust);
0126
0127       return time_type(d,td);
0128     }
0129
0130 #if defined(BOOST_HAS_FTIME)
0131     /*!
0132      * The function converts file_time into number of microseconds elapsed since 1970-Jan-01
0133      *
0134      * \note Only dates after 1970-Jan-01 are supported. Dates before will be wrapped.
0135      */
0136     static boost::uint64_t file_time_to_microseconds(boost::winapi::FILETIME_ const& ft)
0137     {
0138       // shift is difference between 1970-Jan-01 & 1601-Jan-01
0139       // in 100-nanosecond units
0140       const boost::uint64_t shift = 116444736000000000ULL; // (27111902 << 32) + 3577643008
0141
0142       // 100-nanos since 1601-Jan-01
0143       boost::uint64_t ft_as_integer = (static_cast< boost::uint64_t >(ft.dwHighDateTime) << 32) | static_cast< boost::uint64_t >(ft.dwLowDateTime);
0144
0145       ft_as_integer -= shift; // filetime is now 100-nanos since 1970-Jan-01
0146       return (ft_as_integer / 10U); // truncate to microseconds
0147     }
0148 #endif
0149   };
0150
0151
0152 } } //namespace date_time
0153
0154 #endif //BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
0155
0156
0157 #endif
0158