passenger 2.2.15 → 3.0.0.pre1

data/ext/boost/date_time/int_adapter.hpp

@@ -6,7 +6,7 @@
  * 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) $
+ * $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $
  */
 
 
@@ -14,7 +14,9 @@
 #include "boost/limits.hpp" //work around compilers without limits
 #include "boost/date_time/special_defs.hpp"
 #include "boost/date_time/locale_config.hpp"
-#include <iostream>
+#ifndef BOOST_DATE_TIME_NO_LOCALE
+#  include <ostream>
+#endif
 
 namespace boost {
 namespace date_time {

data/ext/boost/date_time/microsec_time_clock.hpp

@@ -6,7 +6,7 @@
  * 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) $
+ * $Date: 2009-06-04 07:36:43 -0400 (Thu, 04 Jun 2009) $
  */
 
 
@@ -14,22 +14,19 @@
   This file contains a high resolution time clock implementation.
 */
 
+#include <boost/cstdint.hpp>
+#include <boost/shared_ptr.hpp>
 #include <boost/detail/workaround.hpp>
-#include "boost/date_time/c_time.hpp"
-#include "boost/date_time/time_clock.hpp"
-#include "boost/cstdint.hpp"
-#include "boost/shared_ptr.hpp"
-
-#ifdef BOOST_HAS_FTIME
-#include <windows.h>
-#endif
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/c_time.hpp>
+#include <boost/date_time/time_clock.hpp>
+#include <boost/date_time/filetime_functions.hpp>
 
 #ifdef BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
 
 namespace boost {
 namespace date_time {
 
-
   //! A clock providing microsecond level resolution
   /*! A high precision clock that measures the local time
    *  at a resolution up to microseconds and adjusts to the
@@ -41,6 +38,10 @@ namespace date_time {
   template<class time_type>
   class microsec_clock
   {
+  private:
+    //! Type for the function used to convert time_t to tm
+    typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);
+
   public:
     typedef typename time_type::date_type date_type;
     typedef typename time_type::time_duration_type time_duration_type;
@@ -49,7 +50,8 @@ namespace date_time {
     //! return a local time object for the given zone, based on computer clock
     //JKG -- looks like we could rewrite this against universal_time
     template<class time_zone_type>
-    static time_type local_time(shared_ptr<time_zone_type> tz_ptr) {
+    static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
+    {
       typedef typename time_type::utc_time_type utc_time_type;
       typedef second_clock<utc_time_type> second_clock;
       // we'll need to know the utc_offset this machine has
@@ -62,137 +64,57 @@ namespace date_time {
       return time_type(utc_time, tz_ptr);
     }
 
-
-  private:
-    // we want this enum available for both platforms yet still private
-    enum TZ_FOR_CREATE { LOCAL, GMT };
-    
-  public:
-
-#ifdef BOOST_HAS_GETTIMEOFDAY
-    //! Return the local time based on computer clock settings
-    static time_type local_time() {
-      return create_time(LOCAL);
+    //! Returns the local time based on computer clock settings
+    static time_type local_time()
+    {
+      return create_time(&c_time::localtime);
     }
 
-    //! Get the current day in universal date as a ymd_type
+    //! Returns the UTC time based on computer settings
     static time_type universal_time()
     {
-      return create_time(GMT);
+      return create_time(&c_time::gmtime);
     }
 
   private:
-    static time_type create_time(TZ_FOR_CREATE tz) {
+    static time_type create_time(time_converter converter)
+    {
+#ifdef BOOST_HAS_GETTIMEOFDAY
       timeval tv;
       gettimeofday(&tv, 0); //gettimeofday does not support TZ adjust on Linux.
       std::time_t t = tv.tv_sec;
-      boost::uint32_t fs = tv.tv_usec;
-      std::tm curr, *curr_ptr = 0;
-      if (tz == LOCAL) {
-        curr_ptr = c_time::localtime(&t, &curr);
-      } else {
-        curr_ptr = c_time::gmtime(&t, &curr);
-      }
-      date_type d(curr_ptr->tm_year + 1900,
-                  curr_ptr->tm_mon + 1,
-                  curr_ptr->tm_mday);
-      //The following line will adjusts the fractional second tick in terms
-      //of the current time system.  For example, if the time system
-      //doesn't support fractional seconds then res_adjust returns 0
-      //and all the fractional seconds return 0.
-      int adjust = resolution_traits_type::res_adjust()/1000000;
-
-      time_duration_type td(curr_ptr->tm_hour,
-                            curr_ptr->tm_min,
-                            curr_ptr->tm_sec,
-                            fs*adjust);
-      return time_type(d,td);
-
-    }
-#endif // BOOST_HAS_GETTIMEOFDAY
-
-#ifdef BOOST_HAS_FTIME
-    //! Return the local time based on computer clock settings
-    static time_type local_time() {
-      FILETIME ft;
-      #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-      // Some runtime library implementations expect local times as the norm for ctime.
-      FILETIME ft_utc;
-      GetSystemTimeAsFileTime(&ft_utc);
-      FileTimeToLocalFileTime(&ft_utc,&ft);
-      #elif defined(BOOST_NO_GETSYSTEMTIMEASFILETIME)
-      SYSTEMTIME st;
-      GetSystemTime( &st );
-      SystemTimeToFileTime( &st, &ft );
-      #else
-      GetSystemTimeAsFileTime(&ft);
-      #endif
-      return create_time(ft, LOCAL);
-    }
-    
-    //! Return the UTC time based on computer settings
-    static time_type universal_time() {
-      FILETIME ft;
-      #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-      // Some runtime library implementations expect local times as the norm for ctime.
-      FILETIME ft_utc;
-      GetSystemTimeAsFileTime(&ft_utc);
-      FileTimeToLocalFileTime(&ft_utc,&ft);
-      #elif defined(BOOST_NO_GETSYSTEMTIMEASFILETIME)
-      SYSTEMTIME st;
-      GetSystemTime( &st );
-      SystemTimeToFileTime( &st, &ft );
-      #else
-      GetSystemTimeAsFileTime(&ft);
-      #endif
-      return create_time(ft, GMT);
-    }
-
-  private:
-    static time_type create_time(FILETIME& ft, TZ_FOR_CREATE tz) {
-      // offset is difference (in 100-nanoseconds) from
-      // 1970-Jan-01 to 1601-Jan-01
-      boost::uint64_t c1 = 27111902;
-      boost::uint64_t c2 = 3577643008UL; // 'UL' removes compiler warnings
-      const boost::uint64_t OFFSET = (c1 << 32) + c2;
-
-      boost::uint64_t filetime = ft.dwHighDateTime;
-      filetime = filetime << 32;
-      filetime += ft.dwLowDateTime;
-      filetime -= OFFSET;
-      // filetime now holds 100-nanoseconds since 1970-Jan-01
-
+      boost::uint32_t sub_sec = tv.tv_usec;
+#elif defined(BOOST_HAS_FTIME)
+      winapi::file_time ft;
+      winapi::get_system_time_as_file_time(ft);
+      uint64_t micros = winapi::file_time_to_microseconds(ft); // it will not wrap, since ft is the current time
+                                                               // and cannot be before 1970-Jan-01
+      std::time_t t = static_cast<std::time_t>(micros / 1000000UL); // seconds since epoch
       // microseconds -- static casts supress warnings
-      boost::uint32_t sub_sec = static_cast<boost::uint32_t>((filetime % 10000000) / 10);
-
-      std::time_t t = static_cast<time_t>(filetime / 10000000); // seconds since epoch
-      
-      std::tm curr, *curr_ptr = 0;
-      if (tz == LOCAL) {
-        curr_ptr = c_time::localtime(&t, &curr);
-      }
-      else {
-        curr_ptr = c_time::gmtime(&t, &curr);
-      }
+      boost::uint32_t sub_sec = static_cast<boost::uint32_t>(micros % 1000000UL);
+#else
+#error Internal Boost.DateTime error: BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK is defined, however neither gettimeofday nor FILETIME support is detected.
+#endif
+
+      std::tm curr;
+      std::tm* curr_ptr = converter(&t, &curr);
       date_type d(curr_ptr->tm_year + 1900,
                   curr_ptr->tm_mon + 1,
                   curr_ptr->tm_mday);
 
-      //The following line will adjusts the fractional second tick in terms
+      //The following line will adjust the fractional second tick in terms
       //of the current time system.  For example, if the time system
       //doesn't support fractional seconds then res_adjust returns 0
       //and all the fractional seconds return 0.
-      int adjust = static_cast<int>(resolution_traits_type::res_adjust()/1000000);
+      int adjust = static_cast< int >(resolution_traits_type::res_adjust() / 1000000);
 
       time_duration_type td(curr_ptr->tm_hour,
                             curr_ptr->tm_min,
                             curr_ptr->tm_sec,
                             sub_sec * adjust);
-                            //st.wMilliseconds * adjust);
-      return time_type(d,td);
 
+      return time_type(d,td);
     }
-#endif // BOOST_HAS_FTIME
   };
 
 

data/ext/boost/date_time/period_parser.hpp

@@ -7,11 +7,12 @@
  * 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) $
+ * $Date: 2008-11-13 15:10:23 -0500 (Thu, 13 Nov 2008) $
  */
 
-#include "boost/date_time/string_parse_tree.hpp"
-#include "boost/date_time/string_convert.hpp"
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/string_parse_tree.hpp>
+#include <boost/date_time/string_convert.hpp>
 
 
 namespace boost { namespace date_time {
@@ -32,7 +33,7 @@ namespace boost { namespace date_time {
    * where the date format is controlled by the date facet
    */
   template<class date_type, typename CharT>
-  class period_parser { 
+  class period_parser {
   public:
     typedef std::basic_string<CharT> string_type;
     typedef CharT                    char_type;
@@ -41,7 +42,7 @@ namespace boost { namespace date_time {
     typedef string_parse_tree<CharT> parse_tree_type;
     typedef typename parse_tree_type::parse_match_result_type match_results;
     typedef std::vector<std::basic_string<CharT> > collection_type;
-    
+
     static const char_type default_period_separator[2];
     static const char_type default_period_start_delimeter[2];
     static const char_type default_period_open_range_end_delimeter[2];
@@ -50,12 +51,12 @@ namespace boost { namespace date_time {
     enum period_range_option { AS_OPEN_RANGE, AS_CLOSED_RANGE };
 
     //! Constructor that sets up period parser options
-    period_parser(period_range_option range_option = AS_CLOSED_RANGE, 
-                  const char_type* const period_separator = default_period_separator, 
+    period_parser(period_range_option range_opt = AS_CLOSED_RANGE,
+                  const char_type* const period_separator = default_period_separator,
                   const char_type* const period_start_delimeter = default_period_start_delimeter,
                   const char_type* const period_open_range_end_delimeter = default_period_open_range_end_delimeter,
                   const char_type* const period_closed_range_end_delimeter = default_period_closed_range_end_delimeter)
-      : m_range_option(range_option)
+      : m_range_option(range_opt)
     {
       delimiters.push_back(string_type(period_separator));
       delimiters.push_back(string_type(period_start_delimeter));
@@ -119,13 +120,13 @@ namespace boost { namespace date_time {
     period_type get_period(stream_itr_type& sitr, 
                            stream_itr_type& stream_end,
                            std::ios_base& a_ios, 
-                           const period_type& p,
+                           const period_type& /* p */,
                            const duration_type& dur_unit,
                            const facet_type& facet) const 
     {
       // skip leading whitespace
       while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-     
+
       typedef typename period_type::point_type point_type;
       point_type p1(not_a_date_time), p2(not_a_date_time);
 
@@ -144,14 +145,14 @@ namespace boost { namespace date_time {
       else {
         consume_delim(sitr, stream_end, delimiters[OPEN_END]);  // end delim
       }
-    
+
       return period_type(p1, p2);
     }
-      
+
   private:
     collection_type delimiters; 
-    period_range_option m_range_option;    
-    
+    period_range_option m_range_option;
+
     enum delim_ids { SEPARATOR, START, OPEN_END, CLOSED_END };
 
     //! throws ios_base::failure if delimiter and parsed data do not match
@@ -170,7 +171,8 @@ namespace boost { namespace date_time {
         ++sitr;
       }
       if(s != delim) {
-        throw std::ios_base::failure("Parse failed. Expected '" + convert_string_type<char_type,char>(delim) + "' but found '" + convert_string_type<char_type,char>(s) + "'");
+        boost::throw_exception(std::ios_base::failure("Parse failed. Expected '"
+          + convert_string_type<char_type,char>(delim) + "' but found '" + convert_string_type<char_type,char>(s) + "'"));
       }
     }
   };

data/ext/boost/date_time/posix_time/conversion.hpp

@@ -2,18 +2,19 @@
 #define POSIX_TIME_CONVERSION_HPP___
 
 /* Copyright (c) 2002-2005 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * 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) $
+ * $Date: 2010-01-10 14:17:23 -0500 (Sun, 10 Jan 2010) $
  */
 
-#include "boost/date_time/posix_time/ptime.hpp"
-#include "boost/date_time/posix_time/posix_time_duration.hpp"
-#include "boost/date_time/filetime_functions.hpp"
-#include "boost/date_time/c_time.hpp"
-#include "boost/date_time/gregorian/conversion.hpp"
+#include <boost/date_time/posix_time/ptime.hpp>
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <boost/date_time/filetime_functions.hpp>
+#include <boost/date_time/c_time.hpp>
+#include <boost/date_time/time_resolution_traits.hpp> // absolute_value
+#include <boost/date_time/gregorian/conversion.hpp>
 
 namespace boost {
 
@@ -22,34 +23,28 @@ namespace posix_time {
 
   //! Function that converts a time_t into a ptime.
   inline
-  ptime from_time_t(std::time_t t) 
+  ptime from_time_t(std::time_t t)
   {
     ptime start(gregorian::date(1970,1,1));
     return start + seconds(static_cast<long>(t));
   }
 
-  //! Convert a time to a tm structure truncating any fractional seconds 
+  //! Convert a time to a tm structure truncating any fractional seconds
   inline
   std::tm to_tm(const boost::posix_time::ptime& t) {
     std::tm timetm = boost::gregorian::to_tm(t.date());
     boost::posix_time::time_duration td = t.time_of_day();
-    timetm.tm_hour = td.hours(); 
-    timetm.tm_min = td.minutes(); 
+    timetm.tm_hour = td.hours();
+    timetm.tm_min = td.minutes();
     timetm.tm_sec = td.seconds();
-    timetm.tm_isdst = -1; // -1 used when dst info is unknown 
+    timetm.tm_isdst = -1; // -1 used when dst info is unknown
     return timetm;
   }
-  //! Convert a time_duration to a tm structure truncating any fractional seconds and zeroing fields for date components 
+  //! Convert a time_duration to a tm structure truncating any fractional seconds and zeroing fields for date components
   inline
   std::tm to_tm(const boost::posix_time::time_duration& td) {
-    std::tm timetm;
-    timetm.tm_year = 0;
-    timetm.tm_mon = 0;
-    timetm.tm_mday = 0;
-    timetm.tm_wday = 0;
-    timetm.tm_yday = 0;
-    
-    timetm.tm_hour = date_time::absolute_value(td.hours()); 
+    std::tm timetm = {};
+    timetm.tm_hour = date_time::absolute_value(td.hours());
     timetm.tm_min = date_time::absolute_value(td.minutes());
     timetm.tm_sec = date_time::absolute_value(td.seconds());
     timetm.tm_isdst = -1; // -1 used when dst info is unknown
@@ -65,21 +60,25 @@ namespace posix_time {
 
 
 #if defined(BOOST_HAS_FTIME)
-  
+
   //! Function to create a time object from an initialized FILETIME struct.
   /*! Function to create a time object from an initialized FILETIME struct.
-   * A FILETIME struct holds 100-nanosecond units (0.0000001). When 
-   * built with microsecond resolution the FILETIME's sub second value 
-   * will be truncated. Nanosecond resolution has no truncation. 
+   * A FILETIME struct holds 100-nanosecond units (0.0000001). When
+   * built with microsecond resolution the FILETIME's sub second value
+   * will be truncated. Nanosecond resolution has no truncation.
    *
-   * Note ftime is part of the Win32 API, so it is not portable to non-windows
+   * \note FILETIME is part of the Win32 API, so it is not portable to non-windows
    * platforms.
+   *
+   * \note The function is templated on the FILETIME type, so that
+   *       it can be used with both native FILETIME and the ad-hoc
+   *       boost::date_time::winapi::file_time type.
    */
-  template<class time_type>
+  template< typename TimeT, typename FileTimeT >
   inline
-  time_type from_ftime(const FILETIME& ft)
+  TimeT from_ftime(const FileTimeT& ft)
   {
-    return boost::date_time::time_from_ftime<time_type>(ft);
+    return boost::date_time::time_from_ftime<TimeT>(ft);
   }
 
 #endif // BOOST_HAS_FTIME

data/ext/boost/date_time/posix_time/posix_time_config.hpp

@@ -2,22 +2,22 @@
 #define POSIX_TIME_CONFIG_HPP___
 
 /* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * 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) $
+ * $Date: 2009-06-04 07:52:28 -0400 (Thu, 04 Jun 2009) $
  */
 
-#include "boost/date_time/time_duration.hpp"
-#include "boost/date_time/time_resolution_traits.hpp"
-#include "boost/date_time/gregorian/gregorian_types.hpp"
-#include "boost/date_time/wrapping_int.hpp"
-#include "boost/limits.hpp"
-#include "boost/date_time/compiler_config.hpp"
-#include "boost/cstdint.hpp"
-#include <cmath>
 #include <cstdlib> //for MCW 7.2 std::abs(long long)
+#include <boost/limits.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/config/no_tr1/cmath.hpp>
+#include <boost/date_time/time_duration.hpp>
+#include <boost/date_time/time_resolution_traits.hpp>
+#include <boost/date_time/gregorian/gregorian_types.hpp>
+#include <boost/date_time/wrapping_int.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
 namespace boost {
 namespace posix_time {
@@ -30,7 +30,7 @@ namespace posix_time {
 #define BOOST_DATE_TIME_HAS_MILLISECONDS
 #define BOOST_DATE_TIME_HAS_MICROSECONDS
 #define BOOST_DATE_TIME_HAS_NANOSECONDS
-  typedef date_time::time_resolution_traits<boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::nano, 
+  typedef date_time::time_resolution_traits<boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::nano,
     1000000000, 9 > time_res_traits;
 #else
   // set up conditional test compilations
@@ -38,14 +38,14 @@ namespace posix_time {
 #define BOOST_DATE_TIME_HAS_MICROSECONDS
 #undef  BOOST_DATE_TIME_HAS_NANOSECONDS
   typedef date_time::time_resolution_traits<
-    boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro, 
+    boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
                                             1000000, 6 > time_res_traits;
 
 
 // #undef BOOST_DATE_TIME_HAS_MILLISECONDS
 // #undef BOOST_DATE_TIME_HAS_MICROSECONDS
 // #undef BOOST_DATE_TIME_HAS_NANOSECONDS
-//   typedef date_time::time_resolution_traits<boost::int64_t, boost::date_time::tenth, 
+//   typedef date_time::time_resolution_traits<boost::int64_t, boost::date_time::tenth,
 //                                              10, 0 > time_res_traits;
 
 #endif
@@ -82,8 +82,8 @@ namespace posix_time {
     //Give duration access to ticks constructor -- hide from users
     friend class date_time::time_duration<time_duration, time_res_traits>;
   private:
-    explicit time_duration(impl_type ticks) :
-      date_time::time_duration<time_duration, time_res_traits>(ticks)
+    explicit time_duration(impl_type tick_count) :
+      date_time::time_duration<time_duration, time_res_traits>(tick_count)
     {}
   };
 
@@ -134,7 +134,7 @@ namespace posix_time {
     }
   };
 
-  class posix_time_system_config 
+  class posix_time_system_config
   {
    public:
     typedef simple_time_rep time_rep_type;
@@ -143,7 +143,7 @@ namespace posix_time {
     typedef time_duration time_duration_type;
     typedef time_res_traits::tick_type int_type;
     typedef time_res_traits resolution_traits;
-#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers 
+#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers
 #else
     BOOST_STATIC_CONSTANT(boost::int64_t, tick_per_second = 1000000000);
 #endif
@@ -151,7 +151,7 @@ namespace posix_time {
 
 #else
 
-  class millisec_posix_time_system_config 
+  class millisec_posix_time_system_config
   {
    public:
     typedef boost::int64_t time_rep_type;
@@ -162,7 +162,7 @@ namespace posix_time {
     typedef time_res_traits::tick_type int_type;
     typedef time_res_traits::impl_type impl_type;
     typedef time_res_traits resolution_traits;
-#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers 
+#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers
 #else
     BOOST_STATIC_CONSTANT(boost::int64_t, tick_per_second = 1000000);
 #endif