Line data    Source code

       1             : #ifndef POSIX_TIME_CONVERSION_HPP___
       2             : #define POSIX_TIME_CONVERSION_HPP___
       3             : 
       4             : /* Copyright (c) 2002-2005 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 <cstring>
      13             : #include <boost/cstdint.hpp>
      14             : #include <boost/date_time/posix_time/ptime.hpp>
      15             : #include <boost/date_time/posix_time/posix_time_duration.hpp>
      16             : #include <boost/date_time/filetime_functions.hpp>
      17             : #include <boost/date_time/c_time.hpp>
      18             : #include <boost/date_time/time_resolution_traits.hpp> // absolute_value
      19             : #include <boost/date_time/gregorian/conversion.hpp>
      20             : 
      21             : namespace boost {
      22             : 
      23             : namespace posix_time {
      24             : 
      25             :   //! Function that converts a time_t into a ptime.
      26             :   inline
      27             :   ptime from_time_t(std::time_t t)
      28             :   {
      29             :     return ptime(gregorian::date(1970,1,1)) + seconds(static_cast<long>(t));
      30             :   }
      31             : 
      32             :   //! Function that converts a ptime into a time_t
      33             :   inline
      34             :   std::time_t to_time_t(ptime pt)
      35             :   {
      36             :     return (pt - ptime(gregorian::date(1970,1,1))).total_seconds();
      37             :   }
      38             : 
      39             :   //! Convert a time to a tm structure truncating any fractional seconds
      40             :   inline
      41           0 :   std::tm to_tm(const boost::posix_time::ptime& t) {
      42           0 :     std::tm timetm = boost::gregorian::to_tm(t.date());
      43           0 :     boost::posix_time::time_duration td = t.time_of_day();
      44           0 :     timetm.tm_hour = static_cast<int>(td.hours());
      45           0 :     timetm.tm_min = static_cast<int>(td.minutes());
      46           0 :     timetm.tm_sec = static_cast<int>(td.seconds());
      47           0 :     timetm.tm_isdst = -1; // -1 used when dst info is unknown
      48           0 :     return timetm;
      49             :   }
      50             :   //! Convert a time_duration to a tm structure truncating any fractional seconds and zeroing fields for date components
      51             :   inline
      52             :   std::tm to_tm(const boost::posix_time::time_duration& td) {
      53             :     std::tm timetm;
      54             :     std::memset(&timetm, 0, sizeof(timetm));
      55             :     timetm.tm_hour = static_cast<int>(date_time::absolute_value(td.hours()));
      56             :     timetm.tm_min = static_cast<int>(date_time::absolute_value(td.minutes()));
      57             :     timetm.tm_sec = static_cast<int>(date_time::absolute_value(td.seconds()));
      58             :     timetm.tm_isdst = -1; // -1 used when dst info is unknown
      59             :     return timetm;
      60             :   }
      61             : 
      62             :   //! Convert a tm struct to a ptime ignoring is_dst flag
      63             :   inline
      64             :   ptime ptime_from_tm(const std::tm& timetm) {
      65             :     boost::gregorian::date d = boost::gregorian::date_from_tm(timetm);
      66             :     return ptime(d, time_duration(timetm.tm_hour, timetm.tm_min, timetm.tm_sec));
      67             :   }
      68             : 
      69             : 
      70             : #if defined(BOOST_HAS_FTIME)
      71             : 
      72             :   //! Function to create a time object from an initialized FILETIME struct.
      73             :   /*! Function to create a time object from an initialized FILETIME struct.
      74             :    * A FILETIME struct holds 100-nanosecond units (0.0000001). When
      75             :    * built with microsecond resolution the FILETIME's sub second value
      76             :    * will be truncated. Nanosecond resolution has no truncation.
      77             :    *
      78             :    * \note FILETIME is part of the Win32 API, so it is not portable to non-windows
      79             :    * platforms.
      80             :    *
      81             :    * \note The function is templated on the FILETIME type, so that
      82             :    *       it can be used with both native FILETIME and the ad-hoc
      83             :    *       boost::detail::winapi::FILETIME_ type.
      84             :    */
      85             :   template< typename TimeT, typename FileTimeT >
      86             :   inline
      87             :   TimeT from_ftime(const FileTimeT& ft)
      88             :   {
      89             :     return boost::date_time::time_from_ftime<TimeT>(ft);
      90             :   }
      91             : 
      92             : #endif // BOOST_HAS_FTIME
      93             : 
      94             : } } //namespace boost::posix_time
      95             : 
      96             : 
      97             : 
      98             : 
      99             : #endif
     100             :